线程同步-ReentrantLock&AQS

已于 2023-06-25 12:43:19 修改
阅读量181 收藏
点赞数 1
文章标签： java jvm 开发语言
于 2023-06-23 17:07:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55626853/article/details/131352241
版权

一、JAVA并发概述

  JAVA开发中常见的并发问题有线程同步、线程协作、线程分工等。JUI包（java.util.concurrent）中提供了多种API和工具类来解决各种并发问题。这几类并发问题往往不是独立存在的，开发者可根据实际问题决定采用哪种方式。本文主要介绍线程同步中的Lock&AQS原理。

  线程同步是指：当有一个线程在对临界资源进行操作时，其他线程都不可以操作该临界资源，直到该线程完成操作，其他线程才能继续操作。实现线程同步的方法有：加锁和无锁。

加锁无锁
含义当一个线程访问临界资源时，会对临界资源加锁，当其他线程访问时会被阻塞。
（实际实现中考虑到效率等原因，一般不会立即阻塞，而是先进行自旋等操作）		当一个线程访问临界资源时，如果该资源正在被其他线程访问，则该线程会访问失败并返回false或者自旋直至成功。
实现方式synchronized、LockCAS、Atomic原子类等

  如上所示，JAVA开发中常用的加锁方式有两种：synchronized关键字、Lock。

// Lock接口中定义了加锁/释放锁的方法;
// Lock的实现类有ReentrantLock、ReentrantReadWriteLock.ReadLock、ReentrantReadWriteLock.WriteLock等
public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

  下面继续介绍synchronized、Lock加锁的用法。

二、ReentrantLock

2.1 基本用法

  ReentrantLock实现了Lock接口。ReentrantLock即可重入锁，指一个线程（已经获得锁）可以对临界资源重复加锁。对比synchronized的使用，ReentrantLock使用方式如下：

// 1.synchronized使用方式
public synchronized void testLock1() {
    doSomething();
}

// 2.ReentrantLock使用方式
public void testLock2() {
    ReentrantLock lock = new ReentrantLock();
    lock.lock();
    try {
        doSomething();
    } finally {
        lock.unlock();
    }
}

  可以看到，相比synchronized方式，ReentrantLock在加锁和释放锁时都需要在代码中显式调用，而synchronized方式会在方法执行前自动加锁，方法执行结束后自动释放锁。ReentrantLock的优点在于ReentrantLock提供了多种获取锁的方式（尝试获取锁、超时获取锁、可中断锁等）、支持公平锁/非公平锁、可结合Condition关联多个条件队列。

ReentrantLocksynchronized
使用方式需要手动加锁/释放锁使用结束后自动释放锁
锁类型支持公平锁/非公平锁非公平锁
获取锁方式提供了多种获取锁的方式
1.尝试获取锁：获取锁失败时会立即返回false；
2.超时获取锁：获取锁时可设置超时时间
3.响应中断：线程可以在被阻塞时响应中断		获取锁失败时会阻塞当前线程，直到获取锁成功
条件队列可创建多个Condition实现关联多个条件队列。
通过Condition.await()、Condition.signal()实现。		只有一个条件队列。
通过Object.wait()、Object.notify()实现。
锁实现机制依赖AQS依赖Monitor机制(每一个Java对象都有一把看不见的锁)；
锁升级机制；
Monitor依赖于底层操作系统的Mutex Lock（互斥锁）来实现线程同步；

2.2 ReentrantLock源码分析

  下面从ReentrantLock的构造函数，以及ReentrantLock.lock()方法来分析加锁过程。如下所示，创建ReentrantLock对象时支持公平锁/非公平锁（默认采用非公平锁），ReentrantLock.lock()的实现依赖其内部类ReentrantLock.Sync：

public class ReentrantLock implements Lock {

    private final Sync sync;

    public ReentrantLock() { 
        // 默认是非公平锁
        sync = new NonfairSync(); 
    }

    public ReentrantLock(boolean fair) {
        // 支持公平锁/非公平锁
        sync = fair ? new FairSync() : new NonfairSync();
    }

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

2.3 非公平锁&公平锁

  内部类ReentrantLock.Sync有两个子类：NonfairSync、FairSync，对应着非公平锁、公平锁。二者的区别在于：获取锁的顺序是否公平，是否与请求获取锁的顺序一样。分两种情况讨论：

  1. 情况1：当新的节点请求获取锁时，锁正在被持有，非公平锁与公平锁都会把新节点放到等待队列；
  2. 情况2：当新的节点请求获取锁时，锁刚好被释放，非公平锁会先尝试获取锁，获取失败才会进入等待队列。

流程图-202306212013.png

  从源码上看，非公平锁NonfairSync和公平锁FairSync的代码区别主要在于：

  1. 在加锁方法lock()中，非公平锁NonfairSync会先尝试CAS更新state状态值，更新成功则直接获得锁；
  2. 在尝试获取锁方法tryAcquire()中，非公平锁NonfairSync会再次先尝试CAS更新state状态值，更新成功则直接获得锁；而公平锁FairSync会多一个hasQueuedPredecessors()判断，判断是否有其他线程等候了更长时间。
public class ReentrantLock implements Lock {
    /**
     * 非公平锁
     */
    static final class NonfairSync extends Sync {

        /**
         * 获取锁
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

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

        /**
         * 尝试获取锁;
         * 源码中nonfairTryAcquire()在其父类中ReentrantLock.Sync,为方便对比放到这里
         */
        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;
        }
    }

    /**
     * 公平锁
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

        /**
         * 尝试获取锁
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                // 相比非公平锁,这里多了一个判断：hasQueuedPredecessors()
                // hasQueuedPredecessors()：判断等待获取锁的队列中,是否有其它等待时间更长的线程
                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;
        }
    }
}

2.4 ReentrantLock.Sync

  上面提到的非公平锁NonfairSync、公平锁FairSync，都是ReentrantLock.Sync的子类。

public class ReentrantLock implements Lock {

    abstract static class Sync extends AbstractQueuedSynchronizer {

        abstract void lock();

        /**
         * 尝试释放锁
         */
        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;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }
    }
}

  可以看到，ReentrantLock.Sync、ReentrantLock.NonfairSync、ReentrantLock.FairSync只是实现了加锁/释放锁的主体逻辑，而具体的工作如修改同步状态、等待队列、线程阻塞都是在其父类AbstractQueuedSynchronizer中实现的。即AbstractQueuedSynchronizer提供了一个同步框架，其子类在这套同步框架的基础上实现锁功能。

2.5 总结

  综合上面的分析，AQS提供了一个基础的同步框架，ReentrantLock在AQS的基础上实现了加锁/解锁的功能。ReentrantLock、ReentrantLock.NonfairSync、ReentrantLock.FairSync、AQS的关系如下：
流程图-202306212011.png

三、AQS源码分析

3.1 AQS基本结构

  AQS即AbstractQueuedSynchronizer，AQS提供了一个基于FIFO等待队列的同步框架。AQS的子类在这套框架基础上实现AQS的几个protect方法来实现同步锁，例如ReentrantLock.Sync、ReentrantReadWriteLock.Sync、CountDownLatch.Sync、Semaphore.Sync等。

  AQS使用volatile int类型的state表示同步状态，用CAS修改state值，用FIFO队列管理获取临界资源的线程。如下所示AQS的FIFO队列持有head节点和tail节点：

public abstract class AbstractQueuedSynchronizer {
    /** 队列头节点 */
    private transient volatile Node head;
    /** 队列尾节点 */
    private transient volatile Node tail;
    /** 同步状态 */
    private volatile int state;
    private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();

    /**
     * CAS设置state;用于尝试获取锁/尝试释放锁操作
     */
    protected final boolean compareAndSetState(int expect, int update) {
        return U.compareAndSwapInt(this, STATE, expect, update);
    }
}

3.2 Node定义

  其中，Node是把单个线程封装成的AQS内部类，每个Node持有前后节点的引用：

public abstract class AbstractQueuedSynchronizer {
    static final class Node {
        /**
         * 当前节点的状态,包括SIGNAL 、CANCELLED 、CONDITION、PROPAGATE、0
         */
        volatile int waitStatus;
        /** 前一个节点 */
        volatile Node prev;
        /** 下一个节点 */
        volatile Node next;
        /** 指向的线程 */
        volatile Thread thread;
        /** Condition下的下一个节点;或SHARED节点 */
        Node nextWaiter;
        private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();

        /**
         * CAS设置当前节点状态
         */
        final boolean compareAndSetWaitStatus(int expect, int update) {
            return U.compareAndSwapInt(this, WAITSTATUS, expect, update);
        }

        /**
         * CAS设置下一个节点
         */
        final boolean compareAndSetNext(Node expect, Node update) {
            return U.compareAndSwapObject(this, NEXT, expect, update);
        }
    }
}

3.3 lock获取锁过程

  以为非公平锁为例分析ReentrantLock.lock()获取锁流程源码：

public class ReentrantLock implements Lock {
    /**
     * 非公平锁
     */
    static final class NonfairSync extends Sync {

        /**
         * 获取锁
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                // 1.尝试CAS设置state值,设置成功,则获取锁
                setExclusiveOwnerThread(Thread.currentThread());
            else
                // 2.CAS设置失败,则执行acquire()进入获取锁流程
                acquire(1);
        }

        /**
         * 尝试获取锁;
         */
        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) {
                // 同上,这个时候有可能其他线程已经释放了锁,所以再次尝试CAS获取锁
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            } else if (current == getExclusiveOwnerThread()) {
                // 当前线程已经是获取锁的线程,则更新state的值,获取锁成功,即可重入锁
                int nextc = c + acquires;
                setState(nextc);
                return true;
            }
            return false;
        }
    }
}

/**
 * 基于FIFO等待队列的同步框架
 */
public abstract class AbstractQueuedSynchronizer {

    /**
     * 获取锁
     */
    public final void acquire(int arg) {
        // 1.tryAcquire()尝试获取锁;获取成功则返回;
        // 2.如果获取失败,则执行addWaiter()创建Node节点(引用着当前线程)并加入同步队列
        // 3.加入同步队列后,会执行acquireQueued()再次尝试获取锁(因为这时其他线程可能已经释放锁)
        // 4.仍然获取失败,则调用LockSupport.park(this)阻塞当前线程;
        if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            // 如果阻塞的过程被中断(超时或者其他原因),则会执行interrupt()
            selfInterrupt();
    }

    /**
     * 把Node节点添加到同步队列
     */
    private Node addWaiter(Node mode) {
        Node node = new Node(mode);
        for (;;) {
            Node oldTail = tail;
            if (oldTail != null) {
                // 1.用Unsafe把当前节点的前一个节点设置为同步队列的尾节点
                U.putObject(node, Node.PREV, oldTail);
                // 2.用Unsafe更新同步队列的尾节点为当前节点
                if (compareAndSetTail(oldTail, node)) {
                    // 3.旧尾节点的next节点更新为当前节点
                    oldTail.next = node;
                    return node;
                }
            } else {
                // 初始化同步队列,即用Unsafe设置队列HEAD值;
                // HEAD节点是空节点,创建完HEAD节点后继续for循环把当前节点添加到队列
                initializeSyncQueue();
            }
        }
    }

    /**
     * 已经在队列中的节点获取锁
     */
    final boolean acquireQueued(final Node node, int arg) {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            // 如果当前节点的前节点即HEAD节点(HEAD是空节点),说明该节点是同步队列第一个节点,则再次尝试获取锁
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null;
                return interrupted;
            }
            // 获取失败后判断是否阻塞线程,如果是则继续执行parkAndCheckInterrupt()
            if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                interrupted = true;
        }
    }

    /**
     * 阻塞当前线程
     */
    private final boolean parkAndCheckInterrupt() {
        // 阻塞线程
        LockSupport.park(this);
        // 当线程恢复执行后,返回是否中断线程
        return Thread.interrupted();
    }
}

3.4 unlock释放锁过程

  下面分析ReentrantLock.unlock()释放锁的流程源码：

public class ReentrantLock implements Lock {

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

    abstract static class Sync extends AbstractQueuedSynchronizer {

        /**
         * 释放锁
         */
        protected final boolean tryRelease(int releases) {
            // 1.计算释放锁后的state值（state值即同步状态）
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                // 2.如果值为0,则设置持有锁的线程为null
                setExclusiveOwnerThread(null);
            }
            // 3.更新state值
            setState(c);
            return free;
        }
    }
}

/**
 * 基于FIFO等待队列的同步框架
 */
public abstract class AbstractQueuedSynchronizer {

    /**
     * 释放锁
     */
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                // 释放锁后,唤醒等待线程
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

    /**
     * 释放锁后,唤醒等待线程
     */
    private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        if (ws < 0)
            node.compareAndSetWaitStatus(ws, 0);
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node p = tail; p != node && p != null; p = p.prev)
                if (p.waitStatus <= 0)
                    s = p;
        }
        if (s != null)
            // 唤醒线程
            LockSupport.unpark(s.thread);
    }
}

3.5 总结

  AQS提供了基于FIFO等待队列的同步框架，包括同步状态state、同步队列、线程阻塞、互斥锁/共享锁等基础功能。ReentrantLock在AQS同步框架的基础上，实现了获取锁/释放锁的具体逻辑（例如非公平锁/公平锁的获取锁流程等）；ReentrantReadWriteLock在AQS同步框架的互斥锁/共享锁基础上，实现了读写锁的功能（写锁WriteLock是互斥锁，而读锁ReadLock是共享锁）。开发者也可以在AQS的基础上自定义其他锁实现。
流程图-202306231622.png

The End

欢迎关注我，一起解锁更多技能：BC的掘金主页～💐 BC的CSDN主页～💐💐
请添加图片描述

JVM结构官方文档：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html#jvms-2.5.3

英文参考文档：http://tutorials.jenkov.com/java-concurrency/index.html

concurrent工具包参考文档：http://tutorials.jenkov.com/java-util-concurrent/index.html

锁类型：https://tech.meituan.com/2018/11/15/java-lock.html

AQS：https://tech.meituan.com/2019/12/05/aqs-theory-and-apply.html

JAVA并发参考文档：http://concurrent.redspider.group/article/01/1.html

线程池参考文档：https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html

BC时间
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 多线程与并发(11-26)-JUC锁- ReentrantLock详解.pdf
07-26
在深入ReentrantLock之前，我们首先需要了解Java并发编程的基础，特别是Java内存模型和线程同步机制。 **可重入锁与可重入性** 可重入锁允许同一个线程反复进入它已经拥有的锁所保护的代码段。在Java中，...
详解java并发之重入锁-ReentrantLock
08-26
ReentrantLock 的锁机制是基于 AQS（Abstract Queued Synchronizer）的，AQS 是 Java 中的一个同步器框架。ReentrantLock 使用了 AQS 来实现锁机制。 ReentrantLock 的锁机制可以分为两部分：公平锁和非公平锁。 1...
深入理解ReentrantLock
乐嘉工作室
01-26 854
深入理解ReentrantLock
AQS源码分析-ReentrantLock&Semaphore
weixin_36114346的博客
06-21 124
juc包中的大多数同步器实现都是围绕着共同的基础行为，比如等待队 列、条件队列、独占获取、共享获取等，而这些行为的抽象就是基于 AbstractQueuedSynchronizer（简称AQS）实现的，AQS是一个抽象同步框架，可以用来实现一个依赖状态的同步器。 两种资源共享方式 Exclusive-独占，只有一个线程能执行，如ReentrantLock Share-共享，多个线程可以同时执行，如Semaphore/CountDownLatch 两种队列 同步等待队列： 双向链表，主要用于维护获取锁失
线程安全-4 AQS&Lock&ReentrantLock
m0_73249076的博客
05-27 599
对AQS、Lock、ReentrantLock相关问题的概述。
Java核心05-AQS&ReentrantLock&Synchronized等锁原理
xiaohoulove_的博客
09-27 50
AQS的核心思想是，如果被请求的共享资源是空闲，则将当前请求资源的线程设置为有效的工作线程(exclusiveOwnerThread)，并且将共享资源设置为锁定状态。AQS 使用state 同步状态字段(0代表无锁，1代表有锁)，并暴露出 getState、setState 以及 compareAndSet 操作来读取和更新这个状态，使得仅当同步状态拥有一个期望值时，才会被原子地设置成新值。公平锁，多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，synchronized 锁是非公平锁。
JUC相关连载三---AQS同步队列&ReentrantLock&ReentrantReadWriterlock(Java劝退师)
weixin_37971826的博客
06-06 134
由于隐式锁在竞争非常激烈的环境中的性能表现不是非常好，Lea 基于AQS提供了显式锁.主要目的就是提高竞争激烈时的效率问题。当然ReentrantLock还有其他
JUC学习笔记- ReentrantLock 和 AQS
weixin_37717746的博客
06-22 199
AQS : 抽象队列同步器，其核心属性，锁的状态state，（FIFO）双向队列和CAS操作。AQS定义了2种资源共享的方式，EXCLUSIVE（独占，即只有一个线程能获取到该资源，比如ReentrantLock），SHARED（共享，多个线程可以共享该资源，Semephore/CountDownLatch），当然也可以兼而有之，比如ReentrantReadWriteLock队列模型：公平锁：先看入队队列，如果有等待的队列，就是先来先得，排队过程中，先进入队列的先获得锁 （前面释放锁，会唤醒后面的在队列等
JavaSE-多线程（13）- ReentrantLock，AQS源码
sql2008help的博客
04-18 283
JavaSE-多线程（13）- ReentrantLock，AQS源码 以如下实例讲解，有两个线程 t1 ，t2 ，它们同时访问 ReentrantLock5 对象的 run 方法，run 方法中打印当前正在执行的线程名，在run方法开始时对 Lock 对象加锁，访问完后释放锁： import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Reentran
08：java基础-锁之AQS&ReentrantLock&BlockingQueue&CountDownLatch&Semapho
weixin_43761434的博客
03-07 874
Exclusive-独占，只有一个线程能执行，如ReentrantLockShare-共享，多个线程可以同时执行，Semaphore/CountDownLatch同步等待队列条件等待队列不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。该线程是否正在独占资源。只有用到condition才需要去实现它独占方式。
Java-ReentrantLock-AQS-原理-应用-美团技术团队
Java程序员的知识博客
01-17 934
Java中的大部分同步类（Lock、Semaphore、ReentrantLock等）都是基于AbstractQueuedSynchronizer（简称为AQS）实现的。AQS是一种提供了原子式管理同步状态、阻塞和唤醒线程功能以及队列模型的简单框架。本文会从应用层逐渐深入到原理层，并通过ReentrantLock的基本特性和ReentrantLock与AQS的关联，来深入解读AQS相关独占锁的知识点，同时采取问答的模式来帮助大家理解AQS。
aqs_demo.rar
03-17
总的来说，AQS同步器和Redisson锁是Java并发编程中不可或缺的工具，它们提供了高效且灵活的线程同步机制，使得开发者能够更好地应对高并发场景，实现稳定、高效的分布式系统。掌握这些技术，对于提升Java开发者的...
深入分析AQS原理-王雷-v1.pptx
08-11
AQS主要用于构建锁和其他同步组件，如ReentrantLock、CountDownLatch等。它提供了一种基于FIFO队列的同步控制机制，支持独占和共享两种模式。 独占锁，也叫排他锁，只允许一个线程持有，如ReentrantLock就是一个...
ReentrantLock实现原理详解
08-31
- **基础知识**：ReentrantLock的lock()和unlock()方法依赖于AQS的同步机制。可重入性和可中断性是其关键特性。 - **NonfairSync**：ReentrantLock默认实现是非公平的，即lock()方法可能不按线程到达的顺序分配锁...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 515
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 326
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
ShardingSphere
最新发布
Casual_Lei的博客
07-04 639
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
如何使用缓存提升SpringBoot性能（EhCache和Redis方式）
三两肉的博客
07-03 1036
缓存是指将文件或数据的副本存储在缓存或临时存储位置中，以便未来对该数据的请求可以更快地提供服务。当从存储中检索数据时，会在缓存中创建该数据的副本。如果再次需要该数据，可以从缓存中比从主存储器中更快地检索到该数据，主存储器可能涉及复杂的计算或较慢的访问速度。如何使用缓存提升SpringBoot性能（EhCache和Redis方式）
ReentrantLock aqs
08-08
ReentrantLock中的AQS指的是AbstractQueuedSynchronizer，是ReentrantLock的核心部件之一。在ReentrantLock的内部，包含了一个AQS对象（内部类），AQS实现了获取锁和释放锁的机制。通过调用AQS提供的方法，ReentrantLock能够实现线程的同步和互斥。AQS使用一种基于队列的算法来管理等待获取锁的线程。当一个线程尝试获取锁时，如果锁已经被其他线程占用，那么该线程就会被放入等待队列中，直到锁被释放为止。而当锁被释放时，AQS会从等待队列中选择一个线程来获得锁的所有权。这种机制保证了线程的有序访问和互斥。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值