AQS简介及其常见实现

原创 已于 2025-05-11 18:08:17 修改 · 403 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

于 2022-03-29 21:28:43 首次发布
本文深入探讨了Java中ReentrantLock的使用方式及其实现原理，包括条件变量的应用、与synchronized的区别，同时还介绍了Semaphore、CountDownLatch及CyclicBarrier等并发工具类的功能与应用场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

JAVA层面如何实现管程模型？ synchronized、AQS两种实现

AQS

是什么

AQS 是一个抽象类AbstractQueuedSynchronizer，为同步器提供了通用的 执行框架。它定义了 资源获取和释放的通用流程，而具体的资源获取逻辑则由具体同步器通过重写模板方法来实现。 因此，可以将 AQS 看作是同步器的 基础“底座”，而同步器则是基于 AQS 实现的 具体“应用”。

例如 可重入锁（ReentrantLock）、信号量（Semaphore）和 倒计时器（CountDownLatch）。通过封装底层的线程同步机制，AQS 将复杂的线程管理逻辑隐藏起来，使开发者只需专注于具体的同步逻辑。

AQS是jdk并发包java.util.concurrent下绝大部分工具类实现的基础

AQS具备的特性：

  • 用 state 属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取 锁和释放锁
    • getState - 获取 state 状态
    • setState - 设置 state 状态
    • compareAndSetState - cas 机制设置 state 状态
    • 独占模式是只有一个线程能够访问资源独占锁，如 ReentrantLock，而共享模式可以允许多个线程访问资源，如Semaphore 和 CountDownLatch
  • 提供了基于 FIFO 的等待队列，类似于 Monitor 的 EntryList 条件变量来实现等待、唤醒机制，只不过是JAVA实现的
  • 支持多个条件变量

具体实现

ReentrantLock

  • 具备AQS具备的特性, 这里重点讲一下条件变量：
package com.test.jucdemo.lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

import lombok.extern.slf4j.Slf4j;

/**
 * @author 
 * 条件变量
 */
@Slf4j
public class ReentrantLockDemo6 {
    private static ReentrantLock lock = new ReentrantLock();
    private static Condition cigCon = lock.newCondition();
    private static Condition takeCon = lock.newCondition();

    private static boolean hashcig = false;
    private static boolean hastakeout = false;

    //送烟
    public void cigratee(){
        lock.lock();
        try {
            while(!hashcig){
                try {
                    log.debug("没有烟，歇一会");
                    // 前半段： 释放锁，进入条件队列，然后阻塞线程

                    //过渡阶段： 被其他调用singal/singalAll的线程唤醒 （前提：要在同步队列中）
                    // 调用singal/singalAll的线程:  条件队列转同步队列，
                    // 可以在释放锁的时候唤醒head的后续节点所在的线程

                    // 后半段： 获取锁（ 如果有竞争，cas获取锁失败，还会阻塞），
                    // 释放锁（唤醒同步队列中head的后续节点所在的线程）
                    // 后半段的逻辑其实就是独占锁的逻辑
                    cigCon.await();

                }catch (Exception e){
                    e.printStackTrace();
                }
            }
            log.debug("有烟了，干活");
        }finally {
            lock.unlock();
        }
    }

    //送外卖
    public void takeout(){
        lock.lock();
        try {
            while(!hastakeout){
                try {
                    log.debug("没有饭，歇一会");
                    takeCon.await();

                }catch (Exception e){
                    e.printStackTrace();
                }
            }
            log.debug("有饭了，干活");
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockDemo6 test = new ReentrantLockDemo6();
        new Thread(() ->{
            test.cigratee();
        }).start();

        new Thread(() -> {
            test.takeout();
        }).start();

        new Thread(() ->{
            lock.lock();
            try {
                hashcig = true;
                log.debug("唤醒送烟的等待线程");
                cigCon.signal();
            }finally {
                lock.unlock();
            }


        },"t1").start();

        new Thread(() ->{
            lock.lock();
            try {
                hastakeout = true;
                log.debug("唤醒送饭的等待线程");
                takeCon.signal();
            }finally {
                lock.unlock();
            }
        },"t2").start();
    }

}
  • 几点synchronized和ReentrantLock的区别：

synchronized是JVM层次的锁实现，ReentrantLock是JDK层次的锁实现；
synchronized的锁状态是无法在代码中直接判断的，但是ReentrantLock可以通过
ReentrantLock#isLocked判断；
synchronized是非公平锁，ReentrantLock是可以是公平也可以是非公平的；
synchronized是不可以被中断的，而ReentrantLock#lockInterruptibly方法是可以
被中断的；
在发生异常时synchronized会自动释放锁，而ReentrantLock需要开发者在finally
块中显示释放锁；
ReentrantLock获取锁的形式有多种：如立即返回是否成功的tryLock(),以及等待指
定时长的获取，更加灵活；
synchronized在特定的情况下对于已经在等待的线程是后来的线程先获得锁（回顾
一下sychronized的唤醒策略），而ReentrantLock对于已经在等待的线程是先来的线程
先获得锁；

Semaphore

俗称信号量，它是操作系统中PV操作的原语在java的实现，它也是基于
AbstractQueuedSynchronizer实现的。经常用于限制获取资源的线程数量，或者限流器

package com.test.jucdemo.lock;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class SemaphoreTest2 {

    /**
     * 实现一个同时只能处理5个请求的限流器
     */
    private static Semaphore semaphore = new Semaphore(5);

    /**
     * 定义一个线程池
     */
    private static ThreadPoolExecutor executor = new ThreadPoolExecutor
            (10, 50, 60,
                    TimeUnit.SECONDS, new LinkedBlockingDeque<>(200));

    /**
     * 模拟执行方法
     */
    public static void exec() {
        try {
            //占用1个资源
            semaphore.acquire(1);
            //TODO  模拟业务执行
            System.out.println("执行exec方法");
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放一个资源
            semaphore.release(1);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        {
            for (; ; ) {
                Thread.sleep(100);
                // 模拟请求以10个/s的速度
                executor.execute(() -> exec());
            }
        }
    }
}

配合异常处理的样例代码

import java.util.concurrent.Semaphore;

public class SemaphoreInterruptExample {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(0); // 初始许可为0，表示没有可用许可
        Thread workerThread = new Thread(() -> {
            try {
                System.out.println("Worker thread is trying to acquire a permit.");
                semaphore.acquire(); // 尝试获取许可，这里会阻塞
                System.out.println("Worker thread acquired a permit.");
            } catch (InterruptedException e) {
                System.out.println("Worker thread was interrupted while waiting for a permit.");
                Thread.currentThread().interrupt(); // 恢复中断状态
            } finally {
                System.out.println("Worker thread is releasing the permit.");
                semaphore.release(); // 释放许可
            }
        });

        Thread interruptThread = new Thread(() -> {
            try {
                Thread.sleep(2000); // 等待2秒，让 workerThread 进入 acquire 的阻塞状态
                System.out.println("Interrupt thread is interrupting worker thread.");
                workerThread.interrupt(); // 中断 workerThread
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        workerThread.start();
        interruptThread.start();
    }
}

CountDownLatch

CountDownLatch（闭锁）是一个同步协助类，允许一个或多个线程等待，直到其他线程完成
操作集。

使用场景

一般用作多线程倒计时计数器，强制它们等待其他一组（CountDownLatch的初始化决定）任务执行完成。CountDownLatch的两种使用场景：场景1：让多个线程等待、场景2：让单个线程等待。

  • 让多个线程等待：模拟并发，让并发线程一起执行 （不常见）
package com.test.jucdemo.lock;

import java.util.concurrent.CountDownLatch;

/**
 * 让多个线程等待：模拟并发，让并发线程一起执行
 */
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {

        CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    //准备完毕……运动员都阻塞在这，等待号令
                    countDownLatch.await();
                    String parter = "【" + Thread.currentThread().getName() + "】";
                    System.out.println(parter + "开始执行……");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        Thread.sleep(2000);// 裁判准备发令
        countDownLatch.countDown();// 发令枪：执行发令
    }
}
  • 让单个线程等待：多个线程(任务)完成后，进行汇总合并（常见）
package com.test.jucdemo.lock;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadLocalRandom;

/**
 * 让单个线程等待：多个线程(任务)完成后，进行汇总合并
 */
public class CountDownLatchTest2 {
    public static void main(String[] args) throws Exception {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 0; i < 5; i++) {
            final int index = i;
            new Thread(() -> {
                try {
                    Thread.sleep(1000 +
                            ThreadLocalRandom.current().nextInt(1000));
                    System.out.println(Thread.currentThread().getName()
                            + " finish task" + index);
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        // 主线程在阻塞，当计数器==0，就唤醒主线程往下执行。
        countDownLatch.await();
        System.out.println("主线程:在所有任务运行完成后，进行结果汇总");
    }
}

有没有可以改进的地方呢？

可以使用 CompletableFuture 类来改进！Java8 的 CompletableFuture 提供了很多对多线程友好的方法，使用它可以很方便地为我们编写多线程程序，什么异步、串行、并行或者等待所有线程执行完任务什么的都非常方便

package concurrent;
 
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.thread.ThreadUtil;
 
import java.util.concurrent.CompletableFuture;
 
public class TestCompletableFuture {
 
    public static void main(String[] args) {
        // T1
        CompletableFuture<Void> futureT1 = CompletableFuture.runAsync(() -> {
            System.out.println("T1 is executing. Current time：" + DateUtil.now());
            // 模拟耗时操作
            ThreadUtil.sleep(1000);
        });
        // T2
        CompletableFuture<Void> futureT2 = CompletableFuture.runAsync(() -> {
            System.out.println("T2 is executing. Current time：" + DateUtil.now());
            ThreadUtil.sleep(1000);
        });
 
        // 使用allOf()方法合并T1和T2的CompletableFuture，等待它们都完成
        CompletableFuture<Void> bothCompleted = CompletableFuture.allOf(futureT1, futureT2);
        // 当T1和T2都完成后，执行T3
        bothCompleted.thenRunAsync(() -> System.out.println("T3 is executing after T1 and T2 have completed.Current time：" + DateUtil.now()));
        // 等待所有任务完成，验证效果
        ThreadUtil.sleep(3000);
    }
}

上面的代码还可以继续优化，当任务过多的时候，把每一个 task 都列出来不太现实，可以考虑通过循环来添加任务。

//文件夹位置
List<String> filePaths = Arrays.asList(...)
// 异步处理所有文件
List<CompletableFuture<String>> fileFutures = filePaths.stream()
    .map(filePath -> doSomeThing(filePath))
    .collect(Collectors.toList());
// 将他们合并起来
CompletableFuture<Void> allFutures = CompletableFuture.allOf(
    fileFutures.toArray(new CompletableFuture[fileFutures.size()])
);

CyclicBarrier

字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态（屏障点）之后再全部同
时执行。回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。

使用场景

CyclicBarrier 可以用于多线程计算数据，最后合并计算结果的场景

package concurrent;

import java.util.Set;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 栅栏与闭锁 CountDownLatch 的关键区别在于，所有的线程必须同时到达栅栏位置，才能继续执行。
 */
public class CyclicBarrierTest2 {

    //保存每个学生的平均成绩
    private ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String,Integer>();

    private ExecutorService threadPool= Executors.newFixedThreadPool(3);

    //  提供一个 barrierAction，合并多线程计算结果  
    private CyclicBarrier cb=new CyclicBarrier(3,()->{
        int result=0;
        Set<String> set = map.keySet();
        for(String s:set){
            result+=map.get(s);
        }
        System.out.println("三人平均成绩为:"+(result/3)+"分");
    });


    public void count(){
        for(int i=0;i<3;i++){
            threadPool.execute(new Runnable(){
                @Override
                public void run() {
                    //获取学生平均成绩
                    int score=(int)(Math.random()*40+60);
                    map.put(Thread.currentThread().getName(), score);
                    System.out.println(Thread.currentThread().getName()
                            +"同学的平均成绩为："+score);
                    try {
                        // 阻塞直到指定的线程都调用此方法，继续执行
                        //执行完运行await(),等待所有学生平均成绩都计算完毕
                        cb.await();
                    } catch (InterruptedException | BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }


    public static void main(String[] args) {
        CyclicBarrierTest2 cb=new CyclicBarrierTest2();
        System.out.println("======第一次调用======");
        cb.count();
        System.out.println("======第二次调用======");
        cb.count();
    }
}
  • CyclicBarrier与CountDownLatch的区别：

CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()
方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可
以重置计数器，并让线程们重新执行一次


CyclicBarrier还提供getNumberWaiting(可以获得CyclicBarrier阻塞的线程数量)、
isBroken(用来知道阻塞的线程是否被中断)等方法。


CountDownLatch会阻塞主线程，CyclicBarrier不会阻塞主线程，只会阻塞子线程。
CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点
CountDownLatch一般用于一个或多个线程，等待其他线程执行完任务后，再执
CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执

CyclicBarrier 还可以提供一个 barrierAction，合并多线程计算结果。


CyclicBarrier是通过ReentrantLock的"独占锁"和Conditon来实现一组线程的阻塞
唤醒的，而CountDownLatch则是通过AQS的“共享锁”实现

参考链接

docs/java/concurrent/java-concurrent-questions-03.md · java小皮匠/JavaGuide - Gitee.com

老司机带你细数 AQS 子类，及以其实现的类
weixin_42510876的博客
04-26 572
本文重点 前情提要 上文中详细介绍了 AQS 源码的执行流程和核心思想， 如下。 CAS 自旋 LockSupport.park() unpark() 双端队列 AQS 中 tryAcquire / tryRelease， tryAcquireShared / tryReleaseShared 都需要具体子类根据不同的策略来实现，而具体的排队逻辑、控制加锁及释放都是在 AQS 中实现的 AQS 的子类 1、ReentrantLock 独占锁 可重入 公平与非公平 通过 CAS 设置 state
浅论aqs的实现
KaffeeVenus
07-07 390
时间记录:2019-4-22 一：什么是抽象队列同步器 提供用于实现阻塞锁和相关依赖先进先出(FIFO)等待队列的同步器（信号量、事件等）。此类被设计为大多数类型的同步器的有用基础，这些同步器依赖单个原子int值来表示状态。子类必须定义更改此状态的受保护方法，以及定义此状态对于正在获取或释放的对象意味着什么。考虑到这些，这个类中的其他方法执行所有排队和阻塞机制。子类可以维护其他状态字段，但只有使用...
Java 多线程并发控制：深入理解与实战应用
最新发布
aini_lovee的博客
04-28 328
Java 多线程并发控制是一个复杂而又重要的领域。通过深入理解线程的创建与启动方式、掌握线程同步机制、熟悉线程间通信的方法以及学会避免常见的并发问题，开发者能够更好地利用多线程技术来提高程序的性能和响应性。在实际项目开发中，需要根据具体的需求和场景，合理选择合适的多线程技术和并发控制策略，同时要充分考虑代码的可读性、可维护性和性能优化。不断地实践和积累经验，才能在 Java 多线程并发编程中得心应手，构建出高效、稳定的多线程应用程序。
AQS的具体实现一：ReentrantLock
qq_35015148的博客
12-13 451
AQS的具体实现一：ReentrantLock ​ AQS的实现有多种形式，包括ReentrantLock、CountDownLatch、CyclicBarrier、ReentrantLock、Semaphore和ThreadPoolExecutor。ReentrantLock 可重入的独占锁：可重入指同一线程可以多次进入此锁，独占表示同一时刻只能够有一个线程持有该锁。其实现方式又有两种，分为公平和非公平锁。 ​ 非公平和公平锁：如下图,我们能看到其内部有两个实现类，公平锁与非公平锁。 [外链图片转存失败,
AQS详解与实现
Codefarmer_uzi的博客
07-18 479
AQS基本原理 AQS：全称 AbstractQueuedSynchronizer 位于java.util.concurrent.locks包下，是阻塞式锁和相关的同步器工具的框架 用 state 属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取 锁和释放锁 /** 用 state 属性来表示资源的状态（分独占模式和共享模式） 独占模式是只有一个线程能够访问资源，而共享模式可以允许多个线程访问资源 **/ private volatile int state;
深入分析AQS实现原理(基于ReentrantLock的源码剖析)
qq_34748010的博客
03-06 570
（一）、AQS概述 AbstractQueuedSynchronizer简称AQS，它是java.util.concurrent包中，它提供了一套完整的同步编程框架。我们常用的ReentrantLock、CountDownLatch都是基于AQS实现的。 AQS的实现分为两种形式，一种是独占锁，另一种则是共享锁。 独占锁：每次只能有一个线程持有锁。我们比较熟悉的ReentrantLock就是通过独占锁实现互斥性的。 共享锁：允许多个线程同时获取锁，并发地访问资源。例如ReentrantReadWriteLo
AQS中锁的实现方式及其影响因素
AQS的主要作用是管理同步状态和线程的排队，通过AQS，我们可以实现各种不同类型的锁，如独占锁（ReentrantLock）、读写锁（ReentrantReadWriteLock）等。AQS中提供了一套统一的机制，帮助开发者实现线
AQS的底层实现原理及其算法解析
AQS（AbstractQueuedSynchronizer）简介 ## 1.1 AQS的概念和作用 AQS（AbstractQueuedSynchronizer）是Java并发编程中的一个重要组件。它提供了一种基于队列的同步器框架，用于实现独占锁（Exclusive Lock）和共享...
手撕Java系列--AQS详解，源码分析，核心方法解读，基于AQS实现的类
横竖撇折点
10-24 830
AQS是AbstractQueuedSynchronizer的缩写，它是Java并发包java.util.concurrent.locks中的一个核心类。AQS为构建锁和其他同步组件提供了一个框架。许多并发工具如ReentrantLock、Semaphore、CountDownLatch等都是基于AQS实现的。 AQS的设计基于一个FIFO队列，这个队列用来保存等待获取共享资源的线程。它通过一个int类型的成员变量state来表示同步状态（例如，对于锁而言，state=0意味着没有线程占有锁，而stat
简单介绍AQS原理及其应用场景
AQS简介 AQS（AbstractQueuedSynchronizer）是一个用于构建锁和同步器的框架，是Java中实现锁的基础，提供了一种便捷且高效的实现机制。在并发编程中，AQS扮演着重要的角色，其设计的核心思想是将排队机制的管理...
AQS的阻塞队列实现
作为一个抽象类，AQS提供了一种实现同步器的框架，其中包括了一些原子操作和一些被其子类所重写的方法，这些方法可以用来在需要同步的代码块中进行加锁和释放锁的操作。 AQS主要提供了以下几种功能特性： - 管理...
AQS浅析及其实现类
有个疙叫瘩儿的博客
07-21 815
AQS（AbstractQueuedSynchronizer），抽象队列同步器，AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它。 AQS的核心思想是如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并将共享资源设置为锁定状态；如果被请求的共享资源被占用，就需要一定的阻塞等待唤醒机制来保证锁分配，这个机制AQS是用CLH队列的变体实现的，即将暂时获取不到锁的线程加入到队列中。 CLH（Craig，Landin，a...
深入分析AQS实现原理
weixin_34198762的博客
12-14 525
简单解释一下J.U.C，是JDK中提供的并发工具包,java.util.concurrent。里面提供了很多并发编程中很常用的实用工具类，比如atomic原子操作、比如lock同步锁、fork/join等。 从Lock作为切入点 我想以lock作为切入点来讲解AQS，毕竟同步锁是解决线程安全问题的通用手段，也是我们工作中用得比较多的方式。...
AQS实现分析
01-23 8427
下文将从实现角度分析AQS是如何完成线程同步，主要包括：同步队列、独占式同步状态获取与释放、共享式同步状态获取与释放、超时获取同步状态等AQS的核心数据结构模板方法。同步队列AQS依赖同步队列（一个FIFO双向队列）来完成同步状态的管理。当前线程获取同步状态失败时，AQS会将当前线程以及等待状态等信息构造成一个节点(Node)并且将其加入到同步队列中，同时会阻塞当前线程，当同步状态释放时，会把首节点
Java AQS实现
u011385940的专栏
02-20 3653
Java AQS实现 本篇理清锁和线程相关知识，主要知识点： AQS； ReentrantLock； Condition； Synchronized； Semaphore，CountDownLatch； AQS AQS：AbstractQueuedSynchronizer，抽象队列同步器。 提供实现阻塞锁的框架。像ReentrantLock, Semaphore等都基于AQS来实现并发资源控制逻辑。 abstractclassAbstrac...
JAVA AQS中的实现
u013614949的博客
08-13 372
8.AQS （AbstractQueuedSynchronizer） AQS的作用：AQS 是一个用于构建锁、同步器等线程协作工具类的模板框架 8.1 AQS的实现有哪些？ Semaphore CountDownLatch ReentrantLock CyclicBarrier ReentrantReadWriteLock ThreadPoolExcutor Semaphore 利用AQS的实现 acquire 获取permits个许可 tryAcquireShared 调用nonfairTry
11.AQS及相关实现类
骚小孩啊丶
02-13 611
AQS AQS是一款抽象的队列式同步器，他定义了一套多线程访问共享资源的同步框架。 当请求得资源空闲那么他将当前请求资源设置为有效的工作线程，并将共享变量设置为锁定状态，如果请求的资源锁定，那么就进入CLH阻塞队列中。 AQS定义两种资源共享方式：Exclusve（独占，只有一个线程执行，如Reentrantlock）和Share(共享，多个线程同时执行，Semaphore/CountD...
【并发知识点】AQS的实现原理及应用
Java 技术专栏，从入门到精通，熟悉企业级开发
06-22 2102
AQS的核心思想是将多线程的进入和退出操作都放入一个FIFO（先进先出）的等待队列中，通过对这个等待队列的管理来控制线程的并发访问和同步。具体来说，AQS通过内部的state状态变量来表示锁或信号量的状态，当state为0时表示没有被占用，当state为1时表示被占用。此外，AQS还提供了一个Condition对象，用于在等待队列中挂起和唤醒线程。
AQS解析以及实现类
qq_45239139的博客
04-15 1173
AQS概念： Java提供的底层的工具类，用一个 ine 类型变量来表示同步状态（如果大于等于 1 说明有线程已经持有该资源，为 0 表示当前没有线程持有该资源）以及 FIFO 同步队列来实现一个同步器，AQS 是一个抽象类，但是它里面却没有一个抽象的方法，这也更加说明了，AQS不希望被使用者直接的当做功能类来使用，AQS希望作为底层的工具类一样被其他子类所继承，从而子类具体的功能需求 同步器功能...
java锁的种类及其实现
03-04
<think>好的，我现在需要回答用户关于Java锁的种类及其实现的问题。首先，我得回想一下Java中常见的锁机制。Java的锁主要分为内置锁（synchronized关键字）和显式锁（如ReentrantLock）。此外，还有读写锁、乐观锁、分布式锁等等。不过用户可能更关注的是Java标准库中的锁类型，所以我需要先整理这些内容。 接下来，我需要确定每种锁的具体实现和使用场景。内置锁synchronized是基于JVM实现的，可以修饰方法或代码块，支持重入。显式锁ReentrantLock是java.util.concurrent.locks包下的类，提供了比synchronized更灵活的功能，比如可中断、超时获取、公平锁等。 然后，读写锁ReentrantReadWriteLock，它分离了读锁和写锁，适用于读多写少的场景，提高并发性能。还有StampedLock，这是Java 8引入的，支持乐观读锁，进一步优化了读性能。 另外，可能还需要提到Condition接口，它通常和显式锁配合使用，实现线程间的条件等待。还有像LockSupport这样的工具类，提供更底层的线程阻塞和唤醒机制。 在解释这些锁的时候，需要给出代码示例，这样用户能更直观地理解。比如synchronized的用法，ReentrantLock的基本使用，ReentrantReadWriteLock如何分离读写锁，以及StampedLock的乐观读机制。 同时，应该比较不同锁的优缺点，比如synchronized使用简单但功能有限，ReentrantLock更灵活但需要手动释放锁，避免死锁。读写锁在读多写少时的性能优势，StampedLock在特定场景下的高效性。 可能还需要注意一些细节，比如锁的公平性与非公平性，重入性的意义，以及锁可能带来的性能问题，比如死锁、活锁等，但用户的问题主要是种类和实现，可能不需要深入这些问题的解决方案，但简要提及可能会有帮助。 最后，要确保回答结构清晰，分点说明，每种锁的名称、实现方式、使用场景、代码示例和注意事项。这样用户能逐步了解每种锁的特点，根据实际需求选择合适的锁机制。</think>以下是 Java 中常见锁的种类及其实现方式的详细介绍，按使用场景和特性分类： --- ### 一、**内置锁（隐式锁）** #### 1. **`synchronized` 关键字** - **实现方式**： - 修饰代码块或方法，基于 JVM 的 Monitor 机制实现（底层依赖 `monitorenter` 和 `monitorexit` 指令）。 - 锁对象可以是任意 Java 对象。 - **特点**： - 自动加锁/解锁，支持可重入（同一线程可重复获取锁）。 - 非公平锁（默认抢占机制）。 - **示例**： ```java // 修饰代码块 public void method() { synchronized (this) { // 锁对象为当前实例 // 同步代码 } } // 修饰实例方法（锁对象为当前实例） public synchronized void syncMethod() {} // 修饰静态方法（锁对象为 Class 对象） public static synchronized void staticSyncMethod() {} ``` --- ### 二、**显式锁（`java.util.concurrent.locks` 包）** #### 1. **`ReentrantLock`（可重入锁）** - **实现方式**： - 基于 AQS（AbstractQueuedSynchronizer）实现，需手动加锁 (`lock()`) 和释放锁 (`unlock()`)。 - **特点**： - 可重入、支持公平锁与非公平锁（构造参数指定）。 - 提供更灵活的功能：可中断锁 (`lockInterruptibly()`)、超时获取锁 (`tryLock(timeout)`)。 - **示例**： ```java ReentrantLock lock = new ReentrantLock(); public void method() { lock.lock(); try { // 同步代码 } finally { lock.unlock(); // 必须手动释放 } } ``` #### 2. **`ReentrantReadWriteLock`（读写锁）** -
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值