学习java synchronized的总结

1. synchronized 可以作为一个method的修饰符
 public synchronized void aMethod() {
        //some code
    }
相当于：
    public void aMethod() {
        synchronized(this) {
           //some code
        }
    }
说明：
(1) 它是对类中的同一对象负责
(2)在同一个类对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法
举例：
public class Thread1 extends Thread{
 
 public void run(){
  /*synchronized (this) {
   for (int i = 0; i < 5; i++) {
    try {
     Thread.sleep(1000);
    } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName() + " " + i);
   }
  }*/
  myRun();
 }
 
 //与synchronized(this){}效果是一致的
 public synchronized void myRun(){
  for (int i = 0; i < 5; i++) {
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   System.out.println(Thread.currentThread().getName() + " " + i);
  }
 }

 public static void main(String[] args) {
  Thread1 t = new Thread1();
  Thread myA = new Thread(t,"A");
  Thread myB = new Thread(t,"B");
  
  myA.start();
  myB.start();
  
 }
运行结果：
A 0
A 1
A 2
A 3
A 4
B 0
B 1
B 2
B 3
B 4

(3) 如果是一个类中的不同对象，多个线程可以同时访问synchronized方法：
将main()方法修改：
  Thread1 t1 = new Thread1();
  Thread1 t2 = new Thread1();
  
  t1.setName("t1");
  t2.setName("t2");
  
  t1.start();
  t2.start();
运行结果：
t1 0
t2 0
t1 1
t2 1
t1 2
t2 2
t1 3
t2 3
t1 4
t2 4

(4) 如果是类的同一个对象存在多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象 中任何一个synchronized方法，但可以访问非synchronized方法。
public class Thread2 extends Thread {

 /**
  * (1) 当一个线程访问object的一个synchronized(this)同步代码块时，
  * 另一个线程仍然可以访问该object中的非synchronized(this)同步代码块
  *
  * (2)当一个线程访问object的一个synchronized(this)同步代码块时，
  * 其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞
  * @param args
  */
 
 public synchronized void method1(){
  for (int i = 0; i < 5; i++) {
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   System.out.println(Thread.currentThread().getName() + " " + i);
  }
 }
 
 public synchronized void method2(){
  for (int i = 0; i < 5; i++) {
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   System.out.println(Thread.currentThread().getName() + " " + i);
  }
 }
 
 public static void main(String[] args) {
  final Thread2 t2 = new Thread2();
  Thread myThreadA = new Thread(
    new Runnable(){
     public void run(){
      t2.method1();
     }
    },"myThreadA");
  
  Thread myThreadB = new Thread(
    new Runnable(){
     public void run(){
      t2.method2();
     }
    },"myThreadB");
  
  myThreadA.start();
  myThreadB.start();
 }

}
运行结果：
myThreadA 0
myThreadA 1
myThreadA 2
myThreadA 3
myThreadA 4
myThreadB 0
myThreadB 1
myThreadB 2
myThreadB 3
myThreadB 4

2. synchronized修饰一个 static的method，
如：
    public static synchronized void aMethod() {
        //some code
    }
相当于：
    public static synchronized void aMethod() {
        synchronized(XX.class) {
           //some code
        }
    }
说明：
synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。
public class ThreadTestE extends Thread {

 public void run(){
  myRun();
 }
 
 public static synchronized void myRun(){
  for (int i = 0; i < 5; i++) {
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   System.out.println(Thread.currentThread().getName() + " " + i);
  }
 }
 
 public static void main(String[] args) {
  ThreadTestE e1 = new ThreadTestE();
  ThreadTestE e2 = new ThreadTestE();
  ThreadTestE e3 = new ThreadTestE();
  
  e1.start();
  e2.start();
  e3.start();
 
 }

}
运行结果：
Thread-0 0
Thread-0 1
Thread-0 2
Thread-0 3
Thread-0 4
Thread-1 0
Thread-1 1
Thread-1 2
Thread-1 3
Thread-1 4
Thread-2 0
Thread-2 1
Thread-2 2
Thread-2 3
Thread-2 4

总结：
无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象。
synchronized(object){
}
线程获得了object对象锁，执行里面的代码，其它线程阻塞，直至其它线程也获得了该对象锁才能执行里面的代码；

补充说明：
synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f() {}。继承类需要你显式的指定它的某个方法为synchronized方法

参考文章：
（1）java synchronized 用法 http://www.360doc.com/showWeb/0/0/493058.aspx
（2）java synchronized的几个规则  http://blog.donews.com/dyhcn/archive/2005/07/14/465420.aspx