面试题：Java锁机制

兜兜转转m

已于 2023-02-12 13:14:19 修改

阅读量1.6k

点赞数 1

分类专栏：面试题 Java并发文章标签： java 面试经验分享 Powered by 金山文档

于 2023-02-11 19:21:11 首次发布

本文链接：https://blog.csdn.net/abc123mma/article/details/128985557

版权

面试题同时被 2 个专栏收录

16 篇文章 1 订阅

订阅专栏

Java并发

16 篇文章 0 订阅

订阅专栏

1 锁编程

java对象包含了三个部分：对象头，实例数据和对齐填充。

对象头又存放了：markWord和class point。

classpoint ：指向方法区，当前对象的类信息数据。

markword：存储了很多和当前对象运行时的数据：例如hashcode，锁状态标志，指向锁记录的指针。

锁标志位：主要用来区分锁的等级，无锁->偏向锁->轻量级锁->重量级锁；

synchronized的实现原理？

synchronized被编译后会成才monitorenter和monitorexit两个字节码指令，分别表示加锁和释放锁。

monitorenter和monitorexit都是基于Monitor实现的。所谓的Monitor其实是一种同步工具，也可以说是一种同步机制。在Java虚拟机（HotSpot）中，Monitor是由ObjectMonitor实现的，可以叫做内部锁，或者Monitor锁。

ObjectMonitor的信息如下：

ObjectMonitor() {
    _header       = NULL;
    _count        = 0; // 记录线程获取锁的次数
    _waiters      = 0,
    _recursions   = 0;  //锁的重入次数
    _object       = NULL;
    _owner        = NULL;  // 指向持有ObjectMonitor对象的线程
    _WaitSet      = NULL;  // 处于wait状态的线程，会被加入到_WaitSet
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ;  // 处于等待锁block状态的线程，会被加入到该列表
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
  }

synchronized的重量级锁讲解：

通过上文已知，monitor由Entry Set 和 Wait Set 两个等待区。

Entry Set：存放已经准备抢锁的线程。

Wait Set：存放执行wait等指令的线程。

当某一个线程抢到锁，那么Owner就会指向改线程。改线程可以调用notify方法，随机唤醒一个线程进入Entry Set 区准备抢锁。

java1.6之后，synchronized有4种状态，无锁，偏向锁，轻量级锁和重量级锁。

无锁：不对资源放入synchronized代码块中。

偏向锁：对资源进行加锁，但是实际运行中只有一个线程获得这个锁。此时锁标志位还是01跟无锁是一样的。仅仅修改是否偏向锁的标志位，从0改到1.

当存在多个线程来获取这个锁时。偏向锁会升级为轻量级锁。但是又一个问题来了？当锁升级为轻量级时如何判断线程和锁之间的绑定关系呢？

轻量级锁和重量级锁都将前30bit修改为指向栈中记录锁的指针。此时这个指针会指向虚拟机栈中开辟的lockRecord，lockRecord存放的是MarkWord的副本和owner指针。

线程通过CAS尝试获取锁，一旦获取成功，将复制该对象的markword到自己的lockRecord，并修改owner指针，指向该对象。从而实现了线程和锁之间的绑定。

轻量级锁是多个线程在不同时间访问共享资源。

如果多个线程在同一时刻抢夺锁时，便会升级为重量级锁，就需要用到monitor机制，即如上文所述完全由jvm控制。

2 无锁编程

无锁编程采用CAS(compare and swap)机制，也就是乐观锁，其关键在于cas是原子性操作。

乐观锁适合读多写少的情况，以下代码采用cas实现多线程累加。

public class ThreadAtomicInte {
    static AtomicInteger integer = new AtomicInteger(0);
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                while (integer.get() <= 1000) {
                    System.out.println("thread name" + Thread.currentThread().getName() + ": " + integer.getAndIncrement());
                }
            }).start();
        }
    }

3 AQS

AbstractQueuedSynchronizer 抽象队列同步器，简称 AQS

AQS是基于一个FIFO的双向链表队列，其内部定义了一个节点类Node，Node 节点内部的 SHARED 用来标记该线程是获取共享资源时被阻挂起后放入AQS 队列的， EXCLUSIVE 用来标记线程是取独占资源时被挂起后放入AQS 队列。

AQS 使用一个 volatile 修饰的 int 类型的成员变量 state 来表示同步状态，修改同步状态成功即为获得锁，volatile 保证了变量在多线程之间的可见性，修改 State 值时通过 CAS 机制来保证修改的原子性。

获取state的方式分为两种，独占方式和共享方式，一个线程使用独占方式获取了资源，其它线程就会在获取失败后被阻塞。一个线程使用共享方式获取了资源，另外一个线程还可以通过CAS的方式进行获取。

如果共享资源被占用，需要一定的阻塞等待唤醒机制来保证锁的分配，AQS 中会将竞争共享资源失败的线程添加到一个变体的队列中。

static final class Node {
        /** 共享节点 */
        static final Node SHARED = new Node();
        /** 独占节点 */
        static final Node EXCLUSIVE = null;

        /** 超时或者中断，该节点会被设置为取消，被取消的节点不会参与竞争 */
        static final int CANCELLED =  1;
        /** 标志这个这节点的后置节点处于等待状态，如果这个节点是否同步状态，或者被取消会通知后置节点 */
        static final int SIGNAL    = -1;
        /**  */
        static final int CONDITION = -2;
        /**
         * 
         * 
         */
        static final int PROPAGATE = -3;

        volatile int waitStatus;

        // 前序节点
        volatile Node prev;

        // 后继节点
        volatile Node next;

        /**
         * 
         * 获取同步状态的线程
         */
        volatile Thread thread;

FIFO的结构图：

head指向第一个节点。

tail指向最后一个节点。

state：大于0表示持有锁，等于0表示未持有锁。

3.1独占式同步状态过程

通过调用acquire方法，acquire包含tryAcquire、acquireQueued、addWaiter和selfInterrupt方法。

 public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

tryAcquire

尝试获取锁，获取成功返回true，否则返回false。该方法由继承AQS的子类进行实现。如ReentrantLock的内部类Sync的子类。NonfairSync 和FairSync

protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

NonfairSync的实现为

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) {
                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;
        }

addWaiter

private Node addWaiter(Node mode) {
        // 1. 新建Node节点
        Node node = new Node(Thread.currentThread(), mode);
        // 2 快速加入队列尾部
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            // 采用cas方式 设置尾部节点
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        // 如果上面失败，采取自旋方式设置尾节点。
        enq(node);
        // 返回新插入的尾部节点。
        return node;
    }



private Node 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;
                }
            }
        }
    }

acquireQueued

final boolean acquireQueued(final Node node, int arg) {
        // 操作是否失败的标记
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                //获取node节点的prev节点。
                final Node p = node.predecessor();
                // 如果p是头结点。
                if (p == head && tryAcquire(arg)) {
                    // 将当前节点设置为头节点。
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                // 自旋过程中，判断当前线程是否需要阻塞  && 阻塞当前线程并且检验线程的中断状态
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

// shouldParkAfterFailedAcquire方法
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        // 1. 获取当前节点的prev节点的等待状态
        int ws = pred.waitStatus;
    
        // 如果状态为signal表示需要去唤醒他的后继节点
        if (ws == Node.SIGNAL)
            /*
             * 如果pre节点是signal，表示当前pre释放了同步状态或者取消了
             * 会去唤醒当前节点，当前节点可以被阻塞或者睡觉
             */
            return true;
        if (ws > 0) {
            /*
             * 说明pre节点是被取消了，从队列中移除。
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * 除了以上情况，通过cas将pre状态设置为signal.
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

// parkAndCheckInterrupt方法
private final boolean parkAndCheckInterrupt() {
        // 阻塞当前线程。
        LockSupport.park(this);
        // 返回当前线程的中断状态。
        return Thread.interrupted();
    }

selfInterrupt

static void selfInterrupt() {
        // 未获取到中断状态  && 线程中断状态为true， 中断当前线程
        Thread.currentThread().interrupt();
    }

4 ReentrantLock

ReentrantLock实现了Lock接口内部定义抽象同步器Sync，其继承了AQS，并且内部有公平锁和非公平锁的实现类。

我们经常调用ReentrantLock无参构造器，那么我们以非公平锁NonfairSync为例进行讲解。

public ReentrantLock() {
        // 定义 同步器的实现类为非公平
        sync = new NonfairSync();
    }

NonfairSync的加锁方法：

final void lock() {
     // 修改aqs中的state属性 从0-->1       
    if (compareAndSetState(0, 1))
        // 设置当前线程占有这把锁。
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // 没修改成功则进入AQS的获取锁的方法。
        acquire(1);
 }

假设现在没有竞争，我们进入if判断：设置state = 1 并且exclusiveOwnerThread属性设置为自己。

第一个竞争出现时，还会执行lock方法，但是会进入else里面。

调用acquire方法，这个方法在aqs中定义的。

Thread-1 执行了

1.CAS 尝试将 state 由0改为 1，结果失败

2.进入tryAcquire 逻辑，这时state 已经是1，结果仍然失败

3.接下来进入addWaiter 逻辑，构造Node 队列

图中黄色三角表示该Node的waitStatus 状态，其中0为默认正常状态

Node 的创建是懒惰的

其中第一个Node称为 Dummy(哑元)或哨兵，用来占位，并不关联线程

当前线程进入acquireQueued逻辑

1. acquireQueued会在一个死循环中不断尝试获得锁，失败后进入park 阻塞

2. 如果自己是紧邻着head(排第二位)，那么再次tyAcquire 尝试获取锁，当然这时state仍为1，失败

3. 进入 shouldParkAfterFailedAcquire 逻辑，将前驱node，即 head 的 waitStatus改为-1，这次返回 false。改为-1表示，当前节点有责任唤醒它的后继节点。

4. shouldParkAfterFailedAcquire 执行完毕回到 acquireQueued，再次 tyAcquire尝试获取锁，当然这时state 仍为 1，失败

5. 当再次进入shouldParkAfterFailedAcquire 时，这时因为其前驱 node的5.waitStatus 已经是-1，这次返回true

6. 进入parkAndCheckInterrupt， Thread-1 park (灰色表示)

当有多个线程经历上述竞争失败。

Thread-0 释放锁，进入tryRelease 流程，如果成功

设置exclusiveOwnerThread为 null

state = 0

public final boolean release(int arg) {
    // 首先调用tryRelsease
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            // 然后唤醒下一个节点。
            unparkSuccessor(h);
        return true;
    }
    return false;
}

//tryRelsease 逻辑
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        // owner 设置为null
        setExclusiveOwnerThread(null);
    }
    // state - 1；
    setState(c);
    return free;
}

private void unparkSuccessor(Node node) {
    // 获取头结点的状态为 -1
    int ws = node.waitStatus;
    if (ws < 0)
        // 设置状态为0
        compareAndSetWaitStatus(node, ws, 0);
    // 获取后继节点
    Node s = node.next;
    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)
        // 调用unpark，唤醒后继节点
        LockSupport.unpark(s.thread);
}

当Thread-0释放锁之后，会唤醒Thread-1来尝试获取锁。那这不就是公平了吗？顺序获取锁，是的在队列中的线程是公平的。但是在Thread-0释放锁的同时敲好有其他线程来竞争锁，那么Thread-1可能就获取不到锁，这就是非公平的体现！！

可重入的体现

final boolean nonfairTryAcquire(int acquires) {
  //acquires = 1
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 已经获取锁 判断当前线程是否是owner，开始锁重入
    else if (current == getExclusiveOwnerThread()) {
        // state ++;
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

// 释放锁
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 释放锁要判断 state 是否 = 0；
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    // 返回false 表示没有释放成功，true表示释放成功
    return free;
}