synchronized
为什么每个Java对象都可以作为锁?
无锁
代码示例:
package multiThreads;
import org.openjdk.jol.info.ClassLayout;
public class SynchronizedTest {
public static void main(String[] args) {
Object o = new Object();
int hashCode = o.hashCode();
System.out.println("10进制 hashCode:" + hashCode);
System.out.println("16进制 hashCode:" + Integer.toHexString(hashCode));
System.out.println("2进制 hashCode:" + Integer.toBinaryString(hashCode));
System.out.println(ClassLayout.parseInstance(o).toPrintable());
System.out.println("-------");
}
}
运行结果:
偏向锁
偏向锁:单线程竞争。当线程A第一次获取时,通过操作修改Mark Word中的偏向线程Id、偏向模式。如果不存在其他线程竞争,那么线程A将永远不需要进行同步。
为什么需要偏向锁呢?或者说偏向锁为什么会被设计出来?
以下面的案例阐释一下:
假设三个线程卖50张票,代码如下:
package multiThreads;
import java.util.*;
import java.util.concurrent.CountDownLatch;
public class SaleTicketsTest {
public static void main(String[] args) throws InterruptedException {
int threadNum = 3;
CountDownLatch countDownLatch = new CountDownLatch(threadNum);
TicketsSale sale = new TicketsSale();
for (int i = 0; i < threadNum; i++) {
new Thread(() -> {
sale.sale();
countDownLatch.countDown();
}, ""+ i).start();
}
countDownLatch.await();
sale.getAllThreadCount();
System.out.println("-------------");
}
}
class TicketsSale {
private int num = 100;
Map<Thread, Integer> countMap = new HashMap<>();
public void sale () {
while (true) {
synchronized (this) {
if (num > 0) {
num--;
Thread thread = Thread.currentThread();
System.out.println(thread.getName() + "售出一张票,现在还剩" + num + "张票");
boolean keyExists = countMap.containsKey(thread);
if (keyExists) {
Integer count = countMap.get(thread);
countMap.put(thread, ++count);
} else {
countMap.put(thread, 1);
}
} else {
break;
}
}
}
}
public void getAllThreadCount () {
Set<Map.Entry<Thread, Integer>> entries = countMap.entrySet();
for (Map.Entry<Thread, Integer> entry : entries) {
System.out.println(entry.getKey().getName() + "卖出:" + entry.getValue() + "张票");
}
}
}
运行结果:
可以看到,我们设定是三个线程卖一百张票,但是实际上可能一个线程卖了99张票。这种情况下,对于一个同步代码块,如果一直被同一个线程多次访问,那么就可以让此线程在后续访问时自动获取锁。这就是偏向锁。
结论
HotSpot作者发现在多线程情况下,可能会出现多线程竞争,都可以差不多的概率执行同步代码块的情况,也可能出现同步代码基本一直被某一个线程执行的情况下,针对基本一直被某个线程执行的情况,使用了偏向锁,目的就是在只有一个线程执行同步代码的情况下提高性能。
偏向锁会倾向于第一个访问的线程,如果在接下来的运行过程中,该锁没有被其他线程访问,那么持有偏向锁的线程永远不需要触发同步。即偏向锁在没有其他线程竞争的情况下,消除了同步语句,懒得连CAS都不执行了,提高了程序性能。
理论落地
在实际应用运行过程中发现,锁总是同一个线程持有,很少发生竞争,也就是说,锁总是被一个占用他的线程拥有,这个线程就是锁的偏向线程。
那么只需要在锁第一次被拥有的时候,记录下偏向线程ID。这样偏向线程就一直持有者锁(后续这个线程进入和 退出这段同步锁的代码块时,不需要再次加锁和解锁)。而是直接去检查锁的MarkWord里面放的是不是自己的线程ID。
如果相等,表示偏向锁是基于当前线程的,就不需要再尝试获取锁了,直到竞争发生时才会释放锁。以后每次同步,检查锁的偏向线程ID与当前线程ID是否一致,如果一致则直接进入同步代码块,无需每次都加锁解锁以及去CAS更新对象头。如果自始至终都是同一个线程使用锁,那么偏向锁几乎没有额外开销,性能极高。如果不等,表示发生了竞争,锁已经不是总是偏向于同一个线程了,这个时候会尝试使用CAS来替换MarkWord里面的线程ID为新线程的ID。
竞争成功,表示之前的线程不存在了,MarkWord里面的线程ID为新线程的ID,锁不会升级,仍为偏向锁。
竞争失败,这时候可能需要升级为轻量级锁,才能保证线程间公平竞争锁。
注意,偏向锁只有遇到其他线程尝试竞争偏向锁时,持有偏向锁的线程才会释放锁,线程是不会主动释放偏向锁的。
技术实现:一个synchronized方法被一个线程抢到锁时,那这个方法所在对象就会在其MarkWord中将偏向锁状态修改为1(无锁:0,偏向锁:1),同时还会占用前54bit位来存储线程指针作为标识。若该线程再次访问同一个synchronized方法时,该线程只需去对象头的MarkWord中去判断一下是否有偏向锁指向本身的ID,无需再次进入Monitor去竞争对象了。
案例说明
偏向锁说明
代码示例:
package multiThreads;
import org.openjdk.jol.info.ClassLayout;
public class BiasedLockTest {
public static void main(String[] args) {
Object object = new Object();
synchronized (object) {
System.out.println(ClassLayout.parseInstance(object).toPrintable());
}
}
}
同时需要设置虚拟机参数,让偏向锁立刻生效:
-XX:BiasedLockingStartupDelay=0
运行结果:
可以看到此时偏向锁标志是1,同步锁标志是01.符合预期。
偏向锁的线程指针什么时候写入?
代码如下:
package multiThreads;
import org.openjdk.jol.info.ClassLayout;
import java.util.concurrent.TimeUnit;
public class BiasedLockTest2 {
public static void main(String[] args) throws InterruptedException {
TimeUnit.SECONDS.sleep(5L);
Object object = new Object();
System.out.println(ClassLayout.parseInstance(object).toPrintable());
System.out.println("-----------");
synchronized (object) {
System.out.println(ClassLayout.parseInstance(object).toPrintable());
}
}
}
运行结果:
可以看到,两次打印都开启了偏向锁,但是偏向锁对应的线程ID是在执行同步代码块后才写入。
偏向锁升级为轻量级锁
当有第二个线程和第一个线程开始竞争锁,此时锁有可能保留偏向锁,也有可能会升级成轻量级锁,这取决于第二个线程开始竞争锁时,第一个线程执行的时机。
偏向锁的获取和撤销流程
轻量级锁
轻量级锁:存在锁竞争,但是任意时刻最多存在一个线程进行竞争,即不存在锁激烈竞争的情况,也就没有线程阻塞。
代码演示:
package multiThreads;
import org.openjdk.jol.info.ClassLayout;
import java.util.concurrent.TimeUnit;
public class BiasedLockTest3 {
public static void main(String[] args) throws InterruptedException {
//记得添加参数 -XX:-UseBiasedLocking 禁用BiasedLocking
TimeUnit.SECONDS.sleep(5L);
Object object = new Object();
new Thread(() ->{
//已禁用偏向锁,此时是无锁状态
System.out.println(ClassLayout.parseInstance(object).toPrintable());
//已禁用偏向锁,同步代码块,此时直接升级为轻量级锁
synchronized (object) {
System.out.println(ClassLayout.parseInstance(object).toPrintable());
}
}).start();
}
}
运行结果:
轻量级锁升级为重量级锁,需要自旋多少次?
Java6之前默认是10次,对应虚拟机参数为 -XX:ProLockSpin=10,或者自旋次数超过CPU核数的一半。Java6之后,是自适应自旋锁,原理如下:
重量级锁
代码示例:
package multiThreads;
import org.openjdk.jol.info.ClassLayout;
public class BiasedLockTest4 {
public static void main(String[] args) {
Object object = new Object();
new Thread(() -> {
synchronized (object) {
System.out.println(ClassLayout.parseInstance(object).toPrintable());
}
}, "a").start();
new Thread(() -> {
synchronized (object) {
System.out.println(ClassLayout.parseInstance(object).toPrintable());
}
}, "b").start();
}
}
运行结果:
小总结:
1.锁升级后hashCode去哪了?
当一个对象已经调用过hashCode()后,如果被锁住,那么无法进入偏向锁状态,而是直接进入轻量级锁状态。
代码示例:
package multiThreads;
import org.openjdk.jol.info.ClassLayout;
import java.util.concurrent.TimeUnit;
public class BiasedLockTest2 {
public static void main(String[] args) throws InterruptedException {
//TimeUnit.SECONDS.sleep(5L);
Object object = new Object();
System.out.println(ClassLayout.parseInstance(object).toPrintable());
System.out.println("-----------");
object.hashCode();
synchronized (object) {
System.out.println(ClassLayout.parseInstance(object).toPrintable());
}
}
}
运行结果:
如果一个对象已经是偏向锁了,此时调用其hashCode(),则会导致偏向锁直接升级为重量级锁。
代码如下:
package multiThreads;
import org.openjdk.jol.info.ClassLayout;
import java.util.concurrent.TimeUnit;
public class BiasedLockTest2 {
public static void main(String[] args) throws InterruptedException {
TimeUnit.SECONDS.sleep(5L);
Object object = new Object();
synchronized (object) {
System.out.println(ClassLayout.parseInstance(object).toPrintable());
object.hashCode();
System.out.println(ClassLayout.parseInstance(object).toPrintable());
}
}
}
运行结果:
各种锁的优缺点
JIT编译器对锁的优化
JIT:just in time Compiler,即时编译器。
锁消除
package multiThreads;
public class LockClear {
//由于m1()的锁在每次调用的时候都会new一个新的对象,
//相当于每次调用都持有不同的锁,在多线程情况下无法达到上锁的目的
//JIT编译器会忽视synchronized代码声明,相当于消除了写得不合规的锁
//这就是 JIT的锁消除
public void m1() {
Object object = new Object();
synchronized (object) {
System.out.println("lock clear");
}
}
public static void main(String[] args) {
LockClear lockClear = new LockClear();
for (int i = 0; i < 10; i++) {
new Thread(lockClear::m1).start();
}
}
}
锁粗化
package multiThreads;
public class LockRoughen {
public static void main(String[] args) {
new Thread(() -> {
Object obj = new Object();
synchronized (obj) {
System.out.println("1111");
}
synchronized (obj) {
System.out.println("2222");
}
synchronized (obj) {
System.out.println("3333");
}
//JIT编译器会优化为如下代码
synchronized (obj) {
System.out.println("1111");
System.out.println("2222");
System.out.println("3333");
}
}).start();
}
}