執行緒安全，是指每次執行結果和單執行緒執行的結果是一樣的，而且其他的變數的值也和預期的是一樣的。或者說:一個類或者程式所提供的介面對於執行緒來說是原子操作或者多個執行緒之間的切換不會導致該介面的執行結果存在二義性，也就是說我們不用考慮同步的問題。

執行緒安全問題都是由全域性變數及靜態變數引起的，若每個執行緒中對全域性變數、靜態變數只有讀操作，而無寫操作，一般來說，這個全域性變數是執行緒安全的；若有多個執行緒同時執行寫操作，一般都需要考慮執行緒同步，否則就可能影響執行緒安全

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.      publicstaticvoid 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 plaincopyprint?

1. publicclass Thread2 {   
2.      publicvoid 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.      publicvoid 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.      publicstaticvoid main(String[] args) {   
25.           final Thread2 myt2 = new Thread2();   
26.           Thread t1 = new Thread(  new Runnable() {  publicvoid run() {  myt2.m4t1();  }  }, "t1"  );   
27.           Thread t2 = new Thread(  new Runnable() {  publicvoid 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 plaincopyprint?

1. //修改Thread2.m4t2()方法： 
2. publicvoid 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 plaincopyprint?

1. //修改Thread2.m4t2()方法如下：
2. publicsynchronizedvoid 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. publicclass Thread3{  
2.      class Inner {  
3.           privatevoid 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.           privatevoid 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.      privatevoid m4t1(Inner inner) {  
25.           synchronized(inner) { //使用物件鎖
26.           inner.m4t1();  
27.      }  
28.      privatevoid m4t2(Inner inner) {  
29.           inner.m4t2();  
30.      }  
31.      publicstaticvoid main(String[] args) {  
32.           final Thread3 myt3 = new Thread3();  
33.           final Inner inner = myt3.new Inner();  
34.           Thread t1 = new Thread( new Runnable() {publicvoid run() { myt3.m4t1(inner);} }, "t1");  
35.           Thread t2 = new Thread( new Runnable() {publicvoid run() { myt3.m4t2(inner);} }, "t2");  
36.      t1.start();  
37.      t2.start();  
38.   }  
39. }  

執行結果：

儘管執行緒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

相關推薦