互联网架构学习-第一章 并发编程基础(四)

1 第一章 并发编程基础

1.4 Unsafe类的核心作用和原理

1.4.1 JDK Unsafe类使用与CAS原子特性

由于java不能直接访问操作系统底层，而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作，主要提供了以下功能：

• 内存操作
• 字段的定位与修改
• 挂起与恢复
• CAS操作(乐观锁)

内存操作
类中提供的3个本地方法allocateMemory、reallocateMemory、freeMemory分别用于分配内存，扩充内存和释放内存，与C语言中的3个方法对应.
字段的定位与修改
可以定位对象某字段的内存位置也可以修改对象的字段值，即使它是私有的。
挂起与恢复

• 将一个线程进行挂起是通过park方法实现的，调用 park后，线程将一直阻塞直到超时或者中断等条件出现。
• unpark可以终止一个挂起的线程，使其恢复正常。
• 整个并发框架中对线程的挂起操作被封装在 LockSupport类中，LockSupport类中有各种版本park方法，但最终都调用了Unsafe.park()方法。
  CAS操作(乐观锁)
  CAS：Compare And Swap 比较并交换。
• CAS操作包含三个操作数——内存位置（V）、预期原值（A）和新值(B)。
• 如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。
• CAS通俗来说，即“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。”
• Java并发包(java.util.concurrent)中大量使用了CAS操作,涉及到并发的地方都调用了sun.misc.Unsafe类方法进行CAS操作，在Unsafe中是通过compareAndSwapXXX方法实现的。

下面的代码演示了如何修改字段内容。

import java.lang.reflect.Field;
import java.util.Arrays;
import sun.misc.Unsafe;

public class UseUnsafe {
	
	private static int 	byteArrayBaseOffset;

	public static void main(String[] args) throws NoSuchFieldException,  Exception {
		// 获取任何类型的字段(getField()是获取public类型的字段)
		Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
		//暴力反射，解除私有限定
		unsafeField.setAccessible(true); 
		Unsafe unsafe = (Unsafe) unsafeField.get(null);
		System.out.println(unsafe);
		
		byte[] data = new byte[10];
		System.out.println(Arrays.toString(data));
		
		// 修改指定位置的内容，注意需要加上偏移量
		byteArrayBaseOffset = unsafe.arrayBaseOffset(byte[].class);
		System.out.println("数组的第一个元素的偏移地址：" + byteArrayBaseOffset);
		
		unsafe.putByte(data, byteArrayBaseOffset, (byte)1);
		unsafe.putByte(data, byteArrayBaseOffset + 6, (byte)8);
		
		System.out.println(Arrays.toString(data));
	}
}

下面是运行结果：

1.4.2 JUC工具类

CountDownLatch
CountDownLatch：用于监听某些初始化操作，并且线程进行阻塞，等初始化执行完毕后，通知主线程继续工作执行。
CyclicBarrier
CyclicBarrier：栅栏的概念，多线程的进行阻塞，等待某一个临界值条件满足后，同时执行！
如同这样一个场景：每个线程代表一个跑步运动员，当运动员都准备好后，才一起出发，只要有一个人没有准备好，大家都等待！

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class UseCyclicBarrier {
	
	static class Runner implements Runnable {
	
		private String name;
		private CyclicBarrier cyclicBarrier;
		
		public Runner(String name, CyclicBarrier cyclicBarrier) {
			this.name = name;
			this.cyclicBarrier = cyclicBarrier;
		}
		public void run() {
			try {
				System.out.println("运动员："+ this.name + "进行准备 工作");
				Thread.sleep(2000*(new Random()).nextInt(5));
				System.out.println("运动员："+ this.name + "准备OK");
				this.cyclicBarrier.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (BrokenBarrierException e) {
				e.printStackTrace();
			}
			System.out.println("运动员：" + this.name + "起跑！");
		}
	}
	
	public static void main(String[] args) {
		CyclicBarrier barrier= new  CyclicBarrier(3);
		
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		
		executorService.submit(new Thread(new Runner("张三", barrier)));
		executorService.submit(new Thread(new Runner("李四", barrier)));
		executorService.submit(new Thread(new Runner("王五", barrier)));
		
		executorService.shutdown();
	}
}