同步器

最新推荐文章于 2024-09-19 16:45:34 发布
最新推荐文章于 2024-09-19 16:45:34 发布
阅读量860 收藏 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.5p版
04-22
麒麟虚拟机同步器1.5p版是一款专为虚拟机设计的同步工具，它主要针对的是麒麟操作系统在虚拟环境下的应用。麒麟操作系统是中国自主研发的一款开源操作系统，基于Linux内核，旨在提供安全、稳定、高效的计算环境。这...
SDC系列同步器说明书
08-26
SDC系列同步器说明书.doc
三种同步器电路设计Verilog代码VIVADO仿真
diaojiangxue的博客
09-19 821
采用行为描述风格完成如下三种同步器电路的设计功能仿真与时序仿真验证。提交电子版的设计代码和仿真结果,分析功能与时序仿真的差异,并根据仿真结果对电路的功能特点、使用条件等尽量详细地作出分析讨论。
Java多线程编程之同步器
weixin_33774308的博客
08-11 218
2019独角兽企业重金招聘Python工程师标准>>> ...
麒麟虚拟机同步器2.2p版
04-22
麒麟虚拟机同步器2.2p版是一款专为麒麟操作系统设计的高效虚拟机同步工具，旨在提高多虚拟机环境下的协作效率和数据一致性。这款软件能够实现不同虚拟机实例之间的实时数据同步，确保用户在各个虚拟环境中都能获取到...
窗口同步器 易语言编写的 同步本地窗口
最新发布
09-28
窗口同步器。易语言编写的。同步本地窗口
HellX 局域网键鼠同步器.rar
06-13
《HellX 局域网键鼠同步器：开启多游戏操控新纪元》 在现代电子竞技和游戏娱乐中，玩家往往需要同时操作多个游戏，无论是为了比较不同游戏的体验，还是进行多开游戏的策略，这样的需求日益增长。这时，一款名为...
键鼠多开同步器
02-13
"键鼠多开同步器"是一种专为游戏多开或者多任务操作设计的软件工具，它的主要功能是实现多个窗口间键盘和鼠标操作的同步。这意味着用户在一个游戏或应用程序中的输入，可以同时被其他打开的相同程序窗口所接收，极大...
Java并发---同步器
l1394049664的博客
07-26 750
同步器     信号量（Semaphore）     倒计时门栓（CountDownLatch）     障栅 （CyclicBarrier）     交换器 (Exchanger)     同步队列(SynchronousQueue)     CountDownLatch和CyclicBarrier区别...
java并发编程之同步器
人生百年几今日，今日不为真可惜。
10-19 5426
同步器是一些使线程能够等待另一个线程的对象，允许它们协调动作。最常用的同步器是CountDownLatch和Semaphore，不常用的是Barrier 和Exchanger 倒计数器 锁存器是一次性障碍，允许一个或者多个线程等待一个或者多个其它线程来做某些事情。CountDownLatch的唯一构造器带一个int类型的参数，这个int参数是指允许所有在等待线程被处理之前，必须在锁存器上调用co
Java多线程（七）之同步器基础：AQS框架深入分析
热门推荐
Vern的专栏
12-09 3万+
一、什么是同步器 多线程并发的执行，之间通过某种 共享 状态来同步，只有当状态满足 xxxx 条件，才能触发线程执行 xxxx 。 这个共同的语义可以称之为同步器。可以认为以上所有的锁机制都可以基于同步器定制来实现的。 而juc(java.util.concurrent)里的思想是 将这些场景抽象出来的语义通过统一的同步框架来支持。 juc 里所有的这些锁机制都是基
Java 同步器
张伯毅的专栏
06-24 1149
java.util.concurrent 包包含了几个能帮助人们管理相互合作的线程集的类见表 14-5。这 些机制具有为线程之间的共用集结点模式(common rendezvous patterns) 提供的“ 预置功能” ( canned functionality ) 0 如果有一个相互合作的线程集满足这些行为模式之一， 那么应该直接 重用合适的库类而不要试图提供手工的锁与条件的集合。 ...
java 同步器
TO TOP CODER
07-08 764
信号量 如果学过rk
java同步器
xixingzhe2的博客
11-17 248
描述依赖关系thenApply() 把前面异步任务的结果，交给后面的FunctionthenCompose()用来连接两个有依赖关系的任务，结果由第二个任务返回描述and聚合关系thenCombine 任务合并，有返回值thenAccepetBoth 两个任务执行完成后，将结果交给thenAccepetBoth消耗，无返回值runAfterBoth 两个任务都执行完成后，执行下一步操作（Runnable）描述or聚合关系。
Java同步器
moni_mm的博客
04-29 408
Sync类 提供一个阻塞锁和相关同步器（信号量，事件等）框架的实现 基于先进先出（FIFO）等待队列 Semaphore 通过计数器控制对共享资源的访问。 eg:创建有信号量计数器为2的信号量 class SmpThread extends Thread { public Semaphore smp; public SmpThread(Semaphore smp...
Java同步器Phaser（阶段器）
灼烧的疯狂
05-29 330
类似于循环障栅CyclicBarrier，不过有一个可变的计数器（JavaSE7中引入） 一个小例子简单说明用法： PS：自我感觉良好，觉得看完这个例子都该懂了…O(∩_∩)O import java.util.Random; import java.util.concurrent.*; /** * * @date 2020/5/29 17:09 * @author wei.heng */ public class PhaserTest { public static void main(S
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值