JDK源码——locks包（二）

于 2024-08-10 08:00:00 发布
阅读量385 收藏 8
点赞数 13
分类专栏： Java 文章标签： java 开发语言 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Luck_gun/article/details/141073119
版权

实现类

LockSupport

这是一个实用工具类，提供基本的线程阻塞原语，如park()和unpark()，用于创建自定义的同步机制。

类的方法如下：
在这里插入图片描述

  1. park(): 阻塞当前线程直到它被唤醒。
  2. parkUntil(long): 阻塞当前线程直到指定的绝对时间（毫秒）。
  3. parkUntil(Object, long): 阻塞当前线程直到指定的条件变量状态发生变化或达到指定的绝对时间。
  4. parkNanos(Object, long): 阻塞当前线程直到指定的条件变量状态发生变化或达到指定的纳秒数。
  5. getBlocker(Thread): 返回指定线程的阻塞对象。
  6. setBlocker(Thread, Object): 设置指定线程的阻塞对象。
  7. nextSecondarySeed(): 返回下一个次要种子值。
  8. parkNanos(long): 阻塞当前线程直到指定的纳秒数。
  9. park(Object): 阻塞当前线程直到指定的条件变量状态发生变化。
  10. unpark(Thread?): 唤醒一个正在等待的线程。

使用场景

使用场景主要包括以下几种：

  1. 线程同步：当一个线程需要等待另一个线程完成某个操作时，可以使用 LockSupport 的 park() 方法将当前线程阻塞，等待其他线程唤醒。
  2. 实现自定义同步组件：例如，可以实现一个简单的生产者-消费者模型，其中生产者线程在生产数据后调用 park() 阻塞，消费者线程在消费数据后调用 unpark(Thread) 唤醒生产者线程。
  3. 实现定时任务：可以使用 LockSupport 的 parkNanos() 或 parkUntil() 方法实现线程的延时执行。

示例：

import java.util.concurrent.locks.LockSupport;

public class LockSupportExample {
    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            System.out.println("生产者开始生产...");
            // 模拟生产数据
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("生产者生产完毕，准备唤醒消费者...");
            LockSupport.unpark(consumer); // 唤醒消费者线程
        });

        Thread consumer = new Thread(() -> {
            System.out.println("消费者等待生产者生产...");
            LockSupport.park(); // 阻塞消费者线程，等待生产者唤醒
            System.out.println("消费者收到通知，开始消费...");
        });

        consumer.start(); // 先启动消费者线程
        producer.start(); // 然后启动生产者线程
    }
}

在这个示例中，生产者线程在生产完数据后调用 LockSupport.unpark(consumer) 唤醒消费者线程，消费者线程在启动时调用 LockSupport.park() 将自己阻塞，等待生产者线程唤醒。

ReentrantLock

Lock接口的一个实现，它允许单个线程多次获得锁，是一个可重入的互斥锁。

类的方法如下：
在这里插入图片描述

  1. isLocked(): boolean - 返回此锁是否被线程持有。

  2. lockInterruptibly(): void - 获取锁，但如果线程在等待获取锁的过程中被中断，将抛出InterruptedException。

  3. hasWaiters(Condition): boolean - 返回给定条件的等待集中是否有任何等待的线程。

  4. getWaitQueueLength(Condition): int - 返回等待在给定条件的等待集中的线程数。

  5. hasQueuedThreads(): boolean - 返回是否有线程等待获取此锁。

  6. hasQueuedThread(Thread): boolean - 返回给定线程是否在等待获取此锁的队列中。

  7. getHoldCount(): int - 返回当前线程在此锁上重复获取的次数。

  8. toString(): String - 返回此锁的字符串表示形式。

  9. getQueueLength(): int - 返回等待获取此锁的线程数。

  10. lock(): void - 获取锁，如果锁不可用，使当前线程等待。

  11. newCondition(): Condition - 创建并返回一个新的Condition实例，该实例绑定到此锁。

  12. isFair(): boolean - 返回此锁是否为公平锁。

  13. getWaitingThreads(Condition): Collection<Thread> - 返回正在等待给定条件的线程。

  14. tryLock(): boolean - 尝试获取锁，仅在调用时锁是空闲的才获取锁。

  15. getQueuedThreads(): Collection<Thread> - 返回一个集合，它包含可能正在等待获取此锁的所有线程。

  16. tryLock(long, TimeUnit): boolean - 尝试在给定的等待时间内获取锁。

  17. getOwner(): Thread - 返回持有此锁的线程，如果没有线程持有则返回null。

  18. unlock(): void - 释放锁。

  19. isHeldByCurrentThread(): boolean - 返回当前线程是否持有此锁。

使用场景

使用场景：

  1. 需要更细粒度的锁定控制，例如可中断的锁定、公平锁和非公平锁等。
  2. 需要实现多个条件变量的同步，而不仅仅是一个。
  3. 需要在锁定期间执行一些操作，然后释放锁，再重新获取锁。
  4. 需要支持锁的尝试获取，以避免死锁。

示例：

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

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private int count = 0;

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
            System.out.println("Count: " + count);
            condition.signalAll(); // 唤醒所有等待的线程
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public void decrement() {
        lock.lock(); // 获取锁
        try {
            count--;
            System.out.println("Count: " + count);
            condition.signalAll(); // 唤醒所有等待的线程
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public void waitForZero() throws InterruptedException {
        lock.lock(); // 获取锁
        try {
            while (count != 0) {
                condition.await(); // 等待直到 count 为 0
            }
            System.out.println("Count is zero");
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.decrement();
            }
        });

        Thread t3 = new Thread(() -> {
            try {
                example.waitForZero();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

在这个示例中，我们使用了 ReentrantLock 来保护对共享资源（count）的访问。我们创建了三个线程，分别执行递增、递减和等待计数器为零的操作。通过使用 ReentrantLock 和 Condition，我们可以确保在多线程环境下对这些操作的正确同步。

ReentrantReadWriteLock

ReadWriteLock接口的一个实现，支持可重入的读锁和写锁功能。

类的方法如下：
在这里插入图片描述

  1. getThreadId(Thread): long - 获取指定线程的ID。
  2. getReadLockCount(): int - 获取当前持有读锁的线程数量。
  3. getQueuedReaderThreads(): Collection<Thread> - 返回等待获取读锁的线程集合。
  4. getQueuedThreads(): Collection<Thread> - 返回等待获取任何锁（读或写）的线程集合。
  5. hasQueuedThreads(): boolean - 是否有线程在等待获取锁。
  6. getWaitQueueLength(Condition): int - 返回给定条件的等待队列中的线程数。
  7. writeLock(): WriteLock - 获取写锁。
  8. getWriteHoldCount(): int - 获取当前持有写锁的线程数量。
  9. hasWaiters(Condition): boolean - 返回给定条件是否有等待的线程。
  10. getQueuedWriterThreads(): Collection<Thread> - 返回等待获取写锁的线程集合。
  11. isWriteLockedByCurrentThread(): boolean - 当前线程是否持有写锁。
  12. getWaitingThreads(Condition): Collection<Thread> - 返回正在等待给定条件的线程集合。
  13. readLock(): ReadLock - 获取读锁。
  14. getQueueLength(): int - 返回等待获取任何锁（读或写）的线程数。
  15. toString(): String - 返回此锁的字符串表示形式。
  16. hasQueuedThread(Thread): boolean - 检查指定的线程是否在等待队列中。
  17. getOwner(): Thread - 返回当前持有锁的线程，如果没有线程持有则返回null。
  18. isFair(): boolean - 判断此锁是否为公平锁。
  19. isWriteLocked(): boolean - 判断此锁是否被写锁定。
  20. getReadHoldCount(): int - 获取当前持有读锁的线程数量。

使用场景

使用场景：

  1. 当多个线程需要频繁读取共享资源时，使用读锁可以提高性能，因为读锁之间不会阻塞。
  2. 当只有一个线程需要修改共享资源时，使用写锁可以确保数据的一致性和完整性。
  3. 在读写比例较高的场景下，ReentrantReadWriteLock 比使用普通的synchronized关键字更高效。

示例：

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockExample {
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private int count = 0;

    public void increment() {
        readWriteLock.writeLock().lock(); // 获取写锁
        try {
            count++;
            System.out.println("Incremented count to: " + count);
        } finally {
            readWriteLock.writeLock().unlock(); // 释放写锁
        }
    }

    public void decrement() {
        readWriteLock.writeLock().lock(); // 获取写锁
        try {
            count--;
            System.out.println("Decremented count to: " + count);
        } finally {
            readWriteLock.writeLock().unlock(); // 释放写锁
        }
    }

    public void getCount() {
        readWriteLock.readLock().lock(); // 获取读锁
        try {
            System.out.println("Current count: " + count);
        } finally {
            readWriteLock.readLock().unlock(); // 释放读锁
        }
    }

    public static void main(String[] args) {
        ReentrantReadWriteLockExample example = new ReentrantReadWriteLockExample();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.decrement();
            }
        });

        Thread t3 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.getCount();
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

在这个示例中，我们使用了 ReentrantReadWriteLock 来保护对共享资源（count）的访问。我们创建了三个线程，分别执行递增、递减和获取计数器值的操作。通过使用 ReentrantReadWriteLock，我们可以确保在多线程环境下对这些操作的正确同步。

StampedLock

一个乐观读锁的实现，它提供了一种通过戳记来控制读写访问的方法，可以有效处理高并发的数据访问。

类方法如下：
在这里插入图片描述

  • unlockWrite(long stamp): 释放写锁。
  • readLockInterruptibly(): 获取读锁，可中断。
  • validate(long stamp): 验证给定的stamp是否有效。
  • acquireWrite(boolean interruptible, long nanos): 尝试获取写锁，可以指定是否可中断以及等待时间。
  • tryReadLock(long time, TimeUnit unit): 尝试在指定的时间内获取读锁。
  • writeLock(): 获取写锁。
  • getReadLockCount(long stamp): 获取给定stamp对应的读锁计数。
  • tryUnlockWrite(): 尝试释放写锁，如果成功则返回true，否则返回false。
  • tryIncReaderOverflow(long stamp): 尝试增加溢出计数器，如果成功则返回新的stamp，否则返回0。
  • isReadLocked(): 判断是否有线程持有读锁。
  • tryWriteLock(long time, TimeUnit unit): 尝试在指定的时间内获取写锁。
  • readObject(ObjectInputStream in): 从输入流中读取对象。
  • getReadLockCount(): 获取当前读锁计数。
  • toString(): 返回类的字符串表示形式。
  • unstampedUnlockRead(): 释放未标记的读锁。
  • tryConvertToWriteLock(long stamp): 尝试将给定的stamp转换为写锁，如果成功则返回新的stamp，否则返回0。
  • isWriteLocked(): 判断是否有线程持有写锁。
  • release(WNode node): 释放节点持有的锁。
  • tryOptimisticRead(): 尝试进行乐观读操作。
  • writeLockInterruptibly(): 获取写锁，可中断。
  • cancelWaiter(WNode w, WNode next, boolean isShared): 取消等待队列中的节点。
  • tryConvertToReadLock(long stamp): 尝试将给定的stamp转换为读锁，如果成功则返回新的stamp，否则返回0。
  • tryConvertToOptimisticRead(long stamp): 尝试将给定的stamp转换为乐观读锁，如果成功则返回新的stamp，否则返回0。
  • asReadWriteLock(): 返回一个ReadWriteLock实例。
  • tryUnlockRead(): 尝试释放读锁，如果成功则返回true，否则返回false。
  • asWriteLock(): 返回一个Lock实例，用于写操作。
  • tryDecReaderOverflow(long stamp): 尝试减少溢出计数器，如果成功则返回新的stamp，否则返回0。
  • acquireRead(boolean interruptible, long nanos): 尝试在指定的时间内获取读锁。
  • unstampedUnlockWrite(): 释放未标记的写锁。
  • unlockRead(long stamp): 释放给定stamp对应的读锁。
  • asReadLock(): 返回一个Lock实例，用于读操作。
  • tryWriteLock(): 尝试获取写锁。
  • readLock(): 获取读锁。
  • unlock(long stamp): 释放给定stamp对应的锁。

使用场景

使用场景：

  1. 当多个线程需要频繁读取共享资源时，使用 StampedLock 可以提高性能，因为读锁之间不会阻塞。
  2. 当只有一个线程需要修改共享资源时，使用 StampedLock 可以确保数据的一致性和完整性。
  3. 在读写比例较高的场景下，StampedLock 比使用普通的synchronized关键字更高效。

示例：

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private int x = 0;
    private final StampedLock stampedLock = new StampedLock();

    public void increment() {
        long stamp = stampedLock.writeLock();
        try {
            x++;
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }

    public int getX() {
        long stamp = stampedLock.tryOptimisticRead();
        int currentX = x;
        if (!stampedLock.validate(stamp)) {
            stamp = stampedLock.readLock();
            try {
                currentX = x;
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
        return currentX;
    }

    public static void main(String[] args) {
        StampedLockExample example = new StampedLockExample();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Current value of x: " + example.getX());
            }
        });

        t1.start();
        t2.start();
    }
}

在这个示例中，我们使用了 StampedLock 来保护对共享资源（x）的访问。我们创建了两个线程，一个线程用于递增 x 的值，另一个线程用于获取 x 的当前值。通过使用 StampedLock，我们可以确保在多线程环境下对这些操作的正确同步。

吴代庄
关注
  • 13
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Jdk源码——AQS同步队列解析
等一杯咖啡的博客
12-26 498
前言 本文主要参考自《Java 并发编程的艺术》第五章内容，结合源码对书中内容进行分析补充。 I. Lock接口 在 Lock 接口出现之前，Java程序是靠 synchronized 关键字实现锁功能的，而 Java SE 5 之后，并发包中新增了 Lock 接口（以及相关实现类）用来实现锁功能，它提供了与 synchronized 关键字类似的同步功能，只是在使用时需要显式地获取和释放锁。...
JDK源码研究——ReentrantLock浅析
HinyLover的专栏
09-27 1306
本文简单地介绍一下从JDK1.5开始引入的java.util.concurrent（简称J.U.C）包下的ReentrantLock类。Reentrant的英文含义是“可重入的”，也就是说ReentrantLock表示可重入的锁。这个类是用纯的java语言来实现synchronized关键字的功能，并且补充了synchronized没有实现的部分功能。
JDK源码——locks包（一）
最新发布
吴代庄的博客
08-10 408
这是一个抽象类，提供了锁的拥有者信息。它主要是为了创建具有所有权功能的同步器，例如信号量和事件计数。：这是一个受保护的方法，用于设置当前拥有独占访问权限的线程。传入一个线程对象作为参数，如果传入null，则表示没有线程拥有访问权限。：这是一个受保护的方法，用于获取当前拥有独占访问权限的线程。如果没有线程拥有访问权限，返回null。这是一个为一系列所设计的抽象框架，比如信号量、事件等，其中操作长整型值。它提供了一个基于FIFO的阻塞队列，可以用于构建锁定和相关的同步器。
JDK源码——AQS源码
庄小焱
11-24 943
AQS 就是一个抽象类，继承了AbstractOwnableSynchronizer ，主要用来构建锁和同步器。这个类在 java.util.concurrent.locks 包下面，AQS为构建锁和同步器提供了一些通用功能的实现，因此，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如 ReentrantLock，Semaphore，其他的 ReentrantReadWriteLock，SynchronousQueue，FutureTask(jdk1.7) 等等皆是基于 AQS 的。
Java juc系列4 ——locks包（二）
seethefuture的博客
06-11 550
Java JUC系列目录链接 Java juc系列4 ——locks包（二）locks包简介AQSAQS中的主要成员变量AQS中的主要方法ReentrantLock公平队列同步器非公平队列同步器ReentrantReadWriteLock locks包简介 locks是java.util.concurrent包下的设计线程锁相关的包，今天我们来简单分析一些这个包下面的内容和他们的主要实现原理。 AQS 说到多线程自然会有锁机制，有锁机制自然就有占有锁线程和等待线程，而等待线程就会由我们的AQS（抽象队列同步
jdk源码分析——Collection 集合
剑八的博客
08-09 374
jdk源码分析——Collection 集合 Collection——java.util.Collection not recommended 不建议使用 - Enumeration                 迭代器，被Iterable取代 - StringTokenizer          字符分割器，建议用split和regex代替 - Vector         ...
Java多线程（16）——JUC——locks系列（3）——AQS
波波鱼的博客
09-27 314
目录 0.locks包简介 1.AQS简介 1.1 AQS是什么 1.2AQS框架实现的一些点 1.3 AQS的层次结构 2.AQS原理及源码详解 2.1状态 （1）state实现独占锁的图解 （2）state实现可重入锁的图解 2.2节点Node 2.3同步队列 2.4 加锁函数acquire （1）tryAcquire(int) （2）addWaiter(N...
JDK1.8源码阅读笔记——Object根父类（一）
weixin_48095246的博客
10-05 362
native关键字 private static native void registerNatives(); static { registerNatives(); } native即JNI，Java Native Interface(Java本地接口,用户和本地C代码进行互操作的API)，也就是说一个native method就是一个java调用非java代码的接口，该方法由非java语言实现，例如C语言。 1、native是用作 java和其他语言进行协作时使用的，也
【学习之路】——JDK源码阅读顺序
我爱吃土豆
11-08 6580
很多java开发的小伙伴都会阅读jdk源码，然而确不知道应该从哪读起。以下为小编整理的通常所需阅读的源码范围。 标题为包名，后面序号为优先级1-4，优先级递减 1、java.lang 1) Object 1 2) String 1 3) AbstractStringBuilder 1 4) StringBuffer 1 5) StringBuilder 1 6) Boolean 2 7...
JDK源码包(包含sun包下的源码)
10-19
源码包是理解JDK内部工作原理的关键，它允许开发者深入学习和调试Java平台的底层机制。通常，JDK安装后的`src.zip`文件包含了大部分的Java标准库源代码，但这不包括`sun`包下的源码。`sun`包中的类是Oracle JDK特有...
JDK8完整源码包
05-27
这份"JDK8完整源码包"包含了JavaFX、Sun私有实现等核心组件的源代码，为深入理解Java平台的工作原理提供了宝贵的资源。 首先，JavaFX是Java的图形用户界面（GUI）库，自JDK 8起成为标准部分，它提供了丰富的UI组件...
jdk8源码包
09-13
这个"jdk8源码包"就是用于查看和学习JDK8内部实现细节的重要资源。 首先，JDK8引入了Lambda表达式，这是一种简洁的函数式编程语法，使得处理集合和事件流变得更加简单。Lambda可以作为参数传递，也可以作为方法...
JDK源码包.zip
03-11
解决在eclipse，myeclipse，idea等开发工具中追源码时遇到追不到的情况，因为本身JDK里面的源码文件只有20MB远远不完整，内含Java源码包，使用方法等，希望能够帮助到更多的喜欢看源码的技术朋友。
JDK1.8 sun 包源码
07-12
安装完JDK后，会在%JAVA_HOME% /jdk文件夹下生成一个src.zip，此文件夹对应rt.jar中的java源码，但细心研究后发现rt.jar中sun包下的文件不存在，也就是说sun包下的java源码并没有打包到src....此包为JDK1.8 sun 包源码
C++ - 函数重载
jiaowenjie的专栏
08-06 289
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
时光不等人：java每日一练
m0_67187271的博客
08-05 1058
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
Java面试篇（JVM相关专题）
聂可以的博客
08-09 1633
Java面试篇（JVM相关专题）
Spring事务
c1tenj2的博客
08-07 397
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

吴代庄

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值