关于synchronized,本文从使用方法,底层原理和锁的升级优化这几个方面来介绍。
1.synchronized的使用:
synchronized可以保证在同一时刻,只有一个线程可以操作共享变量,并且该共享变量的变化对其他线程可见。它的使用方法有三种:
1.1 作用于实例方法
当synchronized作用于实例方法时,它的锁是当前的实例对象。通过以下demo来看下它的用法:
public class SynchronizedDemo implements Runnable{ static int i = 0;
// 作用于实例方法 public synchronized void increase(){ i++; } @Override public void run() { for (int i = 0; i < 10000; i++) { increase(); } } public static void main(String[] args) throws InterruptedException { SynchronizedDemo synchronizedDemo = new SynchronizedDemo(); Thread t1 = new Thread(synchronizedDemo); Thread t2 = new Thread(synchronizedDemo); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(i); } }
以上demo的输出结果是:20000;在java中,任意一个对象都可以作为锁,注意在这里线程t1和t2共用了一把锁,都是synchronizedDemo这个对象。再看下,如下demo:
public class SynchronizedDemo implements Runnable{ static int i = 0; public synchronized void increase(){ i++; } @Override public void run() { for (int i = 0; i < 10000; i++) { increase(); } } public static void main(String[] args) throws InterruptedException { SynchronizedDemo synchronizedDemo = new SynchronizedDemo(); SynchronizedDemo synchronizedDemo2 = new SynchronizedDemo(); Thread t1 = new Thread(synchronizedDemo); Thread t2 = new Thread(synchronizedDemo2); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(i); } }
这个demo会出现什么结果呢?通过多次运行我们发现,输出的值可能会小于20000;原因就是线程t1和t2使用了各自的锁,那么synchronized的存在就毫无意义了,无法保证线程安全。那么针对这种有多个对象(锁)的情况,如何解决呢?将synchronized作用于静态方法就行了。
1.2 作用于静态方法
当作用于静态方法时,锁是当前类的class对象。看如下demo:
public class SynchronizedDemo implements Runnable{ static int i = 0; public static synchronized void increase(){ i++; } @Override public void run() { for (int i = 0; i < 10000; i++) { increase(); } } public static void main(String[] args) throws InterruptedException { SynchronizedDemo synchronizedDemo = new SynchronizedDemo(); SynchronizedDemo synchronizedDemo2 = new SynchronizedDemo(); Thread t1 = new Thread(synchronizedDemo); Thread t2 = new Thread(synchronizedDemo2); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(i); } }
运行结果:20000;此时是线程安全的,因为t1和t2共用了同一个锁,该锁就是SynchronizedDemo的class对象。
1.3 作用于代码块
当作用于代码块时,锁是synchronized括号里配置的对象。对于作用于代码块的使用场景是这样的:如果一个方法体很大,里面有一些耗时操作,但是我们需要同步的仅仅是一部分代码,如果对整个方法进行同步,显然是不合理的,所以可以针对代码块做同步。
* @date 2018年9月25日 */ public class SynchronizedDemo implements Runnable{ static int x = 0; public void run() { //其他耗时操作。。。 synchronized (SynchronizedDemo.class) { for (int i = 0; i < 10000; i++) { x++; } } //其他耗时操作。。。 } public static void main(String[] args) throws InterruptedException { SynchronizedDemo synchronizedDemo = new SynchronizedDemo(); Thread t1 = new Thread(synchronizedDemo); Thread t2 = new Thread(synchronizedDemo); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(x); } }
在这个demo中,锁对象是SynchronizedDemo.class,当然可以是任意的java对象。
2.synchronized底层原理
synchronized在JVM中的实现原理,是基于进入和退出Monitor对象来实现方法同步和代码块同步,但是两者的实现细节不同;代码块同步是基于monitorenter和monitorexit指令来实现的,而方法同步是使用另外一种方式。在详解介绍之前,先了解下java对象头。
2.1 java对象头
在JVM中,对象在内存中的布局分为三块区域:对象头,实例变量和填充数据。而synchronized使用的锁对象就是存放在java对象头中的,对于java对象头由Mark Word和Class MetaData Address组成,如果当前对象是数据,则还有Array Length。如下图:
长度 | 内容 | 说明 |
32/64bit | Mark Word | 存储对象的hashCode,锁信息,分代年龄或者GC标志信息 |
32/64bit | Class MetaData Address | 存储到对象类型数据的指针,JVM通过这个指针能确定该对象是哪个类的实例 |
32/64bit | Array Length | 如果当前对象是数组,则表示数组的长度 |
对于32位的JVM,Mark Word默认的存储结构如下:
锁状态 | 25bit | 4bit | 1bit是否是偏向锁 | 2bit锁标志位 |
无锁状态 | 对象的hashCode | 对象分代年龄 | 0 | 01 |
在32位JVM下,除了上面的Mark Word默认的存储结构外,还有如下可变的的结构:
锁状态 | 25bit | 4bit | 1bit | 2bit | |
23bit | 2bit | 是否是偏向锁 | 锁标志位 | ||
轻量级锁 | 指向栈中锁记录的指针 | 00 | |||
重量级锁 | 指向重量级锁的指针 | 10 | |||
GC标记 | 空 | 11 | |||
偏向锁 | 线程ID | Epoch | 对象粉黛年龄 | 1 | 01 |
在这里,synchronized的对象锁,锁标志位10,指针指向的是monitor对象的起始地址,每一个对象都有一个monitor对象与之关联。当一个monitor对象被一个线程持有后,它就处于锁定状态。
2.2 同步代码块底层原理
对于1.3中的demo,经过javap反编译后得到如下结果:
public class SynchronizedDemo implements java.lang.Runnable { static int x; public SynchronizedDemo(); Code: 0: aload_0 1: invokespecial #1 // Method java/lang/Object."<init>": ()V 4: return public void run(); Code: 0: ldc_w #2 // class SynchronizedDemo 3: dup 4: astore_1 5: monitorenter // 进入同步方法 6: iconst_0 7: istore_2 8: iload_2 9: sipush 10000 12: if_icmpge 29 15: getstatic #3 // Field x:I 18: iconst_1 19: iadd 20: putstatic #3 // Field x:I 23: iinc 2, 1 26: goto 8 29: aload_1 30: monitorexit // 退出同步方法 31: goto 39 34: astore_3 35: aload_1 36: monitorexit // 退出同步方法 37: aload_3 38: athrow 39: return Exception table: from to target type 6 31 34 any 34 37 34 any public static void main(java.lang.String[]) throws java.lang.InterruptedExcept ion; Code: 0: new #2 // class SynchronizedDemo 3: dup 4: invokespecial #4 // Method "<init>":()V 7: astore_1 8: new #5 // class java/lang/Thread 11: dup 12: aload_1 13: invokespecial #6 // Method java/lang/Thread."<init>": (Ljava/lang/Runnable;)V 16: astore_2 17: new #5 // class java/lang/Thread 20: dup 21: aload_1 22: invokespecial #6 // Method java/lang/Thread."<init>": (Ljava/lang/Runnable;)V 25: astore_3 26: aload_2 27: invokevirtual #7 // Method java/lang/Thread.start:()V 30: aload_3 31: invokevirtual #7 // Method java/lang/Thread.start:()V 34: aload_2 35: invokevirtual #8 // Method java/lang/Thread.join:()V 38: aload_3 39: invokevirtual #8 // Method java/lang/Thread.join:()V 42: getstatic #9 // Field java/lang/System.out:Ljava/ io/PrintStream; 45: getstatic #3 // Field x:I 48: invokevirtual #10 // Method java/io/PrintStream.printl n:(I)V 51: return static {}; Code: 0: iconst_0 1: putstatic #3 // Field x:I 4: return }
monitorenter指令是在编译后插入到同步代码块的开始位置,monitorexit指令插入到同步代码块的结束位置和异常处,当线程执行到monitorenter指令时,将会尝试获取对象所对应的monitor的所有权,即尝试获取对象的锁。当monitorexit指令被执行时,执行线程会释放monitor锁。在上面的代码中可以看到,还有一个monitorexit指令,是在异常结束时执行的指令以释放monitor锁。对于同步方法的底层原理,细节实现上和这不同,这里暂时不做叙述。
3 锁的优化
在java SE1.6中,引入了偏向锁和轻量级锁,锁一共有四种状态,从低到高是:无锁状态,偏向锁状态,轻量级锁状态,重量级锁状态。这几种状态会随着竞争的提高,锁不断升级,但是不能降级。
3.1 偏向锁
经研究发现,大多数情况下,锁不仅不存在竞争,而且总是由同一个线程多次获得。为了让线程获得锁的代价更低,所以就引入了偏向锁。当一个线程访问代码块并获取锁时,会在对象头和栈帧的锁记录里存储锁偏向的线程ID,以后线程当再次进入同步代码块时,不需要再加锁和解锁,只需要测试下该对象头中是否存储着指向该线程的偏向锁即可。注意,当没有锁竞争时,偏向锁有很好的优化效果,但是一旦锁竞争激烈,偏向锁就会失效,升级为轻量级锁。
3.1.1 偏向锁的撤销
偏向锁使用了一种竞争出现才释放锁的机制,所以当其他线程竞争偏向锁时,持有该偏向锁的线程才会释放锁,我们称之为偏向锁的撤销。流程如下:如果A线程正在持有一个偏向锁,当B线程竞争该偏向锁时,会暂停A线程,然后检查A线程是否还活着,如果A线程不处于活动状态,则将对象头设置为无锁状态;如果A线程还处于活动状态,则将对象头的锁偏向于B线程或者恢复到无锁,最后,唤醒A线程。
3.2 轻量级锁
3.2.1 轻量级锁加锁
线程尝试使用CAS将对象头中Mark Word替换为指向锁记录中的指针,如果成功,则获取锁成功。如果失败,则继续通过自旋CAS来获取锁。
3.2.2 轻量级锁解锁
轻量级锁升级到重量级锁,是在轻量级锁解锁的过程中发生的。线程在获取锁的时候拷贝了对象头中的Mark Word;在它释放锁的时候发现在它持有锁期间有其它线程尝试获取锁,并且该线程对Mark Word做了修改,两者发现不一致,则切换到重量级锁。
参考资料:《java并发编程的艺术》