Java并发的核心就是 java.util.concurrent 包,而 j.u.c 的核心是AbstractQueuedSynchronizer抽象队列同步器,简称 AQS,一些锁啊!信号量啊!循环屏障啊!都是基于AQS。而 AQS 又是基于Unsafe的一系列compareAndSwap,所以理解了这块,并发不再是问题!

  • 先解释下何为compareAndSwap就拿AtomicInteger先开刀:
// 实际操作的值
	private volatile int value;
	// value 的偏移量 因为 int 是32位,知道首部地址就可以了
	private static final long valueOffset;
	// 静态初始化块,通过虚拟机提供的接口,获得 valueOffset
	static {
	     try {
	         valueOffset = unsafe.objectFieldOffset
	             (AtomicInteger.class.getDeclaredField("value"));
	     } catch (Exception ex) { throw new Error(ex); }
	 }
	 
	// 只是个封装方法,起作用的代码并不在这
	// 值得注意的是显示的 this 和第三个参数 1
	public final int getAndIncrement() {
	        return unsafe.getAndAddInt(this, valueOffset, 1);
	}
	
	// 以下是 Unsafe 类 可以直接访问内存地址,类似指针,所以不安全
	// o getAndIncrement()传入的 this,也就是 AtomicInteger 实例对象
	// offset 内存首部偏移量
	// delta 就是那个 1
	// 应该是希腊字母 δ /'deltə/ delta 变化量,化学反应中的加热,屈光度,一元二次方程中的判别式
	// 佩服

	public final int getAndAddInt(Object o, long offset, int delta) {
	        int v;
	        do {
	            v = getIntVolatile(o, offset);
	        } while (!compareAndSwapInt(o, offset, v, v + delta));
	        return v;
	}
	
	// 从堆内存获取最新的 value
	// 如果不明白,可以先了解下 JMM 和 volatile
	public native int getIntVolatile(Object o, long offset);
	
	// expected 就是这个 v = getIntVolatile(o, offset);
	// 意思就是,我给你这个最新的 value,它要是现在 在内存中还是这个值 那你就返回 true,并且把这块内存上值更新为 x 
	// 不然的话,我就一直 while (!compareAndSwapInt(o, offset, v, v + delta));
	// 相当于自旋锁 活锁,不要被高大上的术语吓到 就是活的循环,不会像死锁那样线程 hang 住
	public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);
  • 第二刀就拿ReentrantLock开刀好了,这几个类中的同步,由于方法和功能不一,细节处理上可能不一样。但是,原理都是一样的,离不开上述的CAS
  • 建议先了解下 Java 对象的内存结构

// 我先简单解释一下 synchronized 工作原理 首先它含有 monitorenter 和 monitorexit 两条指令
	// Java 中的每个对象都有自己的 Monitor(由HotSpot c++ 实现)
	// 当某个线程进入加锁的代码(实际上应该是拿到被加锁的对象在内存的引用地址),会执行 monitorenter 然后将 monitor 置为1,当别的线程访问该内存时,发现 monitor 不为 0
	// 所以其它线程无法获得 monitor,直到占有 monitor 的线程执行 monitorexit 退出将 monitor 减 1
	// 如果占有 monitor 的线程重复进入,monitor 是可以一直累加的
	// 了解了 synchronized 工作原理,就会明白为什么会有诸如 nonfairTryAcquire(1) release(1) 的方法
	
	// 这是 AbstractQueuedSynchronizer 类中的字段
	// 因为 ReentrantLock 中的内部类 Sync 继承于 AQS
	// The synchronization state
	private volatile int state;
	
	// tryLock why ?
	// 因为不同于 synchronized 的悲观(我才不管你是不是并发,多线程,声明了,我就加锁)
	// 所以 ReentrantLock 我先 try 一 try 吧!万一不是多线程并发呢!🤣
	public boolean tryLock() {
			// 加锁 加 1
	        return sync.nonfairTryAcquire(1);
	}

	final boolean nonfairTryAcquire(int acquires) {
           final Thread current = Thread.currentThread();
           int c = getState();
           // 0 的话 说明没有线程占有
           // 可以获得锁
           if (c == 0) {
               // 这个和上面的 AtomicInteger 一样
               if (compareAndSetState(0, acquires)) {
               	   // 设置当前占有锁的线程
                   setExclusiveOwnerThread(current);
                   return true;
               }
           }
           else if (current == getExclusiveOwnerThread()) {
               int nextc = c + acquires;
               // 看见没,锁的计数有可能会有问题
               // 因为一直累计,指不定就加到 int 上限转负数了
               if (nextc < 0) // overflow
                   throw new Error("Maximum lock count exceeded");
               // 不小于 0 更新 state
               setState(nextc);
               return true;
           }
           return false;
	  }
	  
	// AbstractOwnableSynchronizer 类
 	// The current owner of exclusive mode synchronization.
 	// 排它锁 独占锁 写锁 都一个意思 锁的当前持有线程
    private transient Thread exclusiveOwnerThread;

总结一下:

Doug Lea 真正的大师,从他的代码中可以看出对于细节的处理与把控,以及对于我等代码阅读者的友好

大道至简,谁能想到 Java 的并发支持是基于一些加 1 减 1 的运算