JAVA并发基础: 同步器的使用

最新推荐文章于 2024-03-21 05:27:00 发布
最新推荐文章于 2024-03-21 05:27:00 发布
阅读量1.3k 收藏 5
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chen1250/article/details/120363513
版权

前言

Semaphore、CountDownLatch、CyclicBarrier、Exchanger、Phaser 

信号量、倒计时门栓、循环屏障、交换器、移相器

一、什么是同步器？

线程之间相互合作时，需要用到同步器来完成同步，java.util.concurrent包提供了几个能帮助我们管理相互合作的线程集的类。这些机制具有为线程之间的公用集结点提供“预置功能”，这句话通俗理解就是线程集要等待一个起始点一起开始运行。

二、同步器的使用

1.信号量

概念：一个信号量管理许多许可证。为了通过信号量，线程通过调用acquire请求许可。实际上没有真实的许可对象，信号量仅维护一个计数。许可的数目是固定的，由此控制了同一时刻通过的线程数量。其他线程可以通过调用release释放许可，而且许可不是必须由获取它的线程来释放，任意线程可以释放任意数量的许可，这会导致许可数目超出起始数量。信号量还支持是否公平申请。

public class SemaphoreTest {

    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 15; i++) {
            new Thread(new SemaphoreTask(semaphore)).start();
        }
    }

    static class SemaphoreTask implements Runnable {

        private Semaphore semaphore;

        public SemaphoreTask(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                // 获取许可该方法会阻塞直到获取到许可
                this.semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " start task...");
                Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
                System.out.println(Thread.currentThread().getName() + " task completed");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 一般都是在finally中自己释放获取的许可
                this.semaphore.release();
            }
        }

    }

}

2.倒计时门栓

一个倒计时门栓让一个线程集等待直到计数变为0才开始工作，任务线程每完成一个就减1，倒计时门栓是一次性的一旦计数为0，就不能再重用。

场景1、多线程等待主线程任务：可以用于秒杀场景

场景2、多线程任务主线程等待：一般是用于初始化工作

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        test1();
        test2();
    }

    /**
     * 多线程等待主线程任务：可以用于秒杀场景
     * @throws InterruptedException
     */
    static void test2() throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < 5; i++) {
            new Thread(new CountDownLatchTask2(countDownLatch)).start();
        }
        // 主线程睡眠模拟执行任务
        Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
        // 完成任务
        countDownLatch.countDown();
    }

    static class CountDownLatchTask2 implements  Runnable {

        CountDownLatch countDownLatch;

        public CountDownLatchTask2(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            // 就绪
            System.out.println(Thread.currentThread().getName() + " ready....");
            try {
                // 等待开门
                this.countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            onlyOnde();
        }

        static boolean flag;
        static synchronized void onlyOnde() {
            if (!flag) {
                System.out.println(Thread.currentThread().getName() + " doing....");
                flag = true;
            }
        }

    }

    /**
     * 多线程任务主线程等待：一般是用于初始化工作
     * @throws InterruptedException
     */
    static void test1() throws InterruptedException {
        System.out.println(Thread.currentThread().getName() +  " start init task on child thread...");
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 0; i < 5; i++) {
            new Thread(new CountDownLatchTask(countDownLatch)).start();
        }
        // 等待初始化完成
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName() +  " server started");
    }

    static class CountDownLatchTask implements  Runnable {

        CountDownLatch countDownLatch;

        public CountDownLatchTask(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            try {
                // 任务线程睡眠模拟执行任务
                Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " task completed");
            // 完成任务
            this.countDownLatch.countDown();
        }

    }

}

3.循环屏障

 CyclicBarrier类实现了一个集结点称为屏障，一旦所有线程到达这个屏障则撤销屏障线程继续运行。Cyclic（循环）意思是可以设置多个屏障并且可以使用reset方法重置来达到循环使用的目的，多个线程需要多次同步数据的时候使用，否则只有一个屏障使用CountDownLatch就可以了。循环屏障还可以设置所有线程达到屏障后执行一个任务，该任务有最后一个到达的线程执行。

最直观的一个列子就是英雄组队游戏时场景 等待加入->选择英雄->初始化加载

public class CyclicBarrierTest {

    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(gamerCount, new Runnable() {
            @Override
            public void run() {
                // 所有玩家每次都到达一个屏障时调用（由最后到达的线程调用）
                switch ((int) countDownLatch.getCount()) {
                    case 3: System.out.println(Thread.currentThread().getName() + " join ready..."); break;
                    case 2: System.out.println(Thread.currentThread().getName() + " choose ready..."); break;
                    case 1: System.out.println(Thread.currentThread().getName() + " init ready..."); break;
                }
                // 屏障倒计
                countDownLatch.countDown();
            }
        });
        test1(cyclicBarrier);
    }

    // 倒计时门栓，用于倒计玩家到达的屏障点
    static CountDownLatch countDownLatch;
    static final int gamerCount = 5;

    static void test1(CyclicBarrier cyclicBarrier) throws InterruptedException {
        System.out.println("============================================================");
        System.out.println(Thread.currentThread().getName() + " star join game...");
        countDownLatch = new CountDownLatch(3);
        for (int i = 0; i < gamerCount; i++) {
            new Thread(new CyclicBarrierTask(cyclicBarrier)).start();
        }

        // 屏障倒计等待：等待任务完成，这里模拟屏障的循环使用
        countDownLatch.await();
        cyclicBarrier.reset();
        test1(cyclicBarrier);
    }

    /**
     * 英雄组队游戏案例
     */
    static class CyclicBarrierTask implements Runnable {

        CyclicBarrier cyclicBarrier;

        public CyclicBarrierTask(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                // 等待组队
                Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
                System.out.println(Thread.currentThread().getName() + " wating join...");
                cyclicBarrier.await();

                // 选择英雄
                Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
                System.out.println(Thread.currentThread().getName() + " choose hero...");
                cyclicBarrier.await();

                // 游戏初始化加载
                Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
                System.out.println(Thread.currentThread().getName() + " init data...");
                cyclicBarrier.await();

                System.out.println(Thread.currentThread().getName() + " start game...");
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }

    }

}

 4.交换器 

当两个线程在同一个数据缓冲器工作的时时，就可以使用交换器，当两个线程需要同步数据时使用，一般用于数据校验。

public class ExchangerTest {

    public static void main(String[] args) throws InterruptedException {
        Exchanger<String> exchanger = new Exchanger<>();
        new Thread(){
            @Override
            public void run() {
                try {
                    String A = "Apple";
                    System.out.println(Thread.currentThread().getName() + " A 线程开始处理任务...");
                    Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
                    System.out.println(Thread.currentThread().getName() + " A 线程任务处理完成等待交换...");
                    String B = exchanger.exchange(A);
                    System.out.println(Thread.currentThread().getName() + " A 交换过程： " + A + " --> " + B);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                try {
                    String B = "Orange";
                    System.out.println(Thread.currentThread().getName() + " B 线程开始处理任务...");
                    Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
                    System.out.println(Thread.currentThread().getName() + " B 线程任务处理完成等待交换...");
                    String A = exchanger.exchange(B);
                    System.out.println(Thread.currentThread().getName() + " B 交换过程： " + B + " --> " + A);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }

}

5.移相器 

Phaser相对来说较复杂一些，一般可以看做是循环屏障和倒计时门栓的结合体，如上面3我写到的CyclicBarrierTest中就使用到了CountDownLatch来记录任务阶段。移相器可能不好理解称之为阶段性同步器更好理解。Pahser可以继承并重写onAdvance方法来执行阶段性工作，Pahser更特殊的是在运行时可以任意注册或注销任务线程，Phaser还提供了较多的方法共我们使用：register：注册、arriveAndAwaitAdvance：到达并等待、arriveAndDeregister：达到并注销、arrive：达到结束...

public class PhaserTest {

    public static void main(String[] args) {
        Phaser phaser = new MinePhaser(5);
        for (int i = 0; i < 5; i++) {
            new Thread(new PhaserTask1(phaser)).start();
        }

        // 动态注册一个线程并等待其他线程到达，只是用于阻塞等待（不然直接执行下面代码了）
        phaser.register();
        phaser.arriveAndAwaitAdvance();

        // 动态注册3个整理任务线程（公共任务的整理任务线程不够）
        phaser.register();
        phaser.register();
        for (int i = 0; i < 3; i++) {
            new Thread(new PhaserTask2(phaser)).start();
        }

        // 动态注册一个线程并等待其他线程到达，只是用于阻塞等待（不然直接执行下面代码了）
        phaser.register();
        phaser.arriveAndAwaitAdvance();

        // 需要注销上面动态注册的四个线程，不然永远达不到终点
        phaser.arriveAndDeregister();
        phaser.arriveAndDeregister();
        phaser.arriveAndDeregister();
        phaser.arriveAndDeregister();
    }

    /**
     * 自定义移相器并重写onAdvance
     */
    static class MinePhaser extends Phaser {
        public MinePhaser(int parties) {
            super(parties);
        }

        @Override
        protected boolean onAdvance(int phase, int registeredParties) {
            switch (phase) {
                case 0:
                    System.out.println("第一阶段，收集完毕！参与者数量：" + registeredParties);
                    break;
                case 1:
                    System.out.println("第二阶段，整理完毕！参与者数量：" + registeredParties);
                    break;
                case 2:
                    System.out.println("第三阶段，记录完毕！参与者数量：" + registeredParties);
                    break;
            }
            return super.onAdvance(phase, registeredParties);
        }
    }

    /**
     * 公共任务
     */
    static class PhaserTask1 implements Runnable {
        Phaser phaser;

        public PhaserTask1(Phaser phaser) {
            this.phaser = phaser;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
                System.out.println(Thread.currentThread().getName() + " 已爬完");
                this.phaser.arriveAndAwaitAdvance();

                Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
                System.out.println(Thread.currentThread().getName() + " 已整理");
                this.phaser.arriveAndAwaitAdvance();

                Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
                System.out.println(Thread.currentThread().getName() + " 已记录");
                this.phaser.arriveAndAwaitAdvance();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 整理任务
     */
    static class PhaserTask2 implements Runnable {
        Phaser phaser;

        public PhaserTask2(Phaser phaser) {
            this.phaser = phaser;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(3000));
                System.out.println(Thread.currentThread().getName() + " 已整理");
                this.phaser.arrive();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
}

总结

如果一个相互合作的线程集满足上面这些行为模式之一，那么应该直接使用合适的同步组件而不要去尝试用使用锁与条件的集合。

参考来源《JAVA核心技术卷I》

原创不易欢迎点赞，如有错误请不吝指点...

转载请标明出处：https://blog.csdn.net/chen1250/article/details/120363513

MJoyChen
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java高级：条件队列与同步器Synchronizer的原理+AQS的应用
qq3164069700的博客
12-24 694
14.构建自定义的同步工具 类库中包含了许多存在状态依赖性的类，例如 FutureTask ， Semaphore和 BlockingQueue等。在这些类中的一些操作中有着基于状态的前提条件，例如，不能从一个空的队列中删除元素，或者获取一个尚未结束的任务的计算结果，在这些操作可以执行之前，必须等到队列进入 “非空 ”状态，或者任务进入 “已完成 ”状态。 创建状态依赖类的最简单方法通常是在类库中现有的状态依赖类的基础上进行构造。本章将介绍实现状态依赖性的各种选择，以及在使用平台提供的状态依赖性机制时需
java同步器
xixingzhe2的博客
11-17 134
描述依赖关系thenApply() 把前面异步任务的结果，交给后面的FunctionthenCompose()用来连接两个有依赖关系的任务，结果由第二个任务返回描述and聚合关系thenCombine 任务合并，有返回值thenAccepetBoth 两个任务执行完成后，将结果交给thenAccepetBoth消耗，无返回值runAfterBoth 两个任务都执行完成后，执行下一步操作（Runnable）描述or聚合关系。
Java 并发包锁实现的精髓----队列同步器（AbstractQueuedSynchronizer）
知识共享，你我皆是知识的搬运工
08-15 280
队列同步器理解
java并发编程之同步器，Android开发新手入门教程
最新发布
m0_61067876的博客
03-21 678
外链图片转存中…(img-llmatU1l-1710970011094)][外链图片转存中…(img-gzLa2GeU-1710970011095)]
Java并发-同步器原理
solo_jm的博客
08-25 201
CountDownLatch 在我们实际做开发的时候可能会遇到这样的需求，主线程需要等待所有子线程完成任务之后再执行操作，我们可以用join来实现这个功能，但是join不够灵活，主线程只能等子线程完全执行完毕才能从join返回，而不能在子线程某个位置就执行返回。 为了解决这个问题，JDK开发组提供了CountDownLatch这个类，这样的需求通过CountDownLatch来实现会更加优雅、灵活。 CountDownLatch的使用 public static final CountDownLatch c
java并发编程之同步器代码示例
08-28
Java并发编程之同步器代码示例 ...Java并发编程之同步器代码示例展示了Java中的同步器机制，包括CountDownLatch、Semaphore、Barrier和Exchanger队列同步器等，帮助开发者更好地理解和使用Java中的并发编程技术。
java并发编程：juc、aqs
08-09
AQS 是 JUC 中的核心组件，它提供了一个框架，让开发者能够轻松地构建自定义的同步器。通过继承 AQS，可以实现不同的同步机制，如独占锁、共享锁等。 高效的等待队列： AQS 内部维护了一个等待队列，用于管理等待锁...
Java并发编程：CountDownLatch与CyclicBarrier和Semaphore的实例详解
08-29
Java并发编程是Java语言中的一种高级技术，用于处理多线程编程中的同步问题。Java 1.5中引入了几个高效的辅助类，包括CountDownLatch、CyclicBarrier和Semaphore，这些类可以帮助开发者更好地进行并发编程。本文将...
Java并发编程：用AQS写一把可重入锁
02-24
这是一个抽象类，它定义了一套多线程访问共享资源的同步器框架，J.U.C包下的许多同步类实现都依赖于它，比如ReentrantLock/Semaphore/CountDownLatch，可以说这个抽象类是J.U.C并发包的基础。之所以把这一章节叫做...
Java中的锁——队列同步器
惟愿无事
12-20 8133
队列同步器AbstractQueuedSynchronizer(AQS)，似乎我们不经常用，但是它是用来构建锁或者其他同步组件的基础框架，它使用了一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。下图显示了java.concurrent包的实现示意图 同步器的主要使用方式是继承，一般作为同步器组件的静态内部类，在同步器中仅定义了与状态相关的方法，且这个状
Java并发编程中的同步器
xxsiyao的博客
07-08 311
1. CyclicBarrier【参考文献】 和 CountDownLatch 类似 线程会等待，直到足够多线程达到了事先规定的数据。一旦触发条件，就可以进行下一步的操作 适用于线程之间相互等待处理结果就绪的场景 CyclicBarrier 可以构造一个集结点，当某一个线程执行完毕，它就会到集结点等待，直到所有线程都到了集结点，那么该栅栏就会被撤销，所有线程再统一出发，继续执行剩下的任务 用法一：等待所有人到达指定地点，再统一出发 import java.util.concurrent.BrokenBa
Java并发---同步器
l1394049664的博客
07-26 727
同步器     信号量（Semaphore）     倒计时门栓（CountDownLatch）     障栅 （CyclicBarrier）     交换器 (Exchanger)     同步队列(SynchronousQueue)     CountDownLatch和CyclicBarrier区别...
Java并发——多线程并发编程中的同步器
守夜人爱吃兔子的博客
06-25 362
前两天一个小伙伴突然找我求助，说准备换个坑，最近在系统学习多线程知识，但遇到了一个刷新认知的问题…… 小伙伴：Effective JAVA 里的并发章节里，有一段关于可见性的描述。下面这段代码会出现死循环，这个我能理解，JMM 内存模型嘛，JMM 不保证 stopRequested 的修改能被及时的观测到。 static boolean stopRequested = false; public static void main(String[] args) throws Interrupted
harbor实例间的镜像传输
weixin_43557605的博客
09-21 1659
操作部分 现在已经具备了两个安装好的harbor和一个docker客户端，主机及ip情况如下所示 主机 ip 角色 host1 192.168.20.120 docker host2 192.168.20.121 harbor1 host3 192.168.20.122 harbor2 在harbor1上创建项目kgc 在harbor1上设置复制目标 在har...
同步器的实现
qq_41174684的博客
04-22 1348
同步器是如何完成线程同步的，包括同步队列，独占式同步状态的获取与释放，共享式同步状态的获取和释放，以及超时获取同步状态等同步器的核心数据结构和方法 同步队列：同步器依赖内部的同步队列,来完成同步状态的管理，当前线程获取同步状态失败之后，同步器会将当前线程以及等待状态等信息构造称为一个节点，并将其加入同步队列，同时会阻塞当前线程，当同步状态释放之后，会把首节点中的线程唤醒，使其再次重新获取同步状态 ...
同步电机与异步电机的区别
热门推荐
Earthrise
11-08 3万+
试着回答一下，欢迎交流啊。     1. 同步电机，转速与旋转磁势同步，而异步电动机的转速则低于电磁转速；同步电机不论负载大小，只要不失步，转速就不会变化，异步电动机的转速时刻跟随负载大小的变化而变化。     2. 二者转动的原理不同。同步电机，定子和转子都产生磁场，即定子绕组通三相交流电以后产生旋转磁场，转子磁场可由直流励磁线圈或者永磁体产生，定子磁场和转子磁场就像两块磁铁一样，同性相吸；...
同步器
长风
01-07 824
线程之间相互合作时，需要用到同步器来完成同步，下面介绍几种常用同步器：1.Semaphore（信号量） 信号量数量限制了访问资源的线程总数，线程请求会消耗一个信号量，当信号量为0时，新的线程会阻塞，直到有线程释放了一个信号量线程类：package Semaphore;import java.util.concurrent.Semaphore;public class SemaphoreThread
AQS（抽象的队列同步器）
qq_28772075的博客
08-13 343
前提了解： 公平锁和非公平锁 可重入锁 LockSupport 自旋锁 数据结构之链表 设计模式之模板设计模式 1 是什么 抽象的队列同步器 队列：单/双列表， ArrayList就是链表结构 是用来构建锁或者其他同步器组件（一系列根据锁相关的组件）的重量级基础框架及整个JUC体系的基石，通过内置的FIFO队列来完成资源获取线程的排队工作，并通过一个int类型变量表示持有锁的状态。 JUC中有几个AQS缩写的相关内容，长得很相似，通常聊的AQS是指Abstract...
Java中的同步集合与并发集合有什么区别
06-14
Java中的同步集合和并发集合都是用于多线程环境下的集合，但它们有以下区别： 1. 线程安全性：同步集合通过使用synchronized关键字来实现线程安全，而并发集合则是通过使用锁机制来实现线程安全。 2. 性能表现：并发集合比同步集合在多线程环境下的性能要好，因为并发集合采用了更细粒度的锁机制，可以更好地利用多核CPU的性能。而同步集合在高并发情况下可能会出现线程阻塞，导致性能下降。 3. 内存占用：同步集合的实现中通常会涉及到锁对象的创建和维护，这会导致内存占用更高。而并发集合的实现中通常采用了更精细的内存管理方式，内存占用更低。 4. 迭代器：并发集合在迭代时支持弱一致性，而同步集合则需要在迭代时加锁以保证线程安全。 因此，在多线程环境下，如果需要高性能和较低的内存占用，可以选择使用并发集合；如果需要更高的线程安全性，可以选择使用同步集合。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值