java多线程系列(五)---synchronized ReentrantLock volatile Atomic 原理分析

java多线程系列(五)---synchronized ReentrantLock volatile Atomic 原理分析

前言：如有不正确的地方，还望指正。

目录

• 认识cpu、核心与线程
• java多线程系列（一）之java多线程技能
• java多线程系列（二）之对象变量的并发访问
• java多线程系列（三）之等待通知机制
• java多线程系列（四）之ReentrantLock的使用
• java多线程系列（五）之synchronized ReentrantLock volatile Atomic 原理分析
• java多线程系列（六）之线程池原理及其使用

Synchronized

原理

• synchronized关键字是通过字节码指令来实现的
• synchronized关键字编译后会在同步块前后形成monitorenter和monitorexit两个字节码指令
• 执行monitorenter指令时需要先获得对象的锁（每个对象有一个监视器锁monitor），如果这个对象没被锁或者当前线程已经获得此锁（也就是重入锁），那么锁的计数器+1。如果获取失败，那么当前线程阻塞，直到锁被对另一个线程释放
• 执行monitorexit指令时，计数器减一，当为0的时候锁释放

class Test
{
    public int i=1;
    public void test()
    {
	    synchronized (this)
	    {
	    	i++;
	    }
}
}

• 反编译后结果

volatile

作用

• 保证变量对所有的线程的可见性，当一个线程修改了这个变量的值，其他线程可以立即知道这个新值（之所以有可见性的问题，是因为java的内存模型）

原理

• 所有变量都存在主内存，每条线程有自己的工作内存，工作内存保存了被该线程使用的变量的主内存副本拷贝
• 线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，也就是必须先通过工作内存
• 一个线程不能访问另一个线程的工作内存
• volatile保证了变量更新的时候能够立即同步到主内存，使用变量的时候能立即从主内存刷新到工作内存，这样就保证了变量的可见性
• 实际上是通过内存屏障来实现的。语义上，内存屏障之前的所有写操作都要写入内存；内存屏障之后的读操作都可以获得同步屏障之前的写操作的结果。

Atomic

作用

• 当有多个线程同时对单个（包括基本类型及引用类型）变量进行操作时，具有排他性，即当多个线程同时对该变量的值进行更新时，仅有一个线程能成功，而未成功的线程可以像自旋锁一样，继续尝试，一直等到执行成功。

原理

• CAS操作（compare and swap 对比和设置），是通过一个cpu指令实现的，这个指令是一个原子指令，指令有3个操作数ABC，A为内存位置，B为预期值，C为新值，如果A符合旧预期值B，那么用V更新A的值，如果不符合就不更新，这个过程是原子操作
• 所以我们并没有通过代码来实现同步，而是通过硬件级别的cpu指令来实现的，并不像synchronized一样阻塞线程

//加一并返回值
public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
   }

//返回CAS操作成功与否
public final boolean compareAndSet(int expect, int update) {
        //根据变量在内存中的偏移地址valueOffset获取原值，然后和预期值except进行比，如果符合，用update值进行更新，这个过程是原子操作
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

• 如果此时有两个线程，线程A得到current值为1，线程B得到current值也为2，此时线程A执行CAS操作，成功将值改为2，而此时线程B执行CAS操作，发现此时内存中的值并不是读到current值1，所以返回false，此时线程B继续进行循环，最后成功加1

Lock

作用

• 显式加锁

原理

• 通过同步器AQS（AbstractQueuedSynchronized类）来实现的，AQS根本上是通过一个双向队列来实现的
• 线程构造成一个节点，一个线程先尝试获得锁，如果获取锁失败，就将该线程加到队列尾部
• 非公平锁的lock方法,调用的sync（NonfairSync和fairSync的父类）的lock方法

 public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

// ReentrantLock的lock方法
public void lock() {
        sync.lock();
    }

• NonfairSync的lock方法，acquire的是Sync的父类AQS的acquire方法

final void lock() {
            //如果当前同步状态为0(锁未被占有)，CAS操作设置同步状态，设置成功的话当前线程获得锁（如果此时是公平锁，那么不会执行compareAndSetState方法，直接acuire排队）
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            //否则调用AQS的acquire方法
            else
                acquire(1);
        }

 //CAS设置锁的状态
 protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

• AQS的acquire方法

//尝试获得锁，如果获取失败，将节点加入到尾节点
public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

• tryAcquire方法，尝试获得锁

final boolean nonfairTryAcquire(int acquires) {

    final Thread current = Thread.currentThread();
    //获取state变量值
    int c = getState();
    if (c == 0) { //如果没有线程占用锁
        if (compareAndSetState(0, acquires)) {
            //设置当前线程获得锁
            setExclusiveOwnerThread(current);
            return true;
        }
    } else if (current == getExclusiveOwnerThread()) { //当前线程已经占用该锁
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 更新state值为新的重入次数
        setState(nextc);
        return true;
    }
    //获取锁失败
    return false;
}

• 如果获取锁失败，将节点加入尾节点

private Node addWaiter(Node mode) {
         Node node = new Node(Thread.currentThread(), mode);
         // Try the fast path of enq; backup to full enq on failure
         Node pred = tail;
            //如果尾节点不为空
         if (pred != null) {
             node.prev = pred;
                //此时可能同时有其他线程插入，再进行判断（通过CAS）,如果没有，将节点设置为尾节点
             if (compareAndSetTail(pred, node)) {
                 pred.next = node;
                 return node;
             }
         }
            //如果节点为空或者节点不为空并且有其他线程插入（CAS返回false），执行enq方法
         enq(node);
         return node;
     }

• 如果节点为空或者节点不为空并且有其他线程插入（CAS返回false），执行enq

//通过自旋进行设置
private Node More enq(final Node node) {
         for (;;) {
             Node t = tail;
             if (t == null) { // Must initialize
                 if (compareAndSetHead(new Node()))
                     tail = head;
             } else {
                 node.prev = t;
                 if (compareAndSetTail(t, node)) {
                     t.next = node;
                     return t;
                 }
             }
         }
     }

• 进入队列的线程尝试获得锁

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true; //是否成功获取锁
    try {
        boolean interrupted = false; //线程是否被中断过
        for (;;) {
            final Node p = node.predecessor(); //获取前驱节点
            //如果前驱是head尝试获锁
            if (p == head && tryAcquire(arg)) {
                setHead(node); // 获取成功,将当前节点设置为head节点
                p.next = null; // 原head节点出队
                failed = false;
                return interrupted; //返回是否被中断过
            }
            // 前节点不是头节点或者获取失败，判断是否可以挂起
            if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                // 线程若被中断,设置interrupted为true
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

• 线程是否可以挂起

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //前驱节点的状态
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        // 前驱节点状态为signal(此节点线程结束后唤醒下一个节点线程)
        return true;
    //如果 前驱节点状态为CANCELLED(线程已经被取消)
    if (ws > 0) {
        // 删除cancelled状态的节点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 将前驱节点的状态设置为SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

• 挂起当前线程,返回线程中断状态并重置

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

我觉得分享是一种精神，分享是我的乐趣所在，不是说我觉得我讲得一定是对的，我讲得可能很多是不对的，但是我希望我讲的东西是我人生的体验和思考，是给很多人反思，也许给你一秒钟、半秒钟，哪怕说一句话有点道理，引发自己内心的感触，这就是我最大的价值。（这是我喜欢的一句话，也是我写博客的初衷）

作者：jiajun 出处： http://www.cnblogs.com/-new/

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。如果觉得还有帮助的话，可以点一下右下角的【推荐】，希望能够持续的为大家带来好的技术文章！想跟我一起进步么？那就【关注】我吧。