java中同步方式--synchronized

线程安全，是指每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的。或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性，也就是说我们不用考虑同步的问题。

线程安全问题都是由全局变量及静态变量引起的，若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全

synchronized

java语言的关键字，修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 

1.当2个并发线程访问同一个对象object中的这个synchronized（this）同步代码块的时，一个线程得到执行，另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块

2.当一个线程访问object的一个synchronized（this）同步代码时，另外一个线程仍然可以访问非synchronized(this)同步代码块

3.当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所synchronized(this)同步代码块的访问也将 阻塞

4.当一个线程访问objetc的一个synchroniized(this)同步代码块时，它就获得了这个object，其他线程对该object对象所有同步代码部分的访问都被暂时阻塞

5.以上规则对其他对象锁同样适用

Synchronized应用举例

1.当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码时，一个一个线程得到执行，另外一个线程必须等到当前线程执行完这个代码块以后才能执行该代码块

public class Thread1 implements Runnable{

public void run(){

synchronized(this){

for(int i=0;i<5;i++){

System.out.println()

}

}

}

1.      public static void main(String[] args) {   
2.           Thread1 t1 = new Thread1();   
3.           Thread ta = new Thread(t1, "A");   
4.           Thread tb = new Thread(t1, "B");   
5.           ta.start();   
6.           tb.start();   
7.      } 

}

运行结果： 

     A synchronized loop 0 
     A synchronized loop 1 
     A synchronized loop 2 
     A synchronized loop 3 
     A synchronized loop 4 
     B synchronized loop 0 
     B synchronized loop 1 
     B synchronized loop 2 
     B synchronized loop 3 
     B synchronized loop 4

2、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

代码示例：

[java]  view plain copy print ?

1. public class Thread2 {   
2.      public void m4t1() {   
3.           synchronized(this) {   // 同步  
4.                int i = 5;   
5.                while( i-- > 0) {   
6.                     System.out.println(Thread.currentThread().getName() + " : " + i);   
7.                     try {   
8.                          Thread.sleep(500);   
9.                     } catch (InterruptedException ie) {   
10.                     }   
11.                }   
12.           }   
13.      }   
14.      public void m4t2() {   
15.           int i = 5;   // 非同步  
16.           while( i-- > 0) {   
17.                System.out.println(Thread.currentThread().getName() + " : " + i);   
18.                try {   
19.                     Thread.sleep(500);   
20.                } catch (InterruptedException ie) {   
21.                }   
22.           }   
23.      }   
24.      public static void main(String[] args) {   
25.           final Thread2 myt2 = new Thread2();   
26.           Thread t1 = new Thread(  new Runnable() {  public void run() {  myt2.m4t1();  }  }, "t1"  );   
27.           Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  );   
28.           t1.start();   
29.           t2.start();   
30.      }  
31. }  

运行结果： 

     t1 : 4 
     t2 : 4 
     t1 : 3 
     t2 : 3 
     t1 : 2 
     t2 : 2 
     t1 : 1 
     t2 : 1 
     t1 : 0 
     t2 : 0

尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

代码示例：

[java]  view plain copy print ?

1. //修改Thread2.m4t2()方法：   
2. public void m4t2() {   
3.     synchronized(this) {   // 同步  
4.           int i = 5;   
5.           while( i-- > 0) {   
6.                System.out.println(Thread.currentThread().getName() + " : " + i);   
7.                try {   
8.                     Thread.sleep(500);   
9.                } catch (InterruptedException ie) {   
10.                }   
11.           }   
12.      }  
13. }  

运行结果：

     t1 : 4 
     t1 : 3 
     t1 : 2 
     t1 : 1 
     t1 : 0 
     t2 : 4 
     t2 : 3 
     t2 : 2 
     t2 : 1 
     t2 : 0

4、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

代码示例：

[java]  view plain copy print ?

1. //修改Thread2.m4t2()方法如下：  
2. public synchronized void m4t2() {  // 同步代码块（同步方法）  
3.      int i = 5;   
4.      while( i-- > 0) {   
5.           System.out.println(Thread.currentThread().getName() + " : " + i);   
6.           try {   
7.                Thread.sleep(500);   
8.           } catch (InterruptedException ie) {   
9.           }   
10.      }   
11. }  

运行结果： 

     t1 : 4 
     t1 : 3 
     t1 : 2 
     t1 : 1 
     t1 : 0 
     t2 : 4 
     t2 : 3 
     t2 : 2 
     t2 : 1 
     t2 : 0

5.以上规则对其他 对象锁同样适用:

代码示例:

1. public class Thread3{  
2.      class Inner {  
3.           private void m4t1() {  
4.                int i = 5;  
5.                while(i-- > 0) {  
6.                     System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);  
7.                     try {  
8.                          Thread.sleep(500);  
9.                     } catch(InterruptedException ie) {  
10.                     }  
11.                }  
12.           }  
13.           private void m4t2() {  
14.                int i = 5;  
15.                while(i-- > 0) {  
16.                     System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);  
17.                     try {  
18.                          Thread.sleep(500);  
19.                     } catch(InterruptedException ie) {  
20.                     }  
21.                }  
22.           }  
23.      }  
24.      private void m4t1(Inner inner) {  
25.           synchronized(inner) { //使用对象锁  
26.           inner.m4t1();  
27.      }  
28.    
29.      private void m4t2(Inner inner) {  
30.           inner.m4t2();  
31.      }  
32.       
33.      public static void main(String[] args) {  
34.           final Thread3 myt3 = new Thread3();  
35.           final Inner inner = myt3.new Inner();  
36.           Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1");  
37.           Thread t2 = new Thread( new Runnable() {public void run() { myt3.m4t2(inner);} }, "t2");  
38.      t1.start();  
39.      t2.start();  
40.   }  
41. }  

运行结果：

尽管线程t1获得了对Inner的对象锁，但由于线程t2访问的是同一个Inner中的非同步部分。所以两个线程互不干扰。

     t1 : Inner.m4t1()=4 
     t2 : Inner.m4t2()=4 
     t1 : Inner.m4t1()=3 
     t2 : Inner.m4t2()=3 
     t1 : Inner.m4t1()=2 
     t2 : Inner.m4t2()=2 
     t1 : Inner.m4t1()=1 
     t2 : Inner.m4t2()=1 
     t1 : Inner.m4t1()=0 
     t2 : Inner.m4t2()=0

现在在Inner.m4t2()前面加上synchronized：

[java]  view plain copy print ?

1. private synchronized void m4t2() { // 同步代码块（同步方法）   
2.      int i = 5;   
3.      while(i-- > 0) {   
4.           System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);   
5.           try {   
6.                Thread.sleep(500);   
7.           } catch(InterruptedException ie) {   
8.           }   
9.      }   
10. }  

运行结果：

尽管线程t1与t2访问了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁，所以t2对Inner.m4t2()的访问也被阻塞，因为m4t2()是Inner中的一个同步方法。

     t1 : Inner.m4t1()=4 
     t1 : Inner.m4t1()=3 
     t1 : Inner.m4t1()=2 
     t1 : Inner.m4t1()=1 
     t1 : Inner.m4t1()=0 
     t2 : Inner.m4t2()=4 
     t2 : Inner.m4t2()=3 
     t2 : Inner.m4t2()=2 
     t2 : Inner.m4t2()=1 
     t2 : Inner.m4t2()=0

synchronized 关键字，它包括两种用法：synchronized 方法 和 synchronized 块 

1. synchronized 方法：

通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如： 
　　public synchronized void accessVal(int newVal); 

synchronized 方法，控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞。方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。 

在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。 

synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。 

　　

2. synchronized 块：

通过 synchronized关键字来声明synchronized 块。语法如下： 
　　synchronized(syncObject) { 
　　         //允许访问控制的代码 
　　} 
synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。