文档章节

java公平锁和非公平锁

 北极之北
发布于 2017/11/13 11:18
字数 3613
阅读 20
收藏 0

最常用的方式:

 View Code

1、对于ReentrantLock需要掌握以下几点

  • ReentrantLock的创建(公平锁/非公平锁)
  • 上锁:lock()
  • 解锁:unlock()

首先说一下类结构:

  • ReentrantLock-->Lock
  • NonfairSync/FairSync-->Sync-->AbstractQueuedSynchronizer-->AbstractOwnableSynchronizer
  • NonfairSync/FairSync-->Sync是ReentrantLock的三个内部类
  • Node是AbstractQueuedSynchronizer的内部类

注意:上边这四条线,对应关系:"子类"-->"父类"

 

2、ReentrantLock的创建

  • 支持公平锁(先进来的线程先执行)
  • 支持非公平锁(后进来的线程也可能先执行)

非公平锁与非公平锁的创建

  • 非公平锁:ReentrantLock()或ReentrantLock(false)
    final ReentrantLock lock = new ReentrantLock();
  • 公平锁:ReentrantLock(true)
    final ReentrantLock lock = new ReentrantLock(true)

默认情况下使用非公平锁。

源代码如下:

ReentrantLock:

复制代码

/** 同步器:内部类Sync的一个引用 */
    private final Sync sync;

    /**
     * 创建一个非公平锁
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * 创建一个锁
     * @param fair true-->公平锁  false-->非公平锁
     */
    public ReentrantLock(boolean fair) {
        sync = (fair)? new FairSync() : new NonfairSync();
    }

复制代码

上述源代码中出现了三个内部类Sync/NonfairSync/FairSync,这里只列出类的定义,至于这三个类中的具体的方法会在后续的第一次引用的时候介绍。

Sync/NonfairSync/FairSync类定义:

复制代码

/**
     * 该锁同步控制的一个基类.下边有两个子类:非公平机制和公平机制.使用了AbstractQueuedSynchronizer类的
     */
    static abstract class Sync extends AbstractQueuedSynchronizer

    /**
     * 非公平锁同步器
     */
    final static class NonfairSync extends Sync

    /**
     * 公平锁同步器
     */
    final static class FairSync extends Sync

复制代码

 

3、非公平锁的lock()

具体使用方法:

lock.lock();

下面先介绍一下这个总体步骤的简化版,然后会给出详细的源代码,并在源代码的lock()方法部分给出详细版的步骤。

 

简化版的步骤:(非公平锁的核心)

基于CAS尝试将state(锁数量)从0设置为1

A、如果设置成功,设置当前线程为独占锁的线程;

B、如果设置失败,还会再获取一次锁数量,

B1、如果锁数量为0,再基于CAS尝试将state(锁数量)从0设置为1一次,如果设置成功,设置当前线程为独占锁的线程;

B2、如果锁数量不为0或者上边的尝试又失败了,查看当前线程是不是已经是独占锁的线程了,如果是,则将当前的锁数量+1;如果不是,则将该线程封装在一个Node内,并加入到等待队列中去。等待被其前一个线程节点唤醒。

 

源代码:(再介绍源代码之前,心里有一个获取锁的步骤的总的一个印象,就是上边这个"简化版的步骤")

3.1、ReentrantLock:lock()

复制代码

/**
     *获取一个锁
     *三种情况:
     *1、如果当下这个锁没有被任何线程(包括当前线程)持有,则立即获取锁,锁数量==1,之后再执行相应的业务逻辑
     *2、如果当前线程正在持有这个锁,那么锁数量+1,之后再执行相应的业务逻辑
     *3、如果当下锁被另一个线程所持有,则当前线程处于休眠状态,直到获得锁之后,当前线程被唤醒,锁数量==1,再执行相应的业务逻辑
     */
    public void lock() {
        sync.lock();//调用NonfairSync(非公平锁)或FairSync(公平锁)的lock()方法
    }

复制代码

3.2、NonfairSync:lock()

复制代码

/**
         * 1)首先基于CAS将state(锁数量)从0设置为1,如果设置成功,设置当前线程为独占锁的线程;-->请求成功-->第一次插队
         * 2)如果设置失败(即当前的锁数量可能已经为1了,即在尝试的过程中,已经被其他线程先一步占有了锁),这个时候当前线程执行acquire(1)方法
         * 2.1)acquire(1)方法首先调用下边的tryAcquire(1)方法,在该方法中,首先获取锁数量状态,
         * 2.1.1)如果为0(证明该独占锁已被释放,当下没有线程在使用),这个时候我们继续使用CAS将state(锁数量)从0设置为1,如果设置成功,当前线程独占锁;-->请求成功-->第二次插队;当然,如果设置不成功,直接返回false
         * 2.2.2)如果不为0,就去判断当前的线程是不是就是当下独占锁的线程,如果是,就将当前的锁数量状态值+1(这也就是可重入锁的名称的来源)-->请求成功
         * 
         * 下边的流程一句话:请求失败后,将当前线程链入队尾并挂起,之后等待被唤醒。
         * 
         * 2.2.3)如果最后在tryAcquire(1)方法中上述的执行都没成功,即请求没有成功,则返回false,继续执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法
         * 2.2)在上述方法中,首先会使用addWaiter(Node.EXCLUSIVE)将当前线程封装进Node节点node,然后将该节点加入等待队列(先快速入队,如果快速入队不成功,其使用正常入队方法无限循环一直到Node节点入队为止)
         * 2.2.1)快速入队:如果同步等待队列存在尾节点,将使用CAS尝试将尾节点设置为node,并将之前的尾节点插入到node之前
         * 2.2.2)正常入队:如果同步等待队列不存在尾节点或者上述CAS尝试不成功的话,就执行正常入队(该方法是一个无限循环的过程,即直到入队为止)-->第一次阻塞
         * 2.2.2.1)如果尾节点为空(初始化同步等待队列),创建一个dummy节点,并将该节点通过CAS尝试设置到头节点上去,设置成功的话,将尾节点也指向该dummy节点(即头节点和尾节点都指向该dummy节点)
         * 2.2.2.1)如果尾节点不为空,执行与快速入队相同的逻辑,即使用CAS尝试将尾节点设置为node,并将之前的尾节点插入到node之前
         * 最后,如果顺利入队的话,就返回入队的节点node,如果不顺利的话,无限循环去执行2.2)下边的流程,直到入队为止
         * 2.3)node节点入队之后,就去执行acquireQueued(final Node node, int arg)(这又是一个无限循环的过程,这里需要注意的是,无限循环等于阻塞,多个线程可以同时无限循环--每个线程都可以执行自己的循环,这样才能使在后边排队的节点不断前进)
         * 2.3.1)获取node的前驱节点p,如果p是头节点,就继续使用tryAcquire(1)方法去尝试请求成功,-->第三次插队(当然,这次插队不一定不会使其获得执行权,请看下边一条),
         * 2.3.1.1)如果第一次请求就成功,不用中断自己的线程,如果是之后的循环中将线程挂起之后又请求成功了,使用selfInterrupt()中断自己
         * (注意p==head&&tryAcquire(1)成功是唯一跳出循环的方法,在这之前会一直阻塞在这里,直到其他线程在执行的过程中,不断的将p的前边的节点减少,直到p成为了head且node请求成功了--即node被唤醒了,才退出循环)
         * 2.3.1.2)如果p不是头节点,或者tryAcquire(1)请求不成功,就去执行shouldParkAfterFailedAcquire(Node pred, Node node)来检测当前节点是不是可以安全的被挂起,
         * 2.3.1.2.1)如果node的前驱节点pred的等待状态是SIGNAL(即可以唤醒下一个节点的线程),则node节点的线程可以安全挂起,执行2.3.1.3)
         * 2.3.1.2.2)如果node的前驱节点pred的等待状态是CANCELLED,则pred的线程被取消了,我们会将pred之前的连续几个被取消的前驱节点从队列中剔除,返回false(即不能挂起),之后继续执行2.3)中上述的代码
         * 2.3.1.2.3)如果node的前驱节点pred的等待状态是除了上述两种的其他状态,则使用CAS尝试将前驱节点的等待状态设为SIGNAL,并返回false(因为CAS可能会失败,这里不管失败与否,都返回false,下一次执行该方法的之后,pred的等待状态就是SIGNAL了),之后继续执行2.3)中上述的代码
         * 2.3.1.3)如果可以安全挂起,就执行parkAndCheckInterrupt()挂起当前线程,之后,继续执行2.3)中之前的代码
         * 最后,直到该节点的前驱节点p之前的所有节点都执行完毕为止,我们的p成为了头节点,并且tryAcquire(1)请求成功,跳出循环,去执行。
         * (在p变为头节点之前的整个过程中,我们发现这个过程是不会被中断的)
         * 2.3.2)当然在2.3.1)中产生了异常,我们就会执行cancelAcquire(Node node)取消node的获取锁的意图。
         */
        final void lock() {
            if (compareAndSetState(0, 1))//如果CAS尝试成功
                setExclusiveOwnerThread(Thread.currentThread());//设置当前线程为独占锁的线程
            else
                acquire(1);
        }

复制代码

注意:在这个方法中,我列出了一个线程获取锁的详细的过程,自己看注释。

下面列出NonfairSync:lock()中调用的几个方法与相关属性。

3.2.1、AbstractQueuedSynchronizer:锁数量state属性+相关方法:

复制代码

/**
     * 锁数量
     */
    private volatile int state;

    /**
     * 获取锁数量
     */
    protected final int getState() {
        return state;
    }

    protected final void setState(int newState) {
        state = newState;
    }

复制代码

注意:state是volatile型的

3.2.2、AbstractOwnableSynchronizer:属性+setExclusiveOwnerThread(Thread t)

复制代码

/**
     * 当前拥有独占锁的线程
     */
    private transient Thread exclusiveOwnerThread;

    /**
     * 设置独占锁的线程为线程t
     */
    protected final void setExclusiveOwnerThread(Thread t) {
        exclusiveOwnerThread = t;
    }

复制代码

3.2.3、AbstractQueuedSynchronizer:属性+acquire(int arg)

复制代码

/**
     * 获取锁的方法
     * @param arg
     */
    public final void acquire(int arg) {
        if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();//中断自己
    }

复制代码

在介绍上边这个方法之前,先要说一下AbstractQueuedSynchronizer的一个内部类Node的整体构造,源代码如下:

复制代码

/**
     * 同步等待队列(双向链表)中的节点
     */
    static final class Node {
        /** 线程被取消了 */
        static final int CANCELLED = 1;
        /** 
         * 如果前驱节点的等待状态是SIGNAL,表示当前节点将来可以被唤醒,那么当前节点就可以安全的挂起了 
         * 否则,当前节点不能挂起 
         */
        static final int SIGNAL = -1;
        /**线程正在等待条件*/
        static final int CONDITION = -2;
        /**
         * waitStatus value to indicate the next acquireShared should
         * unconditionally propagate
         */
        static final int PROPAGATE = -3;
        /** Marker to indicate a node is waiting in shared mode */
        static final Node SHARED = new Node();
        /** 一个标记:用于表明该节点正在独占锁模式下进行等待 */
        static final Node EXCLUSIVE = null;
        //值就是前四个int(CANCELLED/SIGNAL/CONDITION/PROPAGATE),再加一个0

        volatile int waitStatus;
        /**前驱节点*/
        volatile Node prev;

        /**后继节点*/
        volatile Node next;

        /**节点中的线程*/
        volatile Thread thread;

        /**
         * Link to next node waiting on condition, or the special value SHARED.
         * Because condition queues are accessed only when holding in exclusive
         * mode, we just need a simple linked queue to hold nodes while they are
         * waiting on conditions. They are then transferred to the queue to
         * re-acquire. And because conditions can only be exclusive, we save a
         * field by using special value to indicate shared mode.
         */
        Node nextWaiter;

        /**
         * Returns true if node is waiting in shared mode
         */
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        /**
         * 返回该节点前一个节点
         */
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        Node() { // Used to establish initial head or SHARED marker
        }

        Node(Thread thread, Node mode) { // 用于addWaiter中
            this.nextWaiter = mode;
            this.thread = thread;
        }

        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

复制代码

注意:这里我给出了Node类的完整版,其中部分属性与方法是在共享锁的模式下使用的,而我们这里的ReentrantLock是一个独占锁,只需关注其中的与独占锁相关的部分就好(具体有注释)

 

3.3、AbstractQueuedSynchronizer:acquire(int arg)方法中使用到的两个方法

3.3.1、NonfairSync:tryAcquire(int acquires)

 View Code

Syn:

 View Code

注意:这个方法就完成了"简化版的步骤"中的"A/B/B1"三步,如果上述的请求不能成功,就要执行下边的代码了,

下边的代码,用一句话介绍:请求失败后,将当前线程链入队尾并挂起,之后等待被唤醒。在你看下边的代码的时候心里默记着这句话。

3.3.2、AbstractQueuedSynchronizer:addWaiter(Node mode)

 View Code

AbstractQueuedSynchronizer:enq(final Node node)

 View Code

注意:这里就是一个完整的入队方法,具体逻辑看注释和ReentrantLock:lock()的注释部分的相关部分。

3.3.3、AbstractQueuedSynchronizer:acquireQueued(final Node node, int arg)

 View Code

AbstractQueuedSynchronizer:shouldParkAfterFailedAcquire(Node pred, Node node)

 View Code

AbstractQueuedSynchronizer:

 View Code

 

以上就是一个线程获取非公平锁的整个过程(lock())。

 

4、公平锁的lock()

具体用法与非公平锁一样

如果掌握了非公平锁的流程,那么掌握公平锁的流程会非常简单,只有两点不同(最后会讲)。

 

简化版的步骤:(公平锁的核心)

获取一次锁数量,

B1、如果锁数量为0,如果当前线程是等待队列中的头节点,基于CAS尝试将state(锁数量)从0设置为1一次,如果设置成功,设置当前线程为独占锁的线程;

B2、如果锁数量不为0或者当前线程不是等待队列中的头节点或者上边的尝试又失败了,查看当前线程是不是已经是独占锁的线程了,如果是,则将当前的锁数量+1;如果不是,则将该线程封装在一个Node内,并加入到等待队列中去。等待被其前一个线程节点唤醒。

 

源代码:

4.1、ReentrantLock:lock()

 View Code

4.2、FairSync:lock()

 View Code

4.3、AbstractQueuedSynchronizer:acquire(int arg)就是非公平锁使用的那个方法

4.3.1、FairSync:tryAcquire(int acquires)

 View Code

最后,如果请求失败后,将当前线程链入队尾并挂起,之后等待被唤醒,下边的代码与非公平锁一样。

 

总结:公平锁与非公平锁对比

  • FairSync:lock()少了插队部分(即少了CAS尝试将state从0设为1,进而获得锁的过程)
  • FairSync:tryAcquire(int acquires)多了需要判断当前线程是否在等待队列首部的逻辑(实际上就是少了再次插队的过程,但是CAS获取还是有的)。

最后说一句,

  • ReentrantLock是基于AbstractQueuedSynchronizer实现的,AbstractQueuedSynchronizer可以实现独占锁也可以实现共享锁,ReentrantLock只是使用了其中的独占锁模式
  • 这一块儿代码比较多,逻辑比较复杂,最好在阅读的过程中,可以拿一根笔画画入队等与数据结构相关的图
  • 一定要记住"简化版的步骤",这是整个非公平锁与公平锁的核心

本文转载自:

粉丝 8
博文 23
码字总数 17514
作品 0
深圳
私信 提问
Java核心(三)并发中的线程同步与锁

乐观锁、悲观锁、公平锁、自旋锁、偏向锁、轻量级锁、重量级锁、锁膨胀...难理解?不存的!来,话不多说,带你飙车。 上一篇介绍了线程池的使用,在享受线程池带给我们的性能优势之外,似乎也...

王磊的博客
2018/11/22
140
0
Lock和Condition(可重入锁)

Lock有别于synchronized隐式锁的三个特征:能够响应中断。支持超时和非阻塞地获取锁,也就是说lock比synchronized的功能丰富。 JavaSDK并发包通过Lock和Condition两个接 口来实现管程,其中L...

刘一草
09/23
16
0
JDK基础--Java中的锁概念

Java中的锁概念 掌握Java中锁是Java多线程编程中绕不开的知识,只有知道理解Java各种锁才能在编码过程中灵活运用,写出更高效的多线程程序。而理解掌握锁的第一步,可从宏观上对比理解一下各...

spinachgit
04/16
27
0
Java核心-并发中的线程同步与锁

一、线程安全问题的产生 线程安全问题:指的是在多线程编程中,同时操作同一个可变的资源之后,造成的实际结果与预期结果不一致的问题。 比如:A和B同时向C转账10万元。如果转账操作不具有原...

小刀爱编程
2018/11/23
23
0
Java中的公平锁和非公平锁实现详解

前言 ReentrantLock的可重入性分析 synchronized的可重入性 ReentrantLock的可重入性 ReentrantLock锁的实现分析 公平锁和非公平锁 公平锁FairSync 非公平锁NonfairSync ReentrantLock锁的释...

kim_o
2018/06/08
66
0

没有更多内容

加载失败,请刷新页面

加载更多

[top]cpu内存

%Cpu(s): 96.0 us用户进程整理cpu的占比,按整个cpu算。 PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND ......

Danni3
17分钟前
3
0
JavaScript权威指南笔记2

第二章、词法结构 1、字符集 JavaScript程序:Unicode字符集编写 Unicode:ASCII和Latin-1的超集,支持所有在用的语言。 ECMAScript 3要求JavaScript的实现必须支持Unicode 2.1及后续版本 EC...

_Somuns
24分钟前
4
0
数据安全管理:RSA算法,签名验签流程详解

本文源码:GitHub·点这里 || GitEE·点这里 一、RSA算法简介 1、加密解密 RSA加密是一种非对称加密,在公开密钥加密和电子商业中RSA被广泛使用。可以在不直接传递密钥的情况下,完成加解密操...

知了一笑
今天
7
0
Podman 使用指南

> 原文链接:Podman 使用指南 Podman 原来是 CRI-O 项目的一部分,后来被分离成一个单独的项目叫 libpod。Podman 的使用体验和 Docker 类似,不同的是 Podman 没有 daemon。以前使用 Docker...

米开朗基杨
今天
6
0
拯救 项目经理个人时间的5个技巧

优秀的项目经理都有一个共同点,那就是良好的时间管理能力。专业的项目经理会确保他们的时间投入富有成效,尽可能避免时间浪费。 时间管理叫做GTD,即Getting Things Done——“把事情做完”...

Airship
今天
7
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部