初學Java多線程的時候,遇到需要線程同步的地方,總是會用到synchronized關鍵詞。很簡單的就是幫助我們實現預想的“效果”。殊不知,synchronized是一個重量級的鎖,使用不當的話其實會使我們程序執行的效率大打折扣。
一:synchronized的作用範圍
synchronized可作用在普通的方法上,靜態方法上以及同步代碼塊上。以下,我將分別的對這三種情況做一個分析。
1:作用於普通方法上
public class Demo01 implements Runnable{
private int a;
private synchronized void add() {
a++;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
add();
}
}
public static void main(String[] args) {
Demo01 demo01 =new Demo01();
Thread thread1 =new Thread(demo01);
Thread thread2 =new Thread(demo01);
thread1.start();
thread2.start();
}
}
兩個線程對變量a各進行100次的自加,在add方法上加了synchronized以達到線程間的同步效果。synchronized加在方法上,持有鎖的爲該類的實例對象,即本例的demo01。所以兩個線程訪問同一個鎖對象會有互斥情況。
如果這裏每個線程持有的爲兩個不同的類實例,如下:
Demo01 demo01 =new Demo01();
Demo01 demo02 =new Demo01();
Thread thread1 =new Thread(demo01); //demo01
Thread thread2 =new Thread(demo02); //demo02
很明顯,這裏在方法上加上synchronized來同步是不行的,因爲這裏是兩個new出來的不同的實例,如果想要通過的該類的不同實例來加鎖,我們可以通過下面的方式’。
2:作用於靜態方法上
我們知道靜態方法是歸屬於類所有的,同一個類的不同實例可以通過持有其類的相同Class來達到線程同步的效果。如下:
public class Demo02 implements Runnable{
private static int a;
private synchronized static void add() {
a++;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
add();
}
}
public static void main(String[] args) {
Demo02 demo01 =new Demo02();
Demo02 demo02 =new Demo02();
Thread thread1 =new Thread(demo01);
Thread thread2 =new Thread(demo02);
thread1.start();
thread2.start();
}
}
創建線程使用的爲同一個類的不同實例,調用靜態方法的時候,還是能夠達到線程同步的效果。因爲此時持有鎖對象的爲類的Class字節碼。
除了上面兩種方式,還可以通過同步代碼塊的方式來進行加鎖操作。
2:作用於同步代碼塊上
public class Demo03 implements Runnable{
private int a;
private void add() {
synchronized (Object.class){
a++;
}
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
add();
}
}
public static void main(String[] args) {
Demo03 demo01 =new Demo03();
Demo03 demo02 =new Demo03();
Thread thread1 =new Thread(demo01);
Thread thread2 =new Thread(demo02);
thread1.start();
thread2.start();
}
}
以上例子持有鎖對象的爲Object的Class,這裏應該注意的是,在同步代碼塊中,只要能夠保證每個線程過來時,是同一個對象即可(任何類型的同一個實例對象)
二:synchronized同步的原理
synchronized的實現原理中,同步代碼塊與同步方法,同步靜態方法是不一樣的。在同步代碼塊中,是通過現實的監視器對象來標識的。而同步方法和同步靜態是通過同步方法來標識的。通過查看其源碼的字節碼文件,我們可以清楚的看到其原理。
同步代碼塊字節碼文件:
public void add();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=3, args_size=1
0: aload_0
1: dup
2: astore_1
3: monitorenter //持有鎖
4: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
7: ldc #3 // String Aaa
9: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
12: aload_1
13: monitorexit //釋放鎖
14: goto 22
17: astore_2
18: aload_1
19: monitorexit //釋放鎖
20: aload_2
21: athrow
22: return
Exception table:
from to target type
4 14 17 any
17 20 17 any
LineNumberTable:
line 6: 0
line 7: 4
line 8: 12
line 9: 22
LocalVariableTable:
Start Length Slot Name Signature
0 23 0 this Lcom/sg/thread002/threadSynchronized/Demo04;
StackMapTable: number_of_entries = 2
frame_type = 255 /* full_frame */
offset_delta = 17
locals = [ class com/sg/thread002/threadSynchronized/Demo04, class java/lang/Object ]
stack = [ class java/lang/Throwable ]
frame_type = 250 /* chop */
offset_delta = 4
可以看到同步代碼塊是直接顯示的執行monitorenter和monitorexit ,JVM保證無論在什麼情況下,執行完同步的代碼塊,就會釋放鎖,所以會有兩個monitorexit,另一個則是保證在異常的時候也是能夠釋放掉鎖的。
同步普通方法與靜態方法:
public static synchronized void add();
descriptor: ()V
//同步的標識
//ACC_PUBLIC :公共方法
//ACC_STATIC :靜態方法
//ACC_SYNCHRONIZED :同步方法標識
flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
Code:
stack=2, locals=0, args_size=0
0: getstatic #2 // Field a:I
3: iconst_1
4: iadd
5: putstatic #2 // Field a:I
8: return
LineNumberTable:
line 7: 0
line 8: 8
這裏可以看到在方法級別的同步是通過ACC_SYNCHRONIZED來標識的。
到這裏,關於synchronized就其使用的範圍以及原理做了一個分析,雖然說其是一個重量級的鎖,但是JDK在1.6的時候對其進行了優化,引入的偏向鎖,提高其性能。於此同時,synchronized也是一種可重入的鎖。