Java并发核心浅谈

Java 并发的核心就是 j.u.c 包，而 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

    // The synchronization state. 官方注释
    // 我简单解释一下，synchronized 原理是给加锁的对象 加上一个 monitorenter 和 monitorexit 的指令
    // 当某个线程进入加锁的代码（实际上应该是拿到被加锁的对象在内存的引用地址）// 会执行 monitorenter 然后将 monitor 置为 1，当别的线程访问该内存时，发现 monitor 不为 0
    // 所以其它线程无法获得 monitor，直到占有 monitor 的线程 monitorexit 将 monitor 减 1
    // 如果占有 monitor 的线程 重复进入，monitor 是可以一直累加的
    // 了解了 synchronized 工作原理，就会明白为什么会有诸如 nonfairTryAcquire(1) release(1) 的方法
    // 这是 AbstractQueuedSynchronizer 类中的字段
    // 因为 ReentrantLock 中的内部类 Sync 继承于 AQS
    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;

总结一下：

真正的大师，从代码里可以看出对于细节的处理，以及对于我等代码阅读者的友好

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