淺談Java鎖的膨脹過程以及一致性哈希對鎖膨脹的影響

public String method(){
	StringBuffer sb = new StringBuffer();
	sb.append("1");//append()是被synchronized修飾的
	sb.append("2");
	return sb.toString();
}

public void method(){
	for (int i= 0; i < 100; i++) {
		synchronized (this){
			...
		}
	}
}

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.9</version>
</dependency>

public class LockTest {

	static class Lock{}

	public static void main(String[] args) {
		sleep(5000);
		Lock lock = new Lock();

		System.err.println("無鎖");
		print(lock);

		synchronized (lock) {
			//main線程首次競爭鎖，可偏向
			System.err.println("偏向鎖");
			print(lock);
		}

		new Thread(()->{
			synchronized (lock){
				//線程A來競爭，偏向線程ID不是自己，升級為：輕量級鎖
				System.err.println("輕量級鎖");
				print(lock);
			}
		},"Thread-A").start();

		sleep(2000);

		new Thread(()->{
			synchronized (lock){
				sleep(1000);
			}
		},"Thread-B").start();

		//確保線程B啟動並獲得鎖，sleep 100毫秒
		sleep(100);

		synchronized (lock){
			//main線程競爭時，線程B還未釋放，多線程同時競爭，升級為：重量級鎖
			System.err.println("重量級鎖");
			print(lock);
		}
	}

	static void print(Object o){
		System.err.println("==========對象信息開始...==========");
		System.out.println(ClassLayout.parseInstance(o).toPrintable());
		//jol異步輸出，防止打印重疊，sleep1秒
		sleep(1000);
		System.err.println("==========對象信息結束...==========");
	}

	static void sleep(long l){
		try {
			Thread.sleep(l);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

public static void main(String[] args) {
	sleep(5000);
	Lock lock = new Lock();

	synchronized (lock){
		System.err.println("Main線程首次競爭鎖");
		print(lock);
	}

	System.out.println();
	sleep(1000);
	System.err.println("同步代碼塊退出以後");
	print(lock);
}

public static void main(String[] args) {
	sleep(5000);
	Lock lock = new Lock();

	synchronized (lock){
		//偏向鎖
	}
	
	new Thread(()->{
		synchronized (lock){
			System.err.println("輕量級鎖");
			print(lock);
		}
	},"Thread-A").start();

	sleep(5000);
	System.err.println("\n線程A釋放鎖後");
	print(lock);
}

public static void main(String[] args) {
	sleep(5000);
	Lock lock = new Lock();

	//沒有重寫，一致性哈希，重寫後無效
	lock.hashCode();

	synchronized (lock){
		System.err.println("本應是偏向鎖，但是由於計算過一致性哈希，會直接膨脹為輕量級鎖");
		print(lock);
	}
}

public static void main(String[] args) {
	sleep(5000);
	Lock lock = new Lock();

	synchronized (lock){
		//沒有重寫，一致性哈希，重寫後無效
		lock.hashCode();
		System.err.println("偏向鎖過程中遇到一致性哈希計算請求，立馬撤銷偏向模式，膨脹為重量級鎖");
		print(lock);
	}
}

public class PerformanceTest {
	final static int TEST_COUNT = 100000000;
	static class Lock{}

	public static void main(String[] args) {
		sleep(5000);
		System.err.println("各類型鎖性能測試");
		Lock lock = new Lock();
		long start;
		long end;

		start = System.currentTimeMillis();
		for (int i = 0; i < TEST_COUNT; i++) {

		}
		end = System.currentTimeMillis();
		System.out.println("無鎖:" + (end - start));

		//偏向鎖
		biasedLock(lock);
		start = System.currentTimeMillis();
		for (int i = 0; i < TEST_COUNT; i++) {
			synchronized (lock) {}
		}
		end = System.currentTimeMillis();
		System.out.println("偏向鎖耗時:" + (end - start));

		//輕量級鎖
		lightweightLock(lock);
		start = System.currentTimeMillis();
		for (int i = 0; i < TEST_COUNT; i++) {
			synchronized (lock) {}
		}
		end = System.currentTimeMillis();
		System.out.println("輕量級鎖耗時:" + (end - start));

		//重量級鎖
		weightLock(lock);
		start = System.currentTimeMillis();
		for (int i = 0; i < TEST_COUNT; i++) {
			synchronized (lock) {}
		}
		end = System.currentTimeMillis();
		System.out.println("重量級鎖耗時:" + (end - start));
	}

	static void biasedLock(Object o){
		synchronized (o){}
	}

	//將鎖升級為輕量級
	static void lightweightLock(Object o){
		biasedLock(o);

		Thread thread = new Thread(() -> {
			synchronized (o) {}
		});
		thread.start();
		try {
			thread.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	//將鎖升級為重量級
	static void weightLock(Object o){
		lightweightLock(o);

		Thread t1 = new Thread(() -> {
			synchronized (o){
				sleep(1000);
			}
		});
		Thread t2 = new Thread(() -> {
			synchronized (o){
				sleep(1000);
			}
		});
		t1.start();
		t2.start();
		try {
			t1.join();
			t2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	static void sleep(long l){
		try {
			Thread.sleep(l);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

public static void main(String[] args) throws InterruptedException {
	System.err.println("多線程測試");
	Lock lock = new Lock();
	long start;
	long end;

	//輕量級鎖
	lightweightLock(lock);
	start = System.currentTimeMillis();
	for (int i = 0; i < TEST_COUNT; i++) {
		synchronized (lock) {}
	}
	end = System.currentTimeMillis();
	System.out.println("輕量級鎖耗時:" + (end - start));

	//重量級鎖
	weightLock(lock);
	Thread t1 = new Thread(() -> {
		for (int i = 0; i < TEST_COUNT / 2; i++) {
			synchronized (lock) {}
		}
	});
	Thread t2 = new Thread(() -> {
		for (int i = 0; i < TEST_COUNT / 2; i++) {
			synchronized (lock) {}
		}
	});
	t1.start();
	t2.start();
	start = System.currentTimeMillis();
	t1.join();
	t2.join();
	end = System.currentTimeMillis();
	System.out.println("重量級鎖耗時:" + (end - start));
}