初学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也是一种可重入的锁。