【讨论醒目】我出100分，请大家进来讨论讨论synchronized后分别跟this和*.class的代码段有何异同。up有分

Question

synchronized的三种用法：
1: 基于Object的instance
2: 基于Class的
3: 基于某个对象的
我想你大概想说前两种之间的区别吧，呵呵，值得讨论讨论

Answer 1

再次回来，对synchronized语句和对象的锁定作一个总结：
锁是和对象相关联的，每个对象有一把锁
为了执行synchronized语句，线程必须能够获得synchronized语句中表达式指定的对象的锁
一个对象只有一把锁，被一个线程获得之后它就不再拥有这把锁
线程在执行完synchronized语句后，将获得锁交还给对象
在方法前面加上synchronized修饰符即可以将一个方法声明为同步化方法。同步化方法在执行之前获得一个锁。如果这是一个类方法，那么获得的锁是和声明方法的类相关的Class类对象的锁。如果这是一个实例方法，那么此锁是this对象的锁。

Answer 2

将一个方法声明为同步化方法，那么在该方法被执行期间，别的需要得到对象级的锁的代码及方法都不能执行，所以，我们应该尽量让同步用得其所，不然，效率会受比较大的影响，如下代码：public class mainThread
    implements Runnable {
  static int i = 0;
  public static void main(String args[]) {
    mainThread main = new mainThread();
  }  public mainThread() {
    Thread t1 = new Thread(this, "1");
    t1.start();
    Thread t2 = new Thread(this, "2");
    t2.start();
    Thread t3 = new Thread(this, "3");
    t3.start();
    Thread t4 = new Thread(this, "4");
    t4.start();
    Thread t5 = new Thread(this, "5");
    t5.start();
    Thread t6 = new Thread(this, "6");
    t6.start();  }  public void t1() {
    synchronized (this) {
      while (true) {
        i = ++i;
        try {
          Thread.sleep(1000);
        }
        catch (Exception e) {}
        System.out.println(Thread.currentThread().getName()+" "+i);
      }
    }
  }  public void t2() {
    String s = "*********";
    synchronized (s) {-----------------想一想，为什么不将该方法声明为同步呢？
      while (true) {
        try {
          Thread.sleep(500);
        }
        catch (Exception e) {}
        System.out.println(Thread.currentThread().getName() + " " + s);
      }
    }
  }  public void run() {
    if (Thread.currentThread().getName().equals("1")) {
      t1();-------------如果都声明为同步化方法，那么这里将不会被执行到
    }
    else {
      t2();
    }
  }
}

Answer 3

至于类似于“synchronized(object.class){}”，的代码段的同步，我觉得和synchronized(object.class){}的区别在于：在synchronized(object.class){}中不能使用wait，notify，yield等对象上的方法。

Answer 4

this把谁调用的就把谁当成对象了。*.class就指定了。

Answer 5

void method(){
  synchronized(this){
   //...
  }
}
同
synchronized void method(){
  //...
}而
void method(){
  synchronized(TheClass.class){
     //...
  }
}
同
synchronized static void method(){
   //...
}java中每个类都有一个隐含的静态成员class，类型为Class，这是java语言支持的功能，目的是为了支持RTTI；
当synchronized用于static方法时，表示对该类隐含静态成员：class进行加锁。

Answer 6

将一个方法声明为同步化方法，那么在该方法被执行期间，别的需要得到对象级的锁的代码及方法都不能执行，所以，我们应该尽量让同步用得其所，不然，效率会受比较大的影响，如下代码：public class mainThread
    implements Runnable {
  static int i = 0;
  public static void main(String args[]) {
    mainThread main = new mainThread();
  }  public mainThread() {
    Thread t1 = new Thread(this, "1");
    t1.start();
    Thread t2 = new Thread(this, "2");
    t2.start();
    Thread t3 = new Thread(this, "3");
    t3.start();
    Thread t4 = new Thread(this, "4");
    t4.start();
    Thread t5 = new Thread(this, "5");
    t5.start();
    Thread t6 = new Thread(this, "6");
    t6.start();  }  public void t1() {
    synchronized (this) {
      while (true) {
        i = ++i;
        try {
          Thread.sleep(1000);
        }
        catch (Exception e) {}
        System.out.println(Thread.currentThread().getName()+" "+i);
      }
    }
  }  public void t2() {
    String s = "*********";
    synchronized (s) {-----------------想一想，为什么不将该方法声明为同步呢？
      while (true) {
        try {
          Thread.sleep(500);
        }
        catch (Exception e) {}
        System.out.println(Thread.currentThread().getName() + " " + s);
      }
    }
  }  public void run() {
    if (Thread.currentThread().getName().equals("1")) {
      t1();-------------如果都声明为同步化方法，那么这里将不会被执行到
    }
    else {
      t2();
    }
  }
}

Answer 7

简单的说就是synchronized这个线程同步的关键字,如果是用在方法的同步的话,那么它默认的监听就是this这个对象,如果你是写成
synchronized()
{
 } 
来把要同步的代码包含起来,那么必须给它赋一个对像,如果多个线程都监听到同一个对像那就同步啦!

Answer 8

to qlampskyface：在synchronized(object.class){}中不能使用wait，notify，yield等对象上的方法。能不能加以解释啊？

Answer 9

是因为同步的级别已经不是对象级了，而是对该类所有的成员，包括静态和非静态的。线程也不再因为wait而等待某一个对象了。说得形象一点，不管该类创建了多少个对象，一次也只能是一个线程进入，wait等属于对象级别的方法就不能对整个类起作用了。举个例子：public class mainThread extends Thread{
  int i=0;
  public static void main(String args[]){
    mainThread m1 = new mainThread();
    mainThread m2 = new mainThread();
    mainThread m3 = new mainThread();
    mainThread m4 = new mainThread();
    mainThread m5 = new mainThread();
    mainThread m6 = new mainThread();
    m1.start();
    m2.start();
    m3.start();
    m4.start();
    m5.start();
    m6.start();
  }
  public void t1(){
    int temp=i;
    temp=i+1;
    try{
      Thread.sleep(500);
    }
    catch(Exception e){}
    i=temp;
    //每个线程都进入各自的t1()方法，分别打印各自的i
    System.out.println(Thread.currentThread().getName()+" "+i);
  }
  public void run(){
    synchronized(this){
      while (true) {
        t1();
      }
    }
  }
 }
结果如：
Thread-1 1
Thread-2 1
Thread-3 1
Thread-4 1
Thread-5 1
Thread-6 1
Thread-1 2
Thread-2 2
Thread-3 2
Thread-4 2
Thread-5 2
Thread-6 2
Thread-1 3
Thread-2 3
Thread-3 3
Thread-4 3
Thread-5 3
Thread-6 3
 ... ...在上面的例子中，因为创建了6个自身对象，所以，synchronized形同虚设，每一个线程都能够进入，起不到同步的作用，而要是将同步的级别再提高一个档次，即类级别的话，就可以达到我们想要的效果了，修改如下：public class mainThread extends Thread{
  int i=0;
  public static void main(String args[]){
    mainThread m1 = new mainThread();
    mainThread m2 = new mainThread();
    mainThread m3 = new mainThread();
    mainThread m4 = new mainThread();
    mainThread m5 = new mainThread();
    mainThread m6 = new mainThread();
    m1.start();
    m2.start();
    m3.start();
    m4.start();
    m5.start();
    m6.start();
  }
  public void t1(){
    int temp=i;
    temp=i+1;
    try{
      Thread.sleep(500);
    }
    catch(Exception e){}
    i=temp;
    System.out.println(Thread.currentThread().getName()+" "+i);
  }
  public void run(){
    synchronized(mainThread.class){
      while (true) {
        t1();
      }
    }
  }
 }
结果如：Thread-1 1
Thread-1 2
Thread-1 3
Thread-1 4
Thread-1 5
Thread-1 6上面的用法和下面是等价的：public class mainThread
    extends Thread {
  static int i = 0;
  public static void main(String args[]) {
    mainThread m1 = new mainThread();
    mainThread m2 = new mainThread();
    mainThread m3 = new mainThread();
    mainThread m4 = new mainThread();
    mainThread m5 = new mainThread();
    mainThread m6 = new mainThread();
    m1.start();
    m2.start();
    m3.start();
    m4.start();
    m5.start();
    m6.start();
  }  public static synchronized void t1() {
    int temp = i;
    temp = i + 1;
    try {
      Thread.sleep(500);
    }
    catch (Exception e) {}
    i = temp;
    System.out.println(Thread.currentThread().getName() + " " + i);
  }  public void run() {
    while (true) {
      t1();
    }
  }
}你可以再看看，要是将wait方法写入后会产生什么后果：
public class mainThread extends Thread{
  int i=0;
  public static void main(String args[]){
    mainThread m1 = new mainThread();
    mainThread m2 = new mainThread();
    mainThread m3 = new mainThread();
    mainThread m4 = new mainThread();
    mainThread m5 = new mainThread();
    mainThread m6 = new mainThread();
    m1.start();
    m2.start();
    m3.start();
    m4.start();
    m5.start();
    m6.start();
  }
  public void t1(){
    int temp=i;
    temp=i+1;
    try{
      Thread.sleep(500);
    }
    catch(Exception e){}
    i=temp;
    System.out.println(Thread.currentThread().getName()+" "+i);
  }
  public void run(){
    synchronized(mainThread.class){
      while (true) {
        try{
          wait();
        }
        catch(Exception e){
          System.out.println(e.getMessage());
        }
        t1();
      }
    }
  }
 }结果如：
current thread not owner
Thread-1 1
current thread not owner
Thread-1 2
current thread not owner
Thread-1 3
current thread not owner
Thread-1 4
current thread not owner
... ...