同步器

最新推荐文章于 2023-11-17 10:24:15 发布
最新推荐文章于 2023-11-17 10:24:15 发布
阅读量829 收藏 3
点赞数 1
分类专栏： Java多线程 文章标签： java 多线程 同步器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lixiaobuaa/article/details/78995572
版权

线程之间相互合作时，需要用到同步器来完成同步，下面介绍几种常用同步器：

1.Semaphore（信号量）
信号量数量限制了访问资源的线程总数，线程请求会消耗一个信号量，当信号量为0时，新的线程会阻塞，直到有线程释放了一个信号量

线程类：

package Semaphore;

import java.util.concurrent.Semaphore;

public class SemaphoreThread extends Thread{

    Semaphore semaphore;
    public SemaphoreThread(Semaphore semaphore){
        this.semaphore = semaphore;
    }
    @Override
    public void run() {
        try {
            semaphore.acquire();
            System.out.println("一个线程正在执行");
            sleep(3000);
            System.out.println("一个线程结束运行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        semaphore.release();
    }
}

测试类：

package Semaphore;

import java.util.concurrent.Semaphore;

public class MainClass {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        SemaphoreThread t1 = new SemaphoreThread(semaphore);
        SemaphoreThread t2 = new SemaphoreThread(semaphore);
        SemaphoreThread t3 = new SemaphoreThread(semaphore);
        SemaphoreThread t4 = new SemaphoreThread(semaphore);
        SemaphoreThread t5 = new SemaphoreThread(semaphore);
        SemaphoreThread t6 = new SemaphoreThread(semaphore);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
    }
}

运行结果：

一个线程正在执行
一个线程正在执行
一个线程正在执行
一个线程结束运行
一个线程结束运行
一个线程正在执行
一个线程正在执行
一个线程结束运行
一个线程正在执行
一个线程结束运行
一个线程结束运行
一个线程结束运行

Process finished with exit code 0

可以看到，由于我们把信号量数量设置为3，所以最多只能有3个线程在同时执行

2.CountDownLatch（倒计时门栓）
每完成一次特定操作，倒计时减一，线程集需要等到倒计时为0时才可执行。注意倒计时门栓是一次性的，计数为0后就不能再用了

线程类：

package CountDownLatch;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchThread extends Thread {
    CountDownLatch countDownLatch;
    public CountDownLatchThread(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        System.out.println("一个线程正在等待");
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("一个线程结束等待");
    }
}

测试类：

package CountDownLatch;

import java.util.concurrent.CountDownLatch;

public class MainClass {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        CountDownLatchThread t1 = new CountDownLatchThread(countDownLatch);
        CountDownLatchThread t2 = new CountDownLatchThread(countDownLatch);
        CountDownLatchThread t3 = new CountDownLatchThread(countDownLatch);
        t1.start();
        t2.start();
        t3.start();
        try {
            System.out.println("计数减一");
            Thread.sleep(1000);
            countDownLatch.countDown();
            System.out.println("计数减一");
            Thread.sleep(1000);
            countDownLatch.countDown();
            System.out.println("计数减一");
            Thread.sleep(1000);
            countDownLatch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

计数减一
一个线程正在等待
一个线程正在等待
一个线程正在等待
计数减一
计数减一
一个线程结束等待
一个线程结束等待
一个线程结束等待

Process finished with exit code 0

可以看到，由于我们把计时器设置为3，所以需要经过三次计数减一操作之后，线程集才可执行

3.CyclicBarrier（循环障栅）
线程在障栅处等待，当等待线程凑够一定数量后，打开障栅，放行这些线程，并执行阶段处理方法，然后重新关闭障栅

线程类：

package CyclicBarrier;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierThread extends Thread {
    CyclicBarrier cyclicBarrier;

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

    @Override
    public void run() {
        System.out.println("正在等待");

        try {
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        System.out.println("开始执行");

    }
}

阶段处理方法：

package CyclicBarrier;

public class Deal implements Runnable {
    @Override
    public void run() {
        System.out.println("打开障栅");
    }
}

测试类：

package CyclicBarrier;

import java.util.concurrent.CyclicBarrier;

public class MainClass {


    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Deal());
        CyclicBarrierThread t1 = new CyclicBarrierThread(cyclicBarrier);
        CyclicBarrierThread t2 = new CyclicBarrierThread(cyclicBarrier);
        CyclicBarrierThread t3 = new CyclicBarrierThread(cyclicBarrier);
        CyclicBarrierThread t4 = new CyclicBarrierThread(cyclicBarrier);
        CyclicBarrierThread t5 = new CyclicBarrierThread(cyclicBarrier);

        try {
            t1.start();
            Thread.sleep(2000);
            t2.start();
            Thread.sleep(2000);
            t3.start();
            Thread.sleep(2000);
            t4.start();
            Thread.sleep(2000);
            t5.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

运行结果：

正在等待
正在等待
打开障栅
开始执行
开始执行
正在等待
正在等待
打开障栅
开始执行
开始执行
正在等待

可以看到，由于我们把障栅大小设置为2，所以当等待线程到达2个时就打开障栅放行。由于我们只有5个线程，所以最后一个线程会一直在障栅处等待

4.Phaser（阶段器）
在循环障栅的基础上增加了控制器，可以在循环若干个阶段后拆除障栅。线程需要注册阶段器，当请求等待线程数等于注册线程数时，打开障栅，执行阶段处理方法，阶段处理方法返回true时拆除障栅。

线程类1：

package Phaser;

import java.util.concurrent.Phaser;

public class Thread1 extends Thread {
    Phaser phaser;

    public Thread1(Phaser phaser) {
        this.phaser = phaser;
        phaser.register();
    }

    @Override
    public void run() {
        System.out.println("等待中");
        phaser.arriveAndAwaitAdvance();
        System.out.println("等待中");
        phaser.arriveAndAwaitAdvance();
        System.out.println("注销");
        phaser.arriveAndDeregister();
    }
}

线程类2：

package Phaser;

import java.util.concurrent.Phaser;

public class Thread2 extends Thread {
    Phaser phaser;

    public Thread2(Phaser phaser) {
        this.phaser = phaser;
        phaser.register();
    }

    @Override
    public void run() {
        System.out.println("等待中");
        phaser.arriveAndAwaitAdvance();
        System.out.println("等待中");
        phaser.arriveAndAwaitAdvance();
        System.out.println("等待中");
        phaser.arriveAndAwaitAdvance();
        System.out.println("注销");
        phaser.arriveAndDeregister();
    }
}

测试类：

package Phaser;

import java.util.concurrent.Phaser;

public class MainClass {
    public static void main(String[] args) {
        Phaser phaser = new Phaser() {
            @Override
            protected boolean onAdvance(int phase, int registeredParties) {
                try {
                    System.out.println("一个阶段完成,注册线程数量：" + registeredParties + ",第" + phase + "阶段");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return registeredParties == 1;
            }
        };

        Thread1 t1 = new Thread1(phaser);
        Thread2 t2 = new Thread2(phaser);

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

运行结果：

等待中
等待中
一个阶段完成,注册线程数量：2,第0阶段
等待中
等待中
一个阶段完成,注册线程数量：2,第1阶段
注销
等待中
一个阶段完成,注册线程数量：1,第2阶段
注销

Process finished with exit code 0

可以看到只有等待线程数目等于注册线程数目时，才会打开障栅，完成一个阶段。由于我们的设置是当注册线程数为1时拆除障栅，所以第2阶段完成后就拆除了障栅，不会再有第3阶段

5.Exchanger（交换器）
两个线程之间交换数据，注意必须成对线程才可交换，如果有单个线程无法成对就会一直阻塞

线程一：

package Exchanger;

import java.util.concurrent.Exchanger;

public class Thread1 extends Thread {
    Exchanger<String> exchanger;
    public Thread1(Exchanger<String> exchanger){
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        System.out.println("线程1写入数据1");
        try {
            System.out.println("线程1获得数据："+exchanger.exchange("1"));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程二：

package Exchanger;

import java.util.concurrent.Exchanger;

public class Thread2 extends Thread {
    Exchanger<String> exchanger;
    public Thread2(Exchanger<String> exchanger){
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        System.out.println("线程2写入数据2");
        try {
            sleep(2000);
            System.out.println("线程2获得数据："+exchanger.exchange("2"));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程三：

package Exchanger;

import java.util.concurrent.Exchanger;

public class Thread3 extends Thread {
    Exchanger<String> exchanger;
    public Thread3(Exchanger<String> exchanger){
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        System.out.println("线程3写入数据3");
        try {
            System.out.println("线程3获得数据："+exchanger.exchange("3"));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试类：

package Exchanger;

import java.util.concurrent.Exchanger;

public class MainClass {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<String>();

        Thread1 t1 = new Thread1(exchanger);
        Thread2 t2 = new Thread2(exchanger);
        Thread3 t3 = new Thread3(exchanger);

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

运行结果：

线程1写入数据1
线程2写入数据2
线程3写入数据3
线程3获得数据：1
线程1获得数据：3

由于我们人为让线程2休眠了2秒，所以线程1和线程3先准备好并交换了数据，线程2就一直处于阻塞状态

6.SynchronousQueue（同步队列）
当一个线程调用put方法时，它会一直阻塞直到另一个线程调用take方法，与Exchanger类似，但Exchanger数据双向传递，SynchronousQueue数据单向传递

「已注销」
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java高级：条件队列与同步器Synchronizer的原理+AQS的应用
qq3164069700的博客
12-24 695
14.构建自定义的同步工具 类库中包含了许多存在状态依赖性的类，例如 FutureTask ， Semaphore和 BlockingQueue等。在这些类中的一些操作中有着基于状态的前提条件，例如，不能从一个空的队列中删除元素，或者获取一个尚未结束的任务的计算结果，在这些操作可以执行之前，必须等到队列进入 “非空 ”状态，或者任务进入 “已完成 ”状态。 创建状态依赖类的最简单方法通常是在类库中现有的状态依赖类的基础上进行构造。本章将介绍实现状态依赖性的各种选择，以及在使用平台提供的状态依赖性机制时需
麒麟虚拟机同步器1.5p版
最新发布
04-22
麒麟虚拟机同步器1.5p版是一款专为虚拟机设计的同步工具，它主要针对的是麒麟操作系统在虚拟环境下的应用。麒麟操作系统是中国自主研发的一款开源操作系统，基于Linux内核，旨在提供安全、稳定、高效的计算环境。这...
java同步器
xixingzhe2的博客
11-17 169
描述依赖关系thenApply() 把前面异步任务的结果，交给后面的FunctionthenCompose()用来连接两个有依赖关系的任务，结果由第二个任务返回描述and聚合关系thenCombine 任务合并，有返回值thenAccepetBoth 两个任务执行完成后，将结果交给thenAccepetBoth消耗，无返回值runAfterBoth 两个任务都执行完成后，执行下一步操作（Runnable）描述or聚合关系。
Java 并发包锁实现的精髓----队列同步器（AbstractQueuedSynchronizer）
知识共享，你我皆是知识的搬运工
08-15 292
队列同步器理解
【Verilog】跨时钟域处理（二）——脉冲同步电路
GalaxyerKw的博客
10-31 2100
脉冲同步电路(跨时钟域处理)
Java面试题总结（乱序版，2020-09-19）
学Java，找哪吒
09-29 3902
一、在 Queue 中 poll()和 remove()有什么区别？ 二、如何让 Java 的线程彼此同步？你了解过哪些同步器？请分别介绍下。 三、CyclicBarrier 和 CountDownLatch 看起来很相似，请对比下呢？ 四、如果客户端禁止 cookie 能实现 session 还能用吗？ 五、OSI 的七层模型都有哪些？ 六、在 Java 中，为什么不允许从静态方法中访问非静态变量？ 七、如何向 Spring Bean 中注入一个 Java.util.Properties？
麒麟虚拟机同步器2.2p版
04-22
麒麟虚拟机同步器2.2p版是一款专为麒麟操作系统设计的高效虚拟机同步工具，旨在提高多虚拟机环境下的协作效率和数据一致性。这款软件能够实现不同虚拟机实例之间的实时数据同步，确保用户在各个虚拟环境中都能获取到...
修改同步器id
12-12
迈拓修改软件 ID升级工具
麒麟VM虚拟机同步器V2.2.rar
08-29
【麒麟VM虚拟机同步器V2.2】是一款专为VMware Workstation设计的实用工具，旨在解决在多虚拟机环境中进行键盘和鼠标同步操作的问题。VMware Workstation是一款强大的桌面虚拟化软件，允许用户在同一台物理主机上运行...
键鼠多开同步器
02-13
"键鼠多开同步器"是一种专为游戏多开或者多任务操作设计的软件工具，它的主要功能是实现多个窗口间键盘和鼠标操作的同步。这意味着用户在一个游戏或应用程序中的输入，可以同时被其他打开的相同程序窗口所接收，极大...
同步控制器说明书..pdf
12-16
同步控制器说明书..pdf
跨时钟域系统设计及同步器设计
07-11
多时钟域的数字系统设计，Verilog语言实现，含有基本电路源代码和testbench。有握手同步器和数据流同步器的简单实现，数据流同步器参照DesignWare中的Data_stream_sync设计。<数字系统设计课程作业><原创>
面试题总结
u013923380的博客
01-03 476
ArrayList 和 Vector 的区别。 说说 ArrayList,Vector, LinkedList 的存储性能和特性。 快速失败 (fail-fast) 和安全失败 (fail-safe) 的区别是什么？ hashmap 的数据结构。 HashMap 的工作原理是什么? Hashmap 什么时候进行扩容呢？ List、Map、Set 三个接口，存取元素时，各有什么特点？ Set 里的元...
各种同步器的实现原理
bluedraam_pp的博客
02-13 1219
我们可以把是实现的原理分成两部分，一个是修改 state 的部分，也就是 AQS 的实现类是如何实现 tryAcquire() 方法；另外一个入队列和出队列的逻辑。其中前一个是都不相同的，后面一个是基本相同的。 先来看看，ReentrantLock tryAquire() // 有两个，一个是公平锁，一个非公平锁 static final class FairSync extends Sync { private static final long serialVersionUID = -30008
同步电路与跨时钟域电路设计1——单bit信号的跨时钟域传输（同步器）
weixin_41788560的博客
06-17 4870
即电路中的所有受时钟控制的单元（如触发器Flip Flop、寄存器Register），全部由一个统一的全局时钟控制。例子：两个触发器都受同一个时钟来控制。同步电路设计的优点：同步电路设计的缺点： 因为电路里面所有的触发器都由时钟网络来控制，所以必须要构建时钟树（时钟网络）。 在时钟网络中，触发器距离时钟源点的不同，会产生时钟偏斜（Clock Skew）。时钟偏斜（Clock Skew）、时钟抖动（Clock Jitter）等所有对时钟时序产生影响的因素，都会对触发器有影响。
脉冲同步器
热门推荐
LovingDuo的博客
08-30 1万+
verilog实现上面的电路： module pulse_syc(     input sclk_1,     input sclk_2,     input p_in,     output p_out,     output p_out1 );     reg p_in_reg=0;     reg delay0,delay1,delay2;     wire mu
数字IC设计verilog编写——6脉冲同步器
用心记录每天的学习，提升自己，虽然有的很基础但真的很重要！
06-05 3890
数字IC设计verilog编写——6脉冲同步器 脉冲同步器 首先在源时钟域进行信号翻转，在跨时钟域到des_clk，并进行边沿检测，即为dec_clk时钟域的脉冲，实现脉冲同步； 在实际的电路设计中，异步电路的设计在实际应用中的重要意义不言而喻。由于信号在不同时钟域之间传输，容易发生亚稳态的问题导致，不同时钟域之间得到的信号不同。 处理亚稳态常用打两拍的处理方法。 多时钟域的处理方法很多，最有效的方法异步fifo,异步fifo适合处理不同时钟域之间传输的数据组，但有时不同时钟域之间仅仅传递脉冲，异步f
同步器的实现
qq_41174684的博客
04-22 1405
同步器是如何完成线程同步的，包括同步队列，独占式同步状态的获取与释放，共享式同步状态的获取和释放，以及超时获取同步状态等同步器的核心数据结构和方法 同步队列：同步器依赖内部的同步队列,来完成同步状态的管理，当前线程获取同步状态失败之后，同步器会将当前线程以及等待状态等信息构造称为一个节点，并将其加入同步队列，同时会阻塞当前线程，当同步状态释放之后，会把首节点中的线程唤醒，使其再次重新获取同步状态 ...
FPGA基础知识13(二级D触发器应用于同步器，减少亚稳态)
时间的诗
07-09 1万+
需求说明：IC设计基础 内容       ：第一部分 关于两级D触发器减小亚稳态的原因                   第二部分 关于亚稳态的讨论 来自       ：时间的诗 原文：http://blog.csdn.net/verylogic/article/details/21407191 第一部分 关于同步器为什么需要二级D触发器
Java并发工具详解：Semaphore、Fork/Join框架与高级同步器
本章节主要探讨Java并发工具中的同步器，这些工具是Java并发编程的关键组成部分，旨在帮助开发者更有效地设计和管理多线程应用。Java并发工具主要集中在`java.util.concurrent`包及其两个子包`java.util.concurrent....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值