Java线程同步器

最新推荐文章于 2024-07-16 17:44:34 发布
最新推荐文章于 2024-07-16 17:44:34 发布
阅读量164 收藏
点赞数
分类专栏： Java 文章标签： CyclicBarrier CountDownLatch Exchanger SynchronousQueue Semaphore
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csyqbt001/article/details/84430905
版权

1.CyclicBarrier(屏障)

   CyclicBarrier类是通过设置屏障点来管理同步的，当所有参与的线程都到达指定屏障的时候，那么参与的所有线程就会全部    积蓄运行，具体测试代码如下：

 

public class CyclicBarrierTest {
	// 定义一个循环屏障
	private CyclicBarrier cyclicBarrier;

	// 构造函数
	//count为参与执行的线程数
	//rn为所有线程到达屏障后需要做的行为
	public CyclicBarrierTest(int count, Runnable rn) {
		this.cyclicBarrier = new CyclicBarrier(count, rn);
	}

	public void sayHello(String name, int time) {
		System.out.println("开始执行:" + name);
		try {
			Thread.sleep(time);
			this.cyclicBarrier.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			e.printStackTrace();
		}
		System.out.println("结束执行:" + name);
	}

	public static void main(String[] args) {
		final CyclicBarrierTest cbt = new CyclicBarrierTest(3, new Runnable() {

			@Override
			public void run() {
				System.out.println("执行数量的线程完成后执行");
			}

		});
		// 创建三个测试线程
		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				cbt.sayHello("T1", 500);
			}

		});

		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				cbt.sayHello("T2", 1000);
			}

		});

		Thread t3 = new Thread(new Runnable() {

			@Override
			public void run() {
				cbt.sayHello("T3", 2000);
			}

		});
                //启动三个线程
		t1.start();
		t2.start();
		t3.start();
	}
}

 

 

       上述代码的运行结果，应该是：

           开始执行:T1

            开始执行:T2

            开始执行:T3

            执行数量的线程完成后执行

            结束执行:T1

            结束执行:T2

            结束执行:T3

2.CountDownLatch(计数)

    CountDownLatch类是通过线程计数来实现同步的，也就是有一个计数器，在计数器未到0之前所有相关线程在指定位置都需要阻   塞，直到计数器为0的时候，所有相关线程停止阻塞，继续向下执行。需要注意的是，该同步器不能被复用，并且可以由外部事件触发。

 

public class CountDownLatchTest {
	
	private CountDownLatch countDownLatch = null;
	//构造函数，创建倒计时同步器
	//count为倒计时数
	public CountDownLatchTest(int count){
		this.countDownLatch = new CountDownLatch(count);
	}
	
	//递减计数器
	public void countDown(){
		this.countDownLatch.countDown();
		System.out.println("count:" + this.countDownLatch.getCount());
	}
	
	public void sayHello(String name, int time) {
		System.out.println("开始执行:" + name);
		try {
			Thread.sleep(time);
			this.countDownLatch.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("结束执行:" + name);
	}
	
	public static void main(String[] args) throws InterruptedException {
		final CountDownLatchTest cdl = new CountDownLatchTest(3);
		// 创建三个测试线程
		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				cdl.sayHello("T1", 50);
			}

		});

		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				cdl.sayHello("T2", 50);
			}

		});

		Thread t3 = new Thread(new Runnable() {

			@Override
			public void run() {
				cdl.sayHello("T3", 50);
			}

		});
		//启动测试线程
		t1.start();
		t2.start();
		t3.start();
		
		Thread.sleep(2000);
		//逐步递减
		cdl.countDown();
		Thread.sleep(1000);
		cdl.countDown();
		Thread.sleep(1000);
		cdl.countDown();
		Thread.sleep(1000);
	}
}

      上述代码由于线程运行的不确定性，每次的运行结果都不一样，但原则不变，例如：

 

          开始执行:T1

           开始执行:T2

           开始执行:T3

           count:2

           count:1

           count:0

           结束执行:T2

           结束执行:T3

           结束执行:T1

 

3.Exchanger(交换)

    Exchanger类用于不同线程间交换数据，并且交换过程是线程安全的，通过设置一个同步点来实现，具体代码如下：

 

public class ExchangerTest {
	private Exchanger<String> exchanger;
	
	public ExchangerTest(){
		this.exchanger = new Exchanger<String>();
	}
	
	public void method1(String name){
		System.out.println("执行Mehtod1");
		//Thread.sleep(1000);\
		String ss = name + "发送数据:123123" ;
		try {
			ss = this.exchanger.exchange(ss);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("结束Mehtod1");
	}
	
	public void method2(String name){
		System.out.println("执行Mehtod2");
		String ss = "123";
		try {
			ss = this.exchanger.exchange(ss);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("Mehotd2收到:" + ss);
		System.out.println("结束Mehtod2");
	}
	
	public static void main(String[] args) {
		final ExchangerTest et = new ExchangerTest();
		// 创建三个测试线程
		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				et.method1("T1");
			}

		});

		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				et.method2("T2");
			}

		});
		//启动测试线程
		t2.start();
		t1.start();
	}
}

 

 

        上述代码的运行结果，应该是：

          执行Mehtod2

           执行Mehtod1

           结束Mehtod1

           Mehotd2收到:T1发送数据:123123

           结束Mehtod2

 

4.SynchronousQueue(同步队列)

    该同步器是阻塞队列的一种，虽然称之为队列，但是该“队列”没有长度。使用该队列的规则是：没有存不允许取，没有取不允许存。该队列的方法很多，但一般使用较多的是put和take方法，因为这两个方法实现了阻塞方式的存取，代码如下：

 

public class SynchronousQueueTest {
	private SynchronousQueue<String> synchronousQueue;
	
	public SynchronousQueueTest(){
		//构造函数内的参数表示是否采取公平策略
		//即优先照顾等待时间比较长的线程
		//使用公平策略会影响性能
		this.synchronousQueue = new SynchronousQueue<String>(false);
	}
	
	public void put(String data){
		try {
			System.out.println("等待放入:" + data);
			this.synchronousQueue.put(data);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public String take(){
		String data = null;
		try {
			data = this.synchronousQueue.take();
			System.out.println("提取了:" + data);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return data;
	}
	
	
	public static void main(String[] args) {
		final SynchronousQueueTest sqt = new SynchronousQueueTest();
		// 创建三个测试线程
		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				sqt.put("111111");
				try {
					Thread.sleep(4000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				sqt.put("222222");
			}

		});

		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				sqt.take();
				sqt.take();
				
			}

		});
		//启动测试线程
		t1.start();
		t2.start();
	}
}

     上述代码的运行结果，应该是：

 

          等待放入:111111

           提取了:111111

           等待放入:222222

           提取了:222222

5.Semaphore(信号量)

   Semaphore类通过类似许可证的方式对同步进行管理，简单的来说，许可证的数目是一定的，想要访问，必须要获得许可证，若许可证已经用完，那么必须等待其他占用许可证的线程归还许可证后，方可得到许可从而继续执行。具体代码如下：

 

public class SemaphoreTest {
	private Semaphore semaphore;
	
	//构造函数用于创建一个信号量同步器
	//count为许可个数
	//fair表示是否采用公平策略
	public SemaphoreTest(int count,boolean fair){
		this.semaphore = new Semaphore(count,fair);
	}
	
	public void sayHello(String name){
		try {
			this.semaphore.acquire();
			System.out.println(name + "得到许可");
			Thread.sleep(5000);
			this.semaphore.release();
			System.out.println(name + "释放许可");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		final SemaphoreTest st = new SemaphoreTest(3,false);
		// 创建测试线程
		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				st.sayHello("T1");
			}

		});

		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				st.sayHello("T2");
			}

		});

		Thread t3 = new Thread(new Runnable() {

			@Override
			public void run() {
				st.sayHello("T3");
			}

		});
		
		Thread t4 = new Thread(new Runnable() {

			@Override
			public void run() {
				st.sayHello("T4");
			}

		});
		
		Thread t5 = new Thread(new Runnable() {

			@Override
			public void run() {
				st.sayHello("T5");
			}

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

    上述代码由于线程运行的不确定性，每次的运行结果都不一样，但原则不变，例如：

 

          T1得到许可

           T2得到许可

           T4得到许可

           T2释放许可

           T4释放许可

           T3得到许可

           T1释放许可

           T5得到许可

           T3释放许可

           T5释放许可

 

csyqbt001
关注
专栏目录
Java多线程同步器代码详解
08-28
Java多线程同步器在并发编程中扮演着至关重要的角色，它们帮助开发者管理线程间的协作，确保资源的正确访问和程序的顺序执行。本文将深入解析四种主要的同步器：CountDownLatch、Semaphore、Barrier和Exchanger，并...
java 实现线程同步的方式有哪些
09-05
Java中的线程同步是解决多线程环境下并发访问共享数据可能导致的数据不一致性问题的关键技术。在Java中，有多种方式可以实现线程同步，确保在任何时刻只有一个线程能够访问特定的共享资源。 1. **同步代码块 ...
java线程同步器_Java多线程同步器
weixin_42596246的博客
02-27 195
1、CountDownLatch应用场景：等待一组线程任务完成后在继续执行当前线程。用法：定义一个CountDownLatch变量latch，在当前线程中调用latch.await()方法，在要等待的一组线程中执行完后调用latch.countDown()方法，这样当该做线程都调用过latch.countDown()方法后就开始执行当前线程latch.await()后的方法。CountDownLa...
java多线程同步器
weixin_33768481的博客
12-17 146
Java中多线程开发时，离不开线程的分工协作，常用的多线程的同步器有如下几种： 1、CountDownLatch 应用场景：等待一组线程任务完成后在继续执行当前线程。 用法：定义一个CountDownLatch变量latch，在当前线程中调用latch.await()方法，在要等待的一组线程中执行完后调用latch.countDown(）方法，这样当该做线程都调用过latch.countDo...
（JUC 下典型的类）Java 并发包中线程同步器
weixin_46448719的博客
04-22 1033
文章介绍了并发包中关于线程协作的一些重要类。首先 CountDownLatch 通过计数器提供了更灵活的控制，只要检测到计数器值为 0，就可以往下执行，这相比于 join 必须等待线程执行完毕后主线程才会继续向下运行更灵活。另外，CyclicBarrier 也可以达到 CountDownLatch 的效果，但是后者在计数器值变为 0 后，就不能再被复用，而前者则可以使用 reset 方法重置后复用，前者对同一个算法但是输入参数不同的类似场景比较使用。而 Semaphore 采用了信号量递增的策略，一开始并不
Java高并发编程（二）---线程同步器
喜三仔的世界
09-04 772
从提问中发现关于线程的知识  问：同步方法和非同步方法是否可以同时调用？  答：可以。 解释：这里不贴具体代码，提示：银行如果存钱业务使用同步方法，查询余额使用非同步方法，那么就有可能产生脏读的情况，各位看官可自行编程验证。    问：一个同步方法可以调用另一个同步方法吗？  答：可以。一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到该对象的锁，也就是说，synchronized获得的锁是可...
java同步器
xixingzhe2的博客
11-17 238
描述依赖关系thenApply() 把前面异步任务的结果，交给后面的FunctionthenCompose()用来连接两个有依赖关系的任务，结果由第二个任务返回描述and聚合关系thenCombine 任务合并，有返回值thenAccepetBoth 两个任务执行完成后，将结果交给thenAccepetBoth消耗，无返回值runAfterBoth 两个任务都执行完成后，执行下一步操作（Runnable）描述or聚合关系。
深入解析Java的线程同步以及线程间通信
09-03
Java线程同步是多线程编程中的核心概念，它的目的是防止多个线程同时访问共享资源，从而避免数据不一致和竞态条件。在Java中，线程同步可以通过两种主要方式实现：同步方法和同步块。 1. **同步方法**： Java通过`...
Java线程同步Lock同步锁代码示例
08-28
Java线程同步的原理是基于监视器（Monitor）机制的。Java会为每个对象分配一个监视器，当某个对象的同步方法被多个线程调用时，该对象的监视器将负责处理这些访问的并发独占要求。当一个线程调用一个对象的同步方法...
java集合框架线程同步代码详解
08-28
下面我们将详细探讨Java集合框架中的线程同步以及ArrayList类的相关知识点。 首先，ArrayList是Java集合框架中List接口的一个实现，它基于动态数组的数据结构。ArrayList提供了添加、删除、查找和修改元素的方法，...
JAVA并发——线程同步器AQS
海晨忆的博客
07-19 436
个人博客：haichenyi.com。感谢关注 前言   每一项技术的提出都是为了解决某一个问题，带着问题来理解技术，使得印象你对这个技术的理解印象更加深刻。 并发   举个栗子：现在有一个需求，网络请求分两批（A,B两个批次），A批次并行请求，B批次串行请求按顺序一个一个请求，有一个总超时时间，B批次每一次请求都有一个超时时间，A批次并发请求先请求，在规定时间内没有返回，再开始请求B批次，谁先返回用谁的。   这个是我们项目里面简化过后的一个逻辑，实际逻辑，比这个还要复杂。怎么实现这个功能呢？   带着这
Java 线程同步器：从 synchronized、Lock 到 StampedLock
Al_assad的博客
09-07 1045
Java 线程同步器：从 synchronized、Lock 到 StampedLock     synchronized 和 lock 的对比 synchronized 关键字和 juc 中的 Lock 可以说是 Java 最为常用的线程同步器了，以下我们从多个角度来比较这两者的区别； 首先我们先看一个实际例子中的两者代码的区别： 一个线程共享对象 TimerBean publi...
Java中的线程同步
最新发布
m0_74229735的博客
07-16 452
线程的同步是为了保证多个线程按照特定的顺序、协调地访问共享资源，避免数据不一致和竞争条件等问题。
java多线程之同步计数器
jiushancunMonkeyKing的博客
06-29 924
同步计数器之--CountDownLatch    使用场景：当用户上传文件，我们可以多开几个线程来上传文件，当所有的线程上传完成后，文件才算上传完成，在此场景下可以使用CountDownLatch,当每个线程上传完成，调用CountDownLatch.countDown()使计数器减1，当计数器为0时表示文件上传完成。package com.synchronize; import java.u...
java简单的多线程同步器实现
tiger_Angle
08-23 200
同步器解释,如:跑步必须在统一起跑线出发。
java并发中的同步器
FLGB
08-08 523
是 Java 并发包中的同步器之一，用于实现一组线程在达到一个共同点之前等待彼此，并在达到共同点后继续执行。是 Java 并发包中的同步器之一，用于实现一种等待机制，允许一个或多个线程等待其他线程完成一组操作后再继续执行。当许可证数量为零时，线程需要等待，直到其他线程释放许可证。在上述示例中，我们创建了一个 CyclicBarrier 实例，初始化等待的线程数量为 3，并设置了栅栏动作。然后创建多个线程，每个线程模拟执行任务后等待其他线程达到栅栏点，当所有线程都达到栅栏点时，栅栏动作会被执行。
Java并发编程中的同步器
xxsiyao的博客
07-08 339
1. CyclicBarrier【参考文献】 和 CountDownLatch 类似 线程会等待，直到足够多线程达到了事先规定的数据。一旦触发条件，就可以进行下一步的操作 适用于线程之间相互等待处理结果就绪的场景 CyclicBarrier 可以构造一个集结点，当某一个线程执行完毕，它就会到集结点等待，直到所有线程都到了集结点，那么该栅栏就会被撤销，所有线程再统一出发，继续执行剩下的任务 用法一：等待所有人到达指定地点，再统一出发 import java.util.concurrent.BrokenBa
java并发之同步器
DengDeng_G的博客
01-12 2073
Java concurrent包中有提供多种同步器，信号量(Semaphore)、计数栓(CountDownLatch)、循环屏障(CyclicBarrier)、交换器(Exchanger)、Phaser 一、 Semaphore同步器 特征： 1. 经典的信号量，通过计数器控制对共享资源的访问 2. Semaphore(int count):创建拥有count个许可证的信号量
Java 同步器 CountDownLatch、CyclicBarrier 、Phaser、Exchanger、Semaphore
weixin_39960155的博客
03-12 399
多个线程互相等待，直到到达同一个同步点，再继续一起执行。适用于多个线程有固定的多步需要执行，线程间互相等待，当都执行完了，在一起执行下一步。它支持任务在多个点都进行同步，支持动态调整注册任务的数量。多个窗口叫号，窗口都忙时，顾客等待，有空闲时，最新等待的被通知。个线程，他不支持更多的线程之间互换数据，当线程。方法，然后以线程安全的方式交换数据，之后线程。生活中对应场景：比如运动会起跑用哪个。方法后，他会陷入阻塞状态，直到线程。获取一个许可，如果没有就等待，而。可以控同时访问的线程个数，通过。
Java线程同步示例解析
"java线程同步的例子.doc" Java线程同步是多线程编程中一个关键的概念，用于解决并发访问共享资源时可能出现的数据不一致问题。在Java中，线程同步可以通过多种方式实现，包括`synchronized`关键字、`wait()`和`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值