玩转JUC工具，Java并发编程不再危机四伏

最新推荐文章于 2024-08-22 11:59:02 发布
最新推荐文章于 2024-08-22 11:59:02 发布
阅读量127 收藏
点赞数
文章标签： java jvm 开发语言
原文链接：https://juejin.cn/post/7215454015726420026
版权

前言

  当今互联网应用普遍需要支持高并发访问，而Java作为一种广泛使用的编程语言，其并发编程能力对于实现高性能的应用非常重要。而Java的JUC（java.util.concurrent）并发工具就提供了许多实用的工具类和接口，可以让Java应用轻松实现高效的并发编程。

ReetrantLock

  ReentrantLock是Java提供的一个可重入锁，也是Java并发编程中最常用的一种锁。与synchronized关键字相比，ReentrantLock具有更大的灵活性和功能，可以更好地支持并发编程的实现。

特点

  1. 可重入性：与synchronized一样，ReentrantLock也支持可重入锁，即同一个线程可以重复获得该锁，而不会出现死锁。
  2. 公平锁：ReentrantLock可以创建公平锁，即按照线程请求的顺序分配锁，确保等待时间最长的线程最先获得锁，避免了线程饥饿问题。
  3. 中断响应：当线程等待获取锁的过程中，可以通过调用interrupt()方法中断等待，避免线程无限等待。
  4. 条件变量：ReentrantLock可以创建多个Condition对象，用于控制线程等待和唤醒，从而实现更灵活的线程协作。
  5. 性能优越：在高度竞争的多线程环境中，ReentrantLock相比synchronized有更好的性能表现，特别是在多处理器系统中。

简单使用

模拟秒杀商品场景

public class SecKillDemo {
    private static int stock = 1;

    // 秒杀锁
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        // 模拟多个用户抢购
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    // 加锁
                    lock.lock();
                    try {
                        // 判断库存是否足够
                        if (stock > 0) {
                            // 模拟生成订单
                            System.out.println(Thread.currentThread().getName() + "抢购成功，生成订单");
                            // 减少库存
                            stock--;
                        } else {
                            System.out.println(Thread.currentThread().getName() + "抢购失败，库存不足");
                        }
                    } finally {
                        // 解锁
                        lock.unlock();
                    }
                }
            }).start();
        }
    }
}
复制代码

加锁结果:最先进来的线程抢购成功其余线程抢购失败

不加锁结果:4个线程抢购成功出现超卖现象

可重入示例

  当一个线程获得了ReentrantLock锁之后，如果该线程继续请求获得这个锁，那么该线程可以继续获得这个锁，这种情况就是ReentrantLock锁的可重入性。下面是一个表现出ReentrantLock锁的可重入性的例子：

public class ReentrantLockExample {

    private final ReentrantLock lock = new ReentrantLock();

    public void outer() {
        lock.lock(); // 第一次获取锁
        try {
            inner();
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public void inner() {
        lock.lock(); // 第二次获取锁
        try {
            System.out.println("第二次获取锁");
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        example.outer();
    }
}
复制代码

  在这个例子中，我们定义了一个ReentrantLock锁，并创建了一个outer方法和一个inner方法。在outer方法中，我们首先通过调用lock方法获取锁，并在try块中调用inner方法，然后在finally块中释放锁。在inner方法中，我们再次获取锁，并输出一条信息。

  可以看到，在outer方法中，我们第一次获取锁，然后调用inner方法，inner方法中又通过lock方法获取了锁，但这次获取锁是成功的，并且能够正常输出信息，说明ReentrantLock锁具有可重入性。

Condition

  当使用ReentrantLock时，可以使用Condition对象来进行线程的协调和等待。

public class ConditionDemo {

    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            while (count == 1) {  // 如果计数器已经达到1，就等待
                condition.await();
            }
            count++;  // 计数器加1
            System.out.println(Thread.currentThread().getName() + ": " + count);
            condition.signalAll();  // 唤醒其他等待的线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void decrement() {
        lock.lock();
        try {
            while (count == 0) {  // 如果计数器已经为0，就等待
                condition.await();
            }
            count--;  // 计数器减1
            System.out.println(Thread.currentThread().getName() + ": " + count);
            condition.signalAll();  // 唤醒其他等待的线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ConditionDemo demo = new ConditionDemo();

        // 创建两个线程分别进行增加和减少操作
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                demo.increment();
            }
        }, "Thread-A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                demo.decrement();
            }
        }, "Thread-B").start();
    }
}
复制代码

  在这个示例中，有一个计数器count，两个线程分别进行增加和减少操作。在increment()和decrement()方法中，通过调用ReentrantLock的lock()方法获取锁，并在执行操作之前使用while循环判断条件是否满足，如果不满足就通过调用Condition的await()方法等待。

  当条件满足时，线程执行相应的操作，并使用Condition的signalAll()方法唤醒其他等待的线程。在这个示例中，当计数器为1时，增加线程就会等待，直到计数器减为0；当计数器为0时，减少线程就会等待，直到计数器增加为1。

应用场景

  1. 解决多线程竞争资源的问题，例如多个线程同时对同一个数据库进行写操作，可以使用ReentrantLock保证每次只有一个线程能够写入。

  2. 实现多线程任务的顺序执行，例如在一个线程执行完某个任务后，再让另一个线程执行任务。

  3. 实现多线程等待/通知机制，例如在某个线程执行完某个任务后，通知其他线程继续执行任务

Semaphore

  Semaphore（信号量）是JUC并发工具包中的一种同步工具，用于管理一个或多个共享资源的访问。Semaphore 维护一个计数器，该计数器可以对共享资源的访问进行控制，类似于停车场的车位管理，当所有的车位已满时，新来的车辆必须等待其他车辆离开才能进入停车场。

Semaphore实现限流

public class RateLimiter {

    private Semaphore semaphore;

    public RateLimiter(int permits) {
        semaphore = new Semaphore(permits);
    }

    public boolean tryAcquire() {
        return semaphore.tryAcquire();
    }

    public void release() {
        semaphore.release();
    }
}
复制代码

  在上述代码中，我们定义了一个名为RateLimiter的限流器类。它有一个构造函数，用于初始化Semaphore计数器，其中参数permits表示允许同时访问的线程数。

  在tryAcquire()方法中，我们使用了Semaphore的tryAcquire()方法来尝试获取一个许可，如果获取成功则返回true，否则返回false。

  在release()方法中，我们调用Semaphore的release()方法来释放一个许可。

public static void main(String[] args) {
    int permits = 5;
    RateLimiter rateLimiter = new RateLimiter(permits);

    // 模拟10个线程并发请求
    for (int i = 0; i < 10; i++) {
        new Thread(() -> {
            try {
                if (rateLimiter.tryAcquire()) {
                    System.out.println(Thread.currentThread().getName() + " 获得访问权限");
                    Thread.sleep(1000);
                } else {
                    System.out.println(Thread.currentThread().getName() + " 被限流");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                rateLimiter.release();
                System.out.println(Thread.currentThread().getName() + " 释放访问权限");
            }
        }, "Thread-" + (i + 1)).start();
    }
}
复制代码

在上述代码中，我们创建了一个限流器RateLimiter，允许同时有5个线程访问。然后，我们模拟10个请求。当有可用许可时，请求被允许访问；当所有许可都被占用时，请求被拒绝访问。

应用场景

  1. 限流：Semaphore可以用于限制对共享资源的并发访问数量，以控制系统的流量。

  2. 资源池：Semaphore可以用于实现资源池，以维护一组有限的共享资源。

CountDownLatch

  CountDownLatch可以帮助控制线程之间的执行顺序。在某些场景下，可能需要等待多个线程执行完毕后，再继续执行某些操作，这时候就可以使用CountDownLatch来实现线程的等待。

  CountDownLatch内部维护了一个计数器，该计数器的初始值可以通过构造函数进行指定。在主线程中调用CountDownLatch的await()方法会使当前线程等待，直到计数器的值为0时才会继续执行。而在其他线程中调用CountDownLatch的countDown()方法则会将计数器的值减1。当计数器的值减到0时，之前在主线程中调用await()方法的线程就会继续执行。

CountDownLatch实现多任务合并

  比如说，有一个系统需要进行批量数据导入，数据是从多个文件中读取的，每个文件需要一个线程进行处理，等所有文件处理完毕后再进行下一步操作，这时候就可以使用CountDownLatch来实现等待多个线程执行完毕后再继续执行。。

public class BatchImportDemo  {


    private CountDownLatch latch;
    private String[] filenames = {"file1.txt", "file2.txt", "file3.txt"};

    public BatchImportDemo() {
        this.latch = new CountDownLatch(filenames.length);
    }

    public void start() {
        for (String filename : filenames) {
            new Thread(new ImportTask(filename, latch)).start();
        }
        try {
            latch.await(); // 等待所有线程执行完毕
            System.out.println("所有文件处理完毕，开始进行下一步操作。");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static class ImportTask implements Runnable {
        private String filename;
        private CountDownLatch latch;

        public ImportTask(String filename, CountDownLatch latch) {
            this.filename = filename;
            this.latch = latch;
        }

        @Override
        public void run() {
            // 处理文件的逻辑
            System.out.println("正在处理文件 " + filename);
            try {
                Thread.sleep(2000); // 模拟文件处理
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("文件 " + filename + " 处理完毕。");
            latch.countDown(); // 计数器减1
        }
    }

    public static void main(String[] args) {
        BatchImportDemo demo = new BatchImportDemo();
        demo.start();
    }
}
复制代码

  在这个示例中，我们定义了一个BatchImportDemo类，它包含了一个CountDownLatch实例和一个字符串数组filenames，表示需要处理的文件名。在start()方法中，我们启动了多个线程来处理每个文件，并调用了latch.await()方法来等待所有线程执行完毕。而在每个线程中，我们执行了具体的文件处理逻辑，并在处理完毕后调用了latch.countDown()方法来将计数器减1。

  运行上述代码，输出结果为

正在处理文件 file1.txt
正在处理文件 file2.txt
正在处理文件 file3.txt
文件 file1.txt 处理完毕。
文件 file2.txt 处理完毕。
文件 file3.txt 处理完毕。
所有文件处理完毕，开始进行下一步操作。
复制代码

  可以看到，当所有文件处理完毕后，程序输出了“所有文件处理完毕，开始进行下一步操作。”的信息。这说明我们成功地使用CountDownLatch来等待多个线程执行完毕后再进行后续的操作。

应用场景

  1. 主线程等待多个线程执行完毕后再继续执行。
  2. 多个线程等待某个操作完成后再继续执行。
  3. 实现并发任务的协调，例如多个线程同时执行不同的子任务，当所有子任务都执行完毕后，再执行后续的操作。

CyclicBarrier

  CyclicBarrier（回环栅栏或循环屏障），是 Java 并发库中的一个同步工具，通过它可以实现让一组线程等待至某个状态（屏障点） 之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。

CyclicBarrier多个线程协同工作

public class CyclicBarrierDemo {

    public static void main(String[] args) throws InterruptedException {
        int threadCount = 5;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount, new Runnable() {
            @Override
            public void run() {
                System.out.println("所有线程执行完成，开始执行主线程...");
            }
        });
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " 执行任务...");
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + " 执行任务完成...");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        System.out.println("主线程执行...");
    }
}
复制代码

  上述示例中，定义了5个线程，这5个线程需要等待所有线程都执行完成后，才能继续执行主线程。在定义CyclicBarrier时，将屏障点的数量设置为5，当所有线程都到达屏障点时，会执行Runnable中的任务，输出 "所有线程执行完成，开始执行主线程..."。每个线程执行任务完成后，会调用CyclicBarrier的await()方法，等待其他线程执行完成。

  执行以上代码，输出如下：

Thread-0 执行任务...
Thread-1 执行任务...
Thread-2 执行任务...
Thread-3 执行任务...
Thread-4 执行任务...
主线程执行...
Thread-1 执行任务完成...
Thread-0 执行任务完成...
Thread-3 执行任务完成...
Thread-2 执行任务完成...
Thread-4 执行任务完成...
所有线程执行完成，开始执行主线程...
复制代码

  从输出结果可以看出，所有线程都先执行各自的任务，然后等待其他线程执行完成，当所有线程都执行完成后，执行Runnable中的任务，输出 "所有线程执行完成，开始执行主线程..."，最后主线程继续执行。

应用场景

  1. 多线程任务：CyclicBarrier 可以用于将复杂的任务分配给多个线程执行，并在所有线程完成工作后触发后续作。

  2. 数据处理：CyclicBarrier 可以用于协调多个线程间的数据处理，在所有线程处理完数据后触发后续操作。

Phaser

  Phaser用于协调多个线程的执行。它提供了一些方便的方法来管理多个阶段的执行，可以让程序员灵活地控制线程的执行顺序和阶段性的执行。Phaser可以被视为CyclicBarrier和CountDownLatch的进化版，它能够自适应地调整并发线程数，可以动态地增加或减少参与线程的数量。所以Phaser特别适合使用在重复执行或者重用的情况。

Phaser阶段任务使用

public class PhaserDemo   {

    public static void main(String[] args) {
        int numPhases = 3; // 设置阶段数为3
        int numThreads = 5; // 设置线程数为5
        Phaser phaser = new Phaser(numThreads); // 创建Phaser对象并注册线程数
        for (int i = 0; i < numThreads; i++) {
            new Thread(new Worker(phaser)).start(); // 创建并启动线程
        }
        for (int i = 0; i < numPhases; i++) {
            System.out.println("Phase " + i + " 阶段开始");
            phaser.arriveAndAwaitAdvance(); // 等待所有线程到达同步点
            System.out.println("Phase " + i + " 阶段完成");
        }
    }

    static class Worker implements Runnable {
        private Phaser phaser;

        Worker(Phaser phaser) {
            this.phaser = phaser;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 开始执行");
            for (int i = 0; i < 3; i++) { // 模拟每个线程需要执行3个任务
                phaser.arriveAndAwaitAdvance(); // 到达同步点并等待其他线程
                System.out.println(Thread.currentThread().getName() + " 完成第" + i + "个任务");
            }
        }
    }
}
复制代码

  上述示例中，我们创建了一个Phaser对象，将线程数和阶段数分别设置为5和3，然后创建5个线程并启动它们。每个线程需要完成3个任务，在完成每个任务后调用arriveAndAwaitAdvance()方法到达同步点并等待其他线程，等到所有线程到达同步点后才会进入下一个阶段。最终，程序输出了每个线程完成任务的信息，以及每个阶段的开始和结束时间。

应用场景

  1. 多线程执行多阶段任务，需要协调各个线程的执行顺序。
  2. 多线程进行游戏或模拟操作，需要协调各个线程的执行时机。
  3. 多个线程需要协同工作来处理一个大型问题，例如搜索算法或者数据分析等。

Exchanger

  Exchanger是JUC（java.util.concurrent）并发工具之一，它提供了一个同步点，使得两个线程可以交换对象。Exchanger中交换对象的过程是一个阻塞方法，只有在两个线程都到达同步点时，才会交换对象，并且在交换完成后，两个线程会继续执行自己的代码。

  Exchanger通常用于实现数据的同步和线程间的通信，例如在生产者和消费者模式中，可以使用Exchanger来实现生产者和消费者之间的数据交换。另外，Exchanger也可以用于遗传算法、数据加密等应用场景中。

Exchanger使用

public class ExchangerDemo {

    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();
        Thread thread1 = new Thread(() -> {
            try {
                String data1 = "data1";
                String data2 = exchanger.exchange(data1);
                System.out.println("Thread1 received: " + data2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                String data2 = "data2";
                String data1 = exchanger.exchange(data2);
                System.out.println("Thread2 received: " + data1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();

    }
}
复制代码

  在上述示例代码中，创建了一个Exchanger对象exchanger，然后启动了两个线程thread1和thread2。线程thread1将字符串"data1"交换给线程thread2，并且接收到线程thread2交换过来的字符串"data2"；线程thread2将字符串"data2"交换给线程thread1，并且接收到线程thread1交换过来的字符串"data1"。最后，两个线程都输出了接收到的数据。

应用场景

  1. 生产者消费者模式：在生产者和消费者模式中，可以使用Exchanger来实现生产者和消费者之间的数据交换，从而实现数据的同步和交流。
  2. 遗传算法：在遗传算法中，可以使用Exchanger来实现父代和子代之间的基因交换，从而实现基因的进化和优化。
  3. 数据加密：在数据加密中，可以使用Exchanger来实现加密和解密数据之间的交换，从而保证数据的安全性。
  4. 线程间协作：在需要多个线程协作完成某项任务的场景中，可以使用Exchanger来实现线程间的数据交换和同步，从而协同完成任务。

  需要注意的是，Exchanger只适用于两个线程之间的数据交换，如果需要多个线程之间的数据交换和同步，可以使用其他的并发工具，例如CyclicBarrier、CountDownLatch等。在选择并发工具时，应根据具体的场景和需求来进行选择。

 

小贤编程手记
关注
Java并发编程面试题——JUC专题
二蛋的博客
02-20 7535
1.1AQS是什么？1.2唤醒线程时，AQS为什么从后往前遍历？1.3AQS为什么用双向链表，（为啥不用单向链表）？1.4AQS为什么要有一个虚拟的head节点1.5ReentrantLock的底层实现原理1.6ReentrantLock的公平锁和非公平锁的区别1.7ReentrantReadWriteLock如何实现的读写锁2.1说下你熟悉的阻塞队列？2.2虚假唤醒是什么？3.1线程池的7个参数3.2线程池的状态有什么，如何记录的？3.3线程池常见的拒绝策略3.4线程池执行流程3.5线程池为什么添加空任务
多线程安全——JUC工具汇总
城南孔乙己的专栏
02-14 3318
LongAdder JDK1.8时，java.util.concurrent.atomic包中提供了一个新的原子类：LongAdder。 根据Oracle官方文档的介绍，LongAdder在高并发的场景下会比它的前辈————AtomicLong 具有更好的性能，代价是消耗更多的内存空间： 转存失败重新上传取消 ...
JUC工具类
复制乔布斯
04-11 862
​Exchanger​ 是 Java 中的一个同步工具类，用于在两个线程之间进行数据交换。Exchanger​ 提供了一个同步点，当两个线程都到达这个同步点时，它们可以交换数据。​ExchangerExchanger​ 允许两个线程之间进行数据的交换，其中一个线程将数据放入Exchanger​，而另一个线程从Exchanger​ 中取出数据，从而实现线程间的数据传递。Exchanger​ 提供了一个同步点，当两个线程都到达这个同步点时，它们可以交换数据。
Java JUC 基本使用及教程
最新发布
qq_41493103的博客
08-22 881
是并发执行的程序在执行过程中分配和管理资源的基本单位，是一个动态概念，竞争计算机系统资源的基本单位。是进程的一个执行单元，是进程内科调度实体。比进程更小的独立运行的基本单位。线程也被称为轻量级进程。 wait/sleep的区别 1、是的静态方法, 是的方法,任何对象实例都能调用 2、不会释放锁,它也不需要占用锁。会释放锁,但调用它的前提是当前线程占有锁(即代码要在中)。 3、它们都可以被方法中断 并行和并发 并发:同一时刻多个线程在访问同-一个资源,多个线程对一个点 例子:春运抢票电商秒杀… 并行:多项工作
java并发编程专题（六）----浅析（JUC）Semaphore
08-18
Java 并发编程专题（六）----浅析（JUC）Semaphore Java 并发编程专题（六）----浅析（JUC）Semaphore 是 Java 并发编程中的一种重要机制，它主要用于控制多个线程访问共享资源的同时性。Semaphore 是一种信号量...
java并发编程：juc线程池
08-09
Java并发编程中的JUC线程池是Java程序员必须掌握的关键技术之一，它允许开发者高效地管理并发执行的任务，充分利用多核处理器的性能。线程池的出现解决了在并发环境中线程创建、销毁带来的开销，提高了系统资源的...
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
JUC——共享模型之工具
m0_51710682的博客
08-01 780
这时 Thread-4 释放了 permits，接下来 Thread-0 竞争成功，permits 再次设置为 0，设置自己为 head 节点，断开原来的 head 节点，unpark 接 下来的 Thread-3 节点，但由于 permits 是 0，因此 Thread-3 在尝试不成功后再次进入 park 状态。，是阻塞式锁和相关的同步器工具的框架。提交任务的时，即使有线程池里的线程从阻塞队列中获取不到任务，如果线程池里的线程数还是小于核心线程数，那么依然会继续创建线程，而不是复用已有的线程。
Juc（常用工具，CAS算法）
笔记别偷看
11-02 384
JUC常用工具 CountDownLatch: 减少计数 CyclicBarrier: 循环栅栏 Semaphore: 信号灯 CountDownLatch Java 5.0 在java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。 CountDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 闭锁 CountDownLatch类可以设置一个计数器，然后通过countDown方法来进行减1的操作，使用await
JAVA常用工具JUC
qq_21197507的博客
01-19 405
JAVA工具包
JUC工具包介绍
11-14 705
JUC工具包，全称为Java.util.concurrent工具包，是Java提供的用于实现多线程编程的工具集合。它是在Java 5版本中引入的，并在后续版本中得到了进一步的扩展和优化。JUC工具包中包含了许多常用的组件和类，如线程池（Executor）、并发集合类（Concurrent Collections）、原子类（Atomic）、锁（Lock）、同步器（Synchronizers）等。这些组件和类提供了一些高效、可扩展和线程安全的机制，可以帮助开发者更好地处理并发访问、线程同步和协作等问题。
JUC常见工具类
qq_40025976的博客
08-19 994
JUC常见工具类
JUC工具包学习
X1nZz的博客
07-20 950
JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包。进程：进程是程序的一次执行，进程是一个程序及其数据在处理机上顺序执行时所发生的活动，进程是具有独立功能的程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。线程：线程作为资源调度的基本单位，是程序的执行单元，执行路径(单线程：一条执行路径，多线程：多条执行路径)。是程序使用CPU的最基本单位。...
常用的JUC（Java Util Concurrent）工具类
weixin_44440231的博客
04-14 1850
包下的原子类为Java并发编程提供了一组高效的、线程安全的原子操作类，它们主要用于在高并发环境下确保对共享变量的操作具有原子性，即在同一时刻只有一个线程能够修改这些变量的值，而不会出现因多线程并发导致的中间状态或数据竞争问题。当两个线程都到达交换点时，它们各自携带的数据会被互换，确保线程间的通信和协作。，等待其他线程也到达屏障。当所有线程都到达后，屏障动作执行，然后屏障重置，线程们继续进行下一次迭代，如此反复三次。的特性，它们各自操作的是独立的本地副本，因此输出结果互不影响，展示了线程间数据的隔离。
juc下的四大工具类
h1346706115的博客
07-31 887
juc (java.util.conction)包下四大工具类:CAS+Lock 1.闭锁CountDownLatch public CountDownLatch(int count) : count表示需要等待的线程个数 public void countDown() : 计数器值-1(类似运动员线程) public void await() throws InterruptedExceptio...
Java并发编程详解：JUC工具包与多线程实战
Java.util.concurrent (JUC) 包是Java平台提供的用于编写高效并发程序的关键工具集。这个包包含了各种线程安全的数据结构、同步工具类和并发算法，如Executor框架、并发容器、锁机制以及原子变量等。 在JUC中，三个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值