帮看一简单代码

Question

class T implements Runnable{
  int num=0;
  String s = new String();
  public void run(){
     System.out.println(Thread.currentThread().getName()); 
     s = "hello"; //请问，这一句加不加对结果应该没什么影响吧？
     synchronized(s){
      num++;
      try{
          Thread.sleep(100);
      }catch(InterruptedException e){
         e.getMessage();
      }
      print(num);       
   }  
  }
  public void print(int num){
     System.out.println(num);
  }
}public class TestS1{
  public static void main(String args[]){
   T t = new T();
   Thread tt1 = new Thread(t,"tt1");
   Thread tt2 = new Thread(t,"tt2");
   tt1.start();
   tt2.start();
  }
}

Answer 1

不影响。package com.xuz.csdn.july17;import java.util.ArrayList;
import java.util.List;public class ThreadTest {

public static void main(String[] args) {
List<String> list = new ArrayList<String>();
new Thread(new MyThread(list)).start();
new Thread(new MyThread(list)).start();
}}class MyThread implements Runnable { List<String> myList ;
String lock = new String();

public MyThread(List<String> inList){
myList = inList;
}

@Override
public void run() {
String myName = Thread.currentThread().getName();

lock = "hello";
while (true) {
synchronized (lock) {
myList.add("1");
System.out.println(myName + " size is : " + myList.size() + "," + myList);
}

try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

}
你可以试着注释掉lock.我觉得s = "hello"; 就是让s指向一个内存常量区域而已，还是同一个对象，
如果你 s = new String("hello");就不好说了。

Answer 2

synchronized(s)//这句是指以s作为对象锁，你写不写s = "hello"没什么影响

Answer 3

这时候两个线程在执行synchronized(s){...}的时候，获得的对象锁是一定不同还是有可能相同？
应该是一定不同吧？应为s引用指向已发生改变了。

Answer 4

你理解的对不对我不清楚，不知道你怎么理解的。我想说的是你想用s来同步两个线程是不可能的，除非这样static String s = new String();

Answer 5

或者String lock = "";这样也行，但是这样写依赖了“String的内存限定”,而这不是java规范中必须遵守的规则，所以这样写是不对的。欢迎指正。

Answer 6

        new Thread(new MyThread(list)).start();
        new Thread(new MyThread(list)).start();//这里的s变量都是单独的，意思就是你没必要在run中使用
synchronized (lock) {}