AQS之ReentrantLock特性和源码分析及CAS和LockSupport的核心原理

已于 2022-07-08 16:51:46 修改
阅读量258 收藏
点赞数
分类专栏： 并发编程 文章标签： java 开发语言
于 2022-07-01 16:54:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IUNIQUE/article/details/125503276
版权

系列文章目录

第一节 synchronized关键字详解-偏向锁、轻量级锁、偏向锁、重量级锁、自旋、锁粗化、锁消除
第二节 AQS抽象队列同步器原理详解

AQS之ReentrantLock特性和源码分析及CAS和LockSupport的核心原理

前言

ReentrantLock是一种基于AQS框架的应用实现，是JDK中的一种线程并发访问的同步手段，它的功能类似于synchronized，是一种互斥锁，可以保证线程安全。而且它具有比synchronized更多的特性，比如它支持手动加锁与解锁，支持加锁的公平性。

一、ReentrantLock公平与非公平性的实现

首先synchronized不具备的公平与非公平性，在ReentrantLock内部定义了一个Sync的内部类，该类继承AbstractQueuedSynchronized，对该抽象类的部分方法做了实现；ReentrantLock内部还定义了两个子类FairSync（公平锁）和NonfairSync（非公平锁），这两个类都继承自Sync，也就是间接继承了AbstractQueuedSynchronized，所以这一个ReentrantLock同时具备公平与非公平特性。

二、特性

1、公平锁与非公平锁

公平锁：

ReentrantLock lock = new ReentrantLock(true);

非公平锁：

ReentrantLock lock = new ReentrantLock(false);

默认情况下提供非公平锁，同时也可以在实例化的时候指定锁公平性

以下为源码部分：

#默认为非公平锁
public ReentrantLock() {
    sync = new NonfairSync();
}
#可指定公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

公平和非公平的含义：

  1. 公平和非公平，可以理解为实际生活中的排队，新来的人按规矩排在队尾是公平，插队就是非公平。
  2. 对于ReentrantLock锁也是同样的道理，新来线程排在阻塞队列的队尾即是公平，一上来就抢锁是非公平。
  3. 不同于现实生活的是，ReentrantLock默认非公平锁是为了减少线程间的切换，从而提高效率。

2、可重入锁

可重入指某个线程已经获得锁，可以再次获取锁而不会出现死锁，获取多少次锁就需要解锁多少次。

package com.xj;

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class ReentrantLocks {
    private static ReentrantLock lock = new ReentrantLock(true);

    public static void reentrantLock(){
        String threadName = Thread.currentThread().getName();
        lock.lock();
        log.info("Thread:{},第一次加锁",threadName);
        lock.lock();
        log.info("Thread:{},第二次加锁",threadName);
        lock.unlock();

        try{
            Thread.sleep(1000);
        }catch (Exception e){
        }

        log.info("Thread:{},第一次解锁",threadName);
        lock.unlock();
        log.info("Thread:{},第二次解锁",threadName);
    }

    public static void main(String[] args) {
        Thread t0 = new Thread(new Runnable() {
            @Override
            public void run() {
                reentrantLock();
            }
        },"t0");

        t0.start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                reentrantLock();
            }
        },"t1");

        t1.start();
    }
}

打印结果：

20:14:36.353 [t0] INFO com.xj.ReentrantLocks - Thread:t0,第一次加锁
20:14:36.353 [t0] INFO com.xj.ReentrantLocks - Thread:t0,第二次加锁
20:14:37.366 [t0] INFO com.xj.ReentrantLocks - Thread:t0,第一次解锁
20:14:37.366 [t0] INFO com.xj.ReentrantLocks - Thread:t0,第二次解锁
20:14:37.366 [t1] INFO com.xj.ReentrantLocks - Thread:t1,第一次加锁
20:14:37.366 [t1] INFO com.xj.ReentrantLocks - Thread:t1,第二次加锁
20:14:38.372 [t1] INFO com.xj.ReentrantLocks - Thread:t1,第一次解锁
20:14:38.372 [t1] INFO com.xj.ReentrantLocks - Thread:t1,第二次解锁

3、可中断

使用lock()方式加锁

package com.xj;

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class ReentrantLock_Interrupt {

    private static ReentrantLock lock = new ReentrantLock(true);

    public static void reentrantLock() {
        String threadName = Thread.currentThread().getName();
        boolean flag = false;
        lock.lock();
        log.info("Thread:{},加锁成功!",threadName);
        while(true){
            if(Thread.currentThread().isInterrupted()){
                log.info("Thread-Interrupted(线程被中断):{}",threadName);
                break;
            }
        }
        lock.unlock();
        log.info("Thread:{},锁退出同步块",threadName);
    }

    public static void main(String[] args) {
        //t0线程
        Thread t0 = new Thread(new Runnable() {
            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                try {
                    reentrantLock();
                } catch (Exception e) {
                    log.info("Thread-InterruptedException:{}",threadName);
                }
            }
        },"t0");
        t0.start();
        log.info("t0线程启动");

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //t1线程
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                try {
                    reentrantLock();
                } catch (Exception e) {
                    log.info("Thread-InterruptedException:{}",threadName);
                }
            }
        },"t1");
        t1.start();
        log.info("t1线程启动");

        try {
            log.info("main线程休眠5S");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        log.info("中断t0线程");
        t0.interrupt();
        t1.interrupt();
    }

}

打印结果：

20:51:04.592 [main] INFO com.xj.ReentrantLock_Interrupt - t0线程启动
20:51:04.592 [t0] INFO com.xj.ReentrantLock_Interrupt - Thread:t0,加锁成功!
20:51:05.108 [main] INFO com.xj.ReentrantLock_Interrupt - t1线程启动
20:51:05.108 [main] INFO com.xj.ReentrantLock_Interrupt - main线程休眠5S
20:51:10.116 [main] INFO com.xj.ReentrantLock_Interrupt - 中断t0线程
20:51:10.116 [t0] INFO com.xj.ReentrantLock_Interrupt - Thread-Interrupted(线程被中断):t0
20:51:10.116 [t0] INFO com.xj.ReentrantLock_Interrupt - Thread:t0,锁退出同步块
20:51:10.116 [t1] INFO com.xj.ReentrantLock_Interrupt - Thread:t1,加锁成功!
20:51:10.116 [t1] INFO com.xj.ReentrantLock_Interrupt - Thread-Interrupted(线程被中断):t1
20:51:10.116 [t1] INFO com.xj.ReentrantLock_Interrupt - Thread:t1,锁退出同步块

使用lockInterruptibly()方式加锁

package com.xj;

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class ReentrantLock_Interrupt {

    private static ReentrantLock lock = new ReentrantLock(true);

    public static void reentrantLock() throws InterruptedException {
        String threadName = Thread.currentThread().getName();
        boolean flag = false;
        lock.lockInterruptibly();
        log.info("Thread:{},加锁成功!",threadName);
        while(true){
            if(Thread.currentThread().isInterrupted()){
                log.info("Thread-Interrupted(线程被中断):{}",threadName);
                break;
            }
        }
        lock.unlock();
        log.info("Thread:{},锁退出同步块",threadName);
    }

    public static void main(String[] args) {
        //t0线程
        Thread t0 = new Thread(new Runnable() {
            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                try {
                    reentrantLock();
                } catch (InterruptedException e) {
                    log.info("Thread-InterruptedException:{}",threadName);
                }
            }
        },"t0");
        t0.start();
        log.info("t0线程启动");

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //t1线程
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                try {
                    reentrantLock();
                } catch (InterruptedException e) {
                    log.info("Thread-InterruptedException:{}",threadName);
                }
            }
        },"t1");
        t1.start();
        log.info("t1线程启动");

        try {
            log.info("main线程休眠5S");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        log.info("中断t1线程");
        t1.interrupt();

    }

}

打印结果：

21:00:31.220 [t0] INFO com.xj.ReentrantLock_Interrupt - Thread:t0,加锁成功!
21:00:31.220 [main] INFO com.xj.ReentrantLock_Interrupt - t0线程启动
21:00:31.735 [main] INFO com.xj.ReentrantLock_Interrupt - t1线程启动
21:00:31.735 [main] INFO com.xj.ReentrantLock_Interrupt - main线程休眠5S
21:00:36.751 [main] INFO com.xj.ReentrantLock_Interrupt - 中断t1线程
21:00:36.751 [t1] INFO com.xj.ReentrantLock_Interrupt - Thread-InterruptedException:t1

三、源码分析

1、ReentrantLock#lock

ReentrantLock#lock调用了sync.lock()，Sync中lock()是一个抽象函数，具体的实现在其子类NonfairSync和FairSync中。

public void lock() {
   sync.lock();
}

抽象类Sync：

abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
        abstract void lock();
        //省略
}

（1）ReentrantLock.NonfairSync

ReentrantLock.NonfairSync#lock实现了Sync中的抽象方法lock，其非公平性体现在，一上来就抢锁设置state状态compareAndSetState(0,1)，如果抢锁成功就设置当前线程为持有独占锁的线程setExclusiveOwnerThread(Thread.currentThread())。

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
        	//非公平，直接CAS进行修改state状态，进行抢锁
            if (compareAndSetState(0, 1))
            	//抢成功，设置当前独占锁的线程为当前线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
            	//没有抢到，会再次抢一次，没有抢到则进入同步队列
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

如果一开始抢锁失败则进入AQS的模板方法acquire(1)，acquire(1)中还会再进行一次抢锁tryAcquire
，抢锁还是失败才进入AQS队列操作acquireQueued(addWaiter(Node.EXCLUSIVE), arg)。

public final void acquire(int arg) {
		//没有抢到锁，则进入等待队列
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            //自己中断自己，设置中断标记
            selfInterrupt();
    }

加锁的通用模板acquire()已经在AQS中实现，子类只需要实现tryAcquire即可。NonfairSync#tryAcquire调用了父类的Sync#nonfairTryAcquire。
具体逻辑如下：

  1. 查看当前state，是否有线程持有锁，state=0无线程持有锁，可以继续抢锁。
  2. 有线程持有锁，判断持有锁的线程是否是当前线程，如果是就重入，给state加上acquires值。
protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
}

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
            	//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");
                
                setState(nextc);
                return true;
            }
            return false;
}

（2）ReentrantLock.FairSync

FairSync和NonfairSync的主要区别在于，FairSync不会一上来就抢锁，而是先判断队列中是否有其他线程在等待锁，没有再抢锁。代码的模板逻辑和NonfairSync类似，区别在于FairSync中tryAcquire
的实现。

public final void acquire(int arg) {
		//没有抢到锁，则进入等待队列
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            //自己中断自己，设置中断标记
            selfInterrupt();
}

		/**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
            	//判断队列中是否有线程在等待锁，没有则抢锁
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //如果当前线程已经持有该锁，可重入
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

hasQueuedPredecessors（）源码如下：

public final boolean hasQueuedPredecessors() {
        // The correctness of this depends on head being initialized
        // before tail and on head.next being accurate if the current
        // thread is first in queue.
        //指针t指向队尾
        Node t = tail; // Read fields in reverse initialization order
        //指针h指向队头
        Node h = head;
        Node s;
        //队头不等于队尾且队头的后继节点为null或者是后继节点的线程非当前线程
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
}

acquireQueued（）源码如下：

final boolean acquireQueued(final Node node, int arg) {
		//失败标记
        boolean failed = true;
        try {
            //中断标记
            boolean interrupted = false;
            //自旋
            for (;;) {
                //获取node节点的前驱节点
                final Node p = node.predecessor();
                //如果当前节点的前驱节点为队头，且当前线程再次尝试获取锁
                if (p == head && tryAcquire(arg)) {
                	//当前线程获取到了锁，将当前节点设置为头节点
                    setHead(node);
                    //前驱节点从队列中移除
                    p.next = null; // help GC
                    //没有发现错误
                    failed = false;
                    //返回此时的中断标记
                    return interrupted;
                }
                //如果条件不满足，则进入以下的逻辑
                //shouldParkAfterFailedAcquire(p, node)返回true只能是前驱节点的信号量状态为SIGNAL,不为SIGNAL且不为CANCELLED，会先执行compareAndSetWaitStatus修改信号量为SIGNAL状态
                //
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    //说明是中断唤醒的线程，设置中断标记true
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

//将当前节点设置为头节点
private void setHead(Node node) {
        head = node;
        //清空当前节点thread和prev内容
        node.thread = null;
        node.prev = null;
}

//检查和更新获取失败的节点的状态。 
//如果线程阻塞，返回true
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
		//获取前驱节点的信号量状态
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;//如果为SIGNAL（-1），返回true
        if (ws > 0) {//>0的情况，只能是CANCELLED状态，需要被跳过
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                //找前驱节点的前驱节点，并判断其的信号量状态
                //不为>0,退出循环
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            //将找出来的前驱节点的后继节点指针指向当前节点
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            //waitStatus必须为0或PROPAGATE。
            //CAS修改WaitStatus为SIGNAL
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
}

//线程驻留，然后返回中断标记
private final boolean parkAndCheckInterrupt() {
        //线程驻留
        LockSupport.park(this);
        //之所以需要返回中断标记，是因为线程如果被中断会被唤醒，所以需要在这里返回状态，并清空中断标记
        return Thread.interrupted();
}

//自己中断自己，设置中断标记
static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }

2、ReentrantLock#lockInterruptibly

lock中断是通过自己设置中断标记以及业务自己在程序代码里面进行退出线程，从而达到中断的效果。lockInterruptibly是直接抛出中断异常，其调用了AQS的模板方法acquireInterruptibly。

public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

public final void acquireInterruptibly(int arg)
            throws InterruptedException {
        //判断中断标记，并清空
        //true抛出中断异常
        if (Thread.interrupted())
            throw new InterruptedException();
        if (!tryAcquire(arg))
            doAcquireInterruptibly(arg);
    }

tryAcquire和上面的源码分析类似，而doAcquireInterruptibly也类似，没有了中断标记设置相关的逻辑，而是抛出了中断异常。

private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

3、ReentrantLock#tryLock

tryLock尝试获取锁，调用的是sync.nonfairTryAcquire(1)，使用的是非公平获取锁，不会涉及到AQS队列操作，获取锁成功返回true，失败返回false。

public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
}

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
            	//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");
                
                setState(nextc);
                return true;
            }
            return false;
}

tryLock还有一个重载方法，可传入一个超时时长timeout和一个时间单位TimeUnit，超时时长会被转为纳秒级。

public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        //判断中断标记并清空
        if (Thread.interrupted())
        	//抛出中断异常
            throw new InterruptedException();
        return tryAcquire(arg) ||
            doAcquireNanos(arg, nanosTimeout);
}

private boolean doAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        //判断超时时间
        if (nanosTimeout <= 0L)
            return false;
        //截止时间=系统当前时间+超时时间
        final long deadline = System.nanoTime() + nanosTimeout;
        //进入同步等待队列
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return true;
                }
                //获取超时时间
                nanosTimeout = deadline - System.nanoTime();
                //<0l超时时间已到,返回false，代表获取锁超时
                if (nanosTimeout <= 0L)
                    return false;
                
                if (shouldParkAfterFailedAcquire(p, node) &&
                    nanosTimeout > spinForTimeoutThreshold)
                    //线程停留超时时间
                    LockSupport.parkNanos(this, nanosTimeout);
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

4、ReentrantLock#unlock

释放锁的过程没有区分公平性，调用的是AQS的模板方法release()

public void unlock() {
        sync.release(1);
}

其基本逻辑如下：

  1. 释放锁tryRelease，逻辑由ReentrantLock实现。
  2. 唤醒后继节点unparkSuccessor，逻辑由由AQS负责。
public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

释放锁的代码ReentrantLock.Sync#tryRelease基本逻辑如下：

  1. 判断持有锁的线程是否是当前线程，不是当前线程则抛出异常。
  2. 判断释放之后的state==0，等于0说明完全释放锁，将持锁的线程设置为null。
  3. 修改state，因为是排它锁，只有当前线程才会走到这里，所以是线程安全的。
protected final boolean tryRelease(int releases) {
			//计算释放锁之后的state值
            int c = getState() - releases;
            //不是当前线程，不能unLock 抛异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
            	//c = 0,证明没有线程持有锁了,将独占线程字段内容清空
                free = true;
                setExclusiveOwnerThread(null);
            }
            //线程安全,此为排它锁，只有当前线程会走到这修改state
            setState(c);
            return free;
}

注：如果是当前线程多次重入，releases=1是不能完全释放锁的，free=false，也不会唤醒后继节点。

     /**
     * Wakes up node's successor, if one exists.
     * 唤醒后继节点
     *
     * @param node the node
     */
    private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        //当前节点信号量状态<0 为负数
        int ws = node.waitStatus;
        if (ws < 0)
        	//CAS算法设置WaitStatus为0
            compareAndSetWaitStatus(node, ws, 0);

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        //指针s指向node的后继节点
        Node s = node.next;
        //后继节点为空或者是信号量状态>0(CANCELLED)
        if (s == null || s.waitStatus > 0) {
        	//后继节点置空
            s = null;
            //查找符合条件的节点，从尾部向后遍历查找
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        //后继节点不为空
        if (s != null)
        	//解除驻留
            LockSupport.unpark(s.thread);
    }

四、CAS算法

  1. CAS的全称是Compare And
    Swap（比较并交换），CAS是一种无锁算法（不使用锁而保证多线程安全），也是乐观锁的技术，能让线程不需要通过阻塞就能够避免多线程安全问题。
  2. CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

（1）CAS代码案例

CAS操作对象基于unsafe类，其无法实例化，只能通过反射来获取Unsafe，以下是获取unsafe实例代码：

public class UnsafeInstance {
    public static Unsafe reflectGetUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

CAS案例：

public class CompareAndSwap {
    /**
     * 记录当前加锁状态
     */
    volatile int state = 0;

    private static CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
        @Override
        public void run() {
            log.info("所有线程都准备好了.....");
        }
    });
    private static CompareAndSwap cas = new CompareAndSwap();

    public static void main(String[] args) {
        new Thread(new WorkerThread(),"t0").start();
        new Thread(new WorkerThread(),"t1").start();
        new Thread(new WorkerThread(),"t2").start();
        new Thread(new WorkerThread(),"t3").start();
        new Thread(new WorkerThread(),"t4").start();
    }

    static class WorkerThread implements Runnable{

        @Override
        public void run() {
            log.info("线程{}到达预定点,准备开始抢state:",Thread.currentThread().getName());
            try {
                cyclicBarrier.await();
                if(cas.compareAndSwapState(0,1)){
                    log.info("线程{},抢到锁!",Thread.currentThread().getName());
                }else{
                    log.info("线程{},抢锁失败!",Thread.currentThread().getName());
                }
            } catch (InterruptedException| BrokenBarrierException e) {
                e.printStackTrace();
            }
        }

    }

    /**
     * 原子操作
     * @param oldValue线程工作内存当中的值
     * @param newValue:要替换的新值
     * @return
     */
    public final boolean compareAndSwapState(int oldValue,int newValue){
        return unsafe.compareAndSwapInt(this,stateOffset,oldValue,newValue);
    }

    private static final Unsafe unsafe = UnsafeInstance.reflectGetUnsafe();

    private static final long stateOffset;

    static {
        try {
            stateOffset = unsafe.objectFieldOffset(CompareAndSwap.class.getDeclaredField("state"));
        } catch (Exception e) {
            e.printStackTrace();
            throw new Error();
        }
    }
}

（2）ABA问题

ABA问题在于cas在修改变量的时候，无法记录变量的状态，比如修改的次数，否修改过这个变量。这样就很容易在一个线程将A修改成B时，另一个线程又会把B修改成A,造成CAS多次执行的问题。
例如主线程操作账户余额过程中（进账100元）需要耗时一段时间，这段时间中干扰线程先进账100元，此时账户余额200，然后出账100元，此时账户余额100元，最终主线程得到账户余额为200，也就是金额出现了200->100->200情况

public class ABAProblem {

    static AtomicInteger atomicInteger = new AtomicInteger(100);

    public static void main(String[] args) {
        Thread main = new Thread(new Runnable() {
            @Override
            public void run() {
                int account = atomicInteger.get();
                log.info(Thread.currentThread().getName()+"——修改前账户余额:"+account);
                try {
                    log.info(Thread.currentThread().getName()+"——账户其它操作，需要一段时间");
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(atomicInteger.compareAndSet(account,account + 100)){
                    log.info(Thread.currentThread().getName()+"——CAS进账100元:"+atomicInteger.get());
                }else{
                    log.info(Thread.currentThread().getName()+"——CAS修改账户余额失败");
                }
            }
        },"主线程");

        Thread other = new Thread(new Runnable() {
            @Override
            public void run() {
                atomicInteger.compareAndSet(atomicInteger.get(),atomicInteger.get() + 100);// 1+1 = 2;
                log.info(Thread.currentThread().getName()+"——CAS进账100元:"+atomicInteger.get());
                atomicInteger.compareAndSet(atomicInteger.get(),atomicInteger.get() - 100);// atomic-1 = 2-1;
                log.info(Thread.currentThread().getName()+"--CAS出账100元:"+atomicInteger.get());
            }
        },"干扰线程");

        main.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        other.start();

    }
}

打印结果：

11:07:29.461 [主线程] INFO com.xj.ABAProblem - 主线程——修改前账户余额:100
11:07:29.463 [主线程] INFO com.xj.ABAProblem - 主线程——账户其它操作，需要一段时间
11:07:29.970 [干扰线程] INFO com.xj.ABAProblem - 干扰线程——CAS进账100元:200
11:07:29.970 [干扰线程] INFO com.xj.ABAProblem - 干扰线程--CAS出账100元:100
11:07:32.476 [主线程] INFO com.xj.ABAProblem - 主线程——CAS进账100元:200

（3）ABA解决

通过AtomicStampReference类来解决该问题，其是在CAS的基础上增加了一个标记stamp，使用这个标记可以用来觉察数据是否发生变化，给数据带上了一种实效性的检验。

public class AtomicStampedRerenceExample {

    //初始化AtomicStampedReference
    private static AtomicStampedReference<Integer> atomicStampedRef =
            new AtomicStampedReference<>(100, 0);

    public static void main(String[] args){
        //主线程
        Thread main = new Thread(() -> {
            //获取当前标识
            int version = atomicStampedRef.getStamp();
            System.out.println(Thread.currentThread().getName()+ ":version="+version + ",初始值account = " + atomicStampedRef.getReference());
            try {
                Thread.sleep(3000); //等待3秒 ，以便让干扰线程执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean isCASSuccess = atomicStampedRef.compareAndSet(atomicStampedRef.getReference(),atomicStampedRef.getReference() + 100,version,version +1);  //此时expectedReference未发生改变，但是stamp已经被修改了,所以CAS失败
            System.out.println(Thread.currentThread().getName() + ":version="+version + ",CAS操作结果: " + isCASSuccess);
        },"主线程");

        //干扰线程
        Thread other = new Thread(() -> {
            //获取当前标识
            int version = atomicStampedRef.getStamp();
            atomicStampedRef.compareAndSet(atomicStampedRef.getReference(),atomicStampedRef.getReference() + 100,version,version+1);
            System.out.println(Thread.currentThread().getName() + ":version="+atomicStampedRef.getStamp() +",[INCR],值 a= "+ atomicStampedRef.getReference());

            //再次获取当前标识
            version = atomicStampedRef.getStamp();
            atomicStampedRef.compareAndSet(atomicStampedRef.getReference(),atomicStampedRef.getReference() - 100,version,version+1);
            System.out.println(Thread.currentThread().getName() + ":version="+atomicStampedRef.getStamp() +",[DECR],值 a= "+ atomicStampedRef.getReference());
        },"干扰线程");

        main.start();
        LockSupport.parkNanos(1000000);
        other.start();
    }

打印结果：

主线程:version=0,初始值account = 100
干扰线程:version=1,[INCR],值 a= 200
干扰线程:version=2,[DECR],值 a= 100
主线程:version=0,将账户余额增加100的CAS操作结果: false

五、LockSupport

LockSupport是concurrent包中一个工具类，不支持构造，提供了很多static方法，常见的比如park(),unpark()等。

public class LockSupportExample {

    public static void main(String[] args) {

        Thread t0 = new Thread(new Runnable() {
            @Override
            public void run() {
                Thread current = Thread.currentThread();
                log.info("线程{},开始执行!",current.getName());
                for(;;){//spin 自旋
                    log.info("准备park当前线程:{}....",current.getName());
                    LockSupport.park();
                    //此处需要执行Thread.interrupted()，用于清空中断标记，否则将无法再次park
                    if(Thread.interrupted()){
                        log.info(current.getName()+"线程被中断唤醒");
                    }
                    log.info("当前线程{}已经被唤醒....",current.getName());

                }
            }
        },"t0");

        t0.start();

        try {
            Thread.sleep(5000);
            log.info("准备唤醒{}线程!",t0.getName());
            //unpark解除t0线程驻留
            LockSupport.unpark(t0);
            Thread.sleep(2000);
            //中断唤醒t0线程
            t0.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

打印结果：

16:47:56.534 [t0] INFO com.xj.LockSupportExample - 线程t0,开始执行!
16:47:56.537 [t0] INFO com.xj.LockSupportExample - 准备park当前线程:t0....
16:48:01.532 [main] INFO com.xj.LockSupportExample - 准备唤醒t0线程!
16:48:01.532 [t0] INFO com.xj.LockSupportExample - 当前线程t0已经被唤醒....
16:48:01.532 [t0] INFO com.xj.LockSupportExample - 准备park当前线程:t0....
16:48:03.547 [t0] INFO com.xj.LockSupportExample - t0线程被中断唤醒
16:48:03.547 [t0] INFO com.xj.LockSupportExample - 当前线程t0已经被唤醒....
16:48:03.547 [t0] INFO com.xj.LockSupportExample - 准备park当前线程:t0....

总结

本节主要介绍的是ReentrantLock相关特性与源码分析，以及关于实现Lock锁的CAS与LockSupport的核心原理。

IUNIQUE
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LockSupport原理解析及源码
u012464024的博客
05-24 723
目录概览LockSupport解析用法：具体使用：原理概述：源码解析：底层原理：park原理流程图：unpark原理流程图：park() 源码：unpark() 源码：Q & A1. unpark是否可以调用多次，以获取多个permit？2. unpark是否一定要在park之后调用？3. park会像wait()一样睡眠释放当前锁吗？ LockSupport解析 LockSupport 底层使用Posix线程库pthreads的系统级别锁互斥量mutex和condition，所以它的系统消耗是比
AQS、ReentrantLock、ReentrantReadWriteLock 结构与源码分析
一步一步往上爬
07-28 917
AQS 以及其实现类 ReentrantLock、ReentrantReadWriteLock 源码分析。
Java中的锁分类与使用
qq_44912603的博客
10-19 144
Java锁的种类 　　在笔者面试过程时，经常会被问到各种各样的锁，如乐观锁、读写锁等等，非常繁多，在此做一个总结。介绍的内容如下： 乐观锁/悲观锁 独享锁/共享锁 互斥锁/读写锁 可重入锁 公平锁/非公平锁 分段锁 偏向锁/轻量级锁/重量级锁 自旋锁 　　以上是一些锁的名词，这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计，下面总结的内容是对每个锁的名词进行一定的解释。 1.1 乐观锁/悲观锁 　　乐观锁与悲观锁并不是特指某两种类型的锁，是人们定义出来的概念或思想，主要是指看待并发同步的角度.
ReentrantLock 实现原理
crossoverJie专栏
01-26 272
使用 `synchronize` 来做同步处理时，锁的获取和释放都是隐式的，实现的原理是通过编译后加上不同的机器指令来实现。 而 ReentrantLock 就是一个普通的类，它是基于 AQS(AbstractQueuedSynchronizer)来实现的。 是一个重入锁：一个线程获得了锁之后仍然可以反复的加锁，不会出现自己阻塞自己的情况。 AQS 是 Java 并发包里实现锁、同步
【并发编程进阶6】ReentrantLock 和 LockSupport
檀越的博客
04-17 218
首先明确下 synchronized 和 lock 接口均为可重入锁。重入锁,顾名思义,就是支持重进入的锁,它表示该锁能够支持一个线程对资源的重复加锁。线程再次获取锁.锁需要去识别获取锁的线程是否为当前占据锁的线程,如果是,则再次成功获取。锁的最终释放.线程重复 n 次获取了锁,随后在第 n 次释放该锁后,其他线程能够获取到该锁.锁的最终释放要求锁对于获取进行计数自增,计数表示当前锁被重复获取的次数,而锁被释放时,计数自减,当计数等于 0 时表示锁已经成功释放。
java多线程之LockSupport及ReentrantLock
stormCoder的博客
09-02 1447
目前java语言层面能够实现线程的阻塞与唤醒,主要包含两个组合对wait/notify以及park/unpark。wait/notify这组组合中wait必须发生在notify前面，否则很可能造成线程会一直阻塞,而park与unpark则不必,但是如果unpark先执行,后面执行park操作将不会阻塞。JDK并发中的AQS框架使用的就是LockSupport中的park/unpark操作，实际上调用
面试必问之AQS原理详解.pdf
08-08
AbstractQueuedSynchronizer（AQS）是Java并发包中的核心组件，主要用于构建锁和同步器，如ReentrantLock等。AQS通过维护一个FIFO（先进先出）的等待队列（CLH队列）来管理线程的同步。CLH队列是一个虚拟队列，由...
笔记-4、显式锁和AQS(1)1
08-08
`LockSupport`工具类提供了`park()`和`unpark(Thread thread)`方法，用于线程的阻塞和唤醒，这些方法在AQS中起到了关键作用。 总之，显式锁和AQS的出现极大地丰富了Java并发编程的能力，通过定制化同步策略，我们...
尚硅谷大厂面试题第三季周阳主讲
06-24
此外，还提到了LockSupport如何实现线程的阻塞和唤醒，以及AbstractQueuedSynchronizer (AQS) 在锁和同步器实现中的重要性。 【标签】"redis Java后端面试题"表明了Redis作为重要的内存数据存储系统，在Java后端...
Java面试题并发部分.docx
06-15
10. **AQS的工作协调**：AQS使用`LockSupport`来阻塞和唤醒线程。线程通过调用`park`方法进入等待状态，当有许可证可用时，`unpark`方法会释放一个许可证，唤醒等待的线程。 11. **AQS工作原理**：AQS使用一个...
Java 并发编程一篇 -（Synchronized 原理、LockSupport 原理、ReentrantLock 原理）
qq_40820563的博客
06-29 439
一、基本概念 1、进程与线程 进程 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的。 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器 等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等） 线程 一个进程之内可以分为一到多个线程
停个车真的不是一般的难ReentrantLock.lock之LockSupport.park
简单就是美！
07-17 440
今碰到一问题，原以为代码用上 ReentrantLock.lock 想当然以为就是个很好用的东西，至少说不会出大问题吧，可是万万没有想到的是： 在Web Container最大线程数设置了500线情况下，压力测试了一把，居然给我满了，一看，原来这么壮观的场面，第一次碰到。圈中的代码省略，大家看看估计会是由于什么问题导致的？ [img]/upload/attachment/126167/...
ReentrantLock与Condition实现生产者消费者，模拟延时用LockSupport.parkNanos
老专家的博客
05-10 2511
使用ReentrantLock与Condition实现生产者消费者 主要有Producer，Consumer，Pool 生产池 在测试多线程程序时，最后【多建线程】才能明显看出并发时，是否数据异常。建议10到30个线程 创建的线程数少，模拟的延时太高，多线程可能会依次执行，不能判断是否线程安全 Pool生产池，封装也生产与消费的方法，注意里面的【while循环】判断Pool是否满或者空，负责会产出...
解析Concurrent包下的ReentrantLock、LockSupport、AQS
SmuEdward的博客
02-14 1006
本文转自老马编程，微信公众号：laoma_shuoJava并发包中的显式锁接口和类位于包java.util.concurrent.locks下，主要接口和类有： 锁接口Lock，主要实现类是ReentrantLock 读写锁接口ReadWriteLock，主要实现类是ReentrantReadWriteLock本节主要介绍接口Lock和实现类ReentrantLock，关于读写锁，我们后续章节介
ReentrantLock详解(可重入、可中断、锁超时、公平锁、条件变量)、同步模式之顺序控制
热门推荐
张大安的博客
03-12 1万+
文章目录1.ReentrantLock详解1.1 可重入1.2 可中断 lockInterruptibly()1.3 设置超时时间 tryLock()1.4 通过lock.tryLock()来解决, 哲学家就餐问题1.5 公平锁 new ReentrantLock(true)1.6 条件变量 Condition 1.ReentrantLock详解 相对于synchronized 它具备如下特点 可中断 可以设置超时时间 可以设置为公平锁 支持多个条件变量 与 synchronized 一样,都支持可重入
Java中LockSupport的使用
black_bird_cn的博客
09-11 2031
一、基本使用 LockSupport是JDK1.6中在java.util.concurrent中的子包locks中引入的一个比较底层的工具类，用来创建锁和其他同步工具类的基本线程阻塞原语。java锁和同步器框架的核心 AQS: AbstractQueuedSynchronizer，就是通过调用 LockSupport .park()和 LockSupport .unpark()实现线程的阻塞和唤...
Java中可重入锁ReentrantLock原理剖析
Flyer的后花园
09-01 8862
一、 概述 本文首先介绍Lock接口、ReentrantLock的类层次结构以及锁功能模板类AbstractQueuedSynchronizer的简单原理，然后通过分析ReentrantLock的lock方法和unlock方法，来解释ReentrantLock的内部原理，最后做一个总结。本文不涉及ReentrantLock中的条件变量。 1.1、Lock接口 Lock接口，是对控制并发的工具...
AQS、LockSupport、Lock和ReentrantLock、Condition
gao_tianLiang的博客
03-20 264
AQS、LockSupport、Lock和ReentrantLock、Condition
Java并发编程：深入解析抽象队列同步器(AQS)及其在Lock中的应用
最新发布
12-11
"Java并发编程的关键...通过对AQS源码的分析，我们可以更深入地理解其内部的工作原理，如等待队列的管理、线程的阻塞和唤醒机制，以及状态变更的原子操作。这对于提升并发编程的技能和优化多线程应用的性能至关重要。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值