java 同步器

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

信号量

如果学过操作系统这门课应该对信号量这个名词相当熟悉，其中Mutex互斥锁更是操作系统中用来访问临界资源的用例经典。

其实包括p操作和v操作

void p(s){

while(s<=0);

s--;

}

void V(s){

s++;

}

倒计时门栓

让一个线程集等待直到计数变为0，倒计时门栓是一次性的。一旦计数器为0，就不能再用了

当一个或者 多个线程需要等待直到指定数目的事件发生时使用。

一个人要完成一些任务，但是需要些数据，此时这个人准备好后（就绪）在门外等着，另外几个人在里面准备数据。这个人数取决于new门栓是的参数，当数据准备好后调用countdown()，那个要完成要任务的就可以开始工作啦、跟下面的障栅是几乎一样的。所以看下面就应该能明白我要说的了。

障栅

很形象的名字，可以把线程比喻成一队运动员，当最先一个运动员跑到终点时先等待后边的。当所有运动员都跑到这个障栅时，然后再一起跑。期间如果任何一个线程在等待时候离开的障栅，会破坏障栅，其它线程会报异常错误。
书上说使用场景 是当大量的线程需要在它们结果可用之前完成时。 
package test;

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

public class Demo {
	private static int num = 0;

	public static void main(String[] Args) {
		new Demo().test();
	}

	private void test() {
		Runnable comtask = new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("完成啦完成啦");
			}
		};
		CyclicBarrier cb = new CyclicBarrier(3, comtask);
		thread t1 = new thread(cb);
		thread t2 = new thread(cb);
		thread t3 = new thread(cb);
		t1.start();
		t2.start();
		t3.start();
		System.out.println(cb.getNumberWaiting());
	}

	class thread extends Thread {
		private CyclicBarrier cb;

		public thread(CyclicBarrier cb) {
			super();
			this.cb = cb;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub
			try {
				cb.await();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (BrokenBarrierException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

输出结果：
完成啦完成啦
0
障栅是可以重用的，之后调用 cb.reset();即可完成重置，而倒计时门栓只可以用一次。

交换器

交换嘛，两个线程在同一个缓冲区的两个实例上工作的时候，就可以用交换器，如，一个人在做饭，一个人在吃饭。那么这个碗就是缓冲区，做完了，吃完了。之后交换这个碗。就是一个线程在消耗数据，一个在准备数据。又比如一个线程在根据数据进行计算，一个线程在收集新的数据。 
package test;

import java.util.concurrent.Exchanger;

public class Demo {
	private static int num = 0;

	public static void main(String[] Args) {
		new Demo().test();
	}

	private void test() {
		Exchanger<Integer> ec = new Exchanger<Integer>();
		threadcook tc = new threadcook(ec);
		threadeat te = new threadeat(ec);
		tc.start();
		te.start();
	}

	class threadcook extends Thread {
		private Exchanger<Integer> ec;

		public threadcook(Exchanger<Integer> ec) {
			super();
			this.ec = ec;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (true) {
				int result = 0;
				for (int i = 0; i < 100; i++) {
					result += i;
				}
				try {
					ec.exchange(result);

				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("我是做饭的内个~：" + result);
			}

		}
	}

	class threadeat extends Thread {
		private Exchanger<Integer> ec;

		public threadeat(Exchanger<Integer> ec) {
			super();
			this.ec = ec;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (true) {
				int result = 0;
				try {
					ec.exchange(result);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("我是吃饭的内个~：" + result);
			}

		}
	}

}

结果：
我是做饭的内个~：4950
我是吃饭的内个~：0
我是吃饭的内个~：0
我是做饭的内个~：4950
我是吃饭的内个~：0
我是做饭的内个~：4950
我是吃饭的内个~：0
我是做饭的内个~：4950
我是吃饭的内个~：0
我是吃饭的内个~：0
我是做饭的内个~：4950
我是做饭的内个~：4950
我是吃饭的内个~：0
我是做饭的内个~：4950
我是吃饭的内个~：0
我是做饭的内个~：4950
我是吃饭的内个~：0
我是做饭的内个~：4950

好吧要吃饭的那个估计已经饿死了。。。那么问题出在哪呢。。

哦这个点找错了，交换之后获得的对象是exchange()这个方法的返回值，并不会重新对result赋值。所以改过之后 

package test;

import java.util.concurrent.Exchanger;

import javax.xml.ws.spi.Invoker;

public class Demo {
	private static int num = 0;

	public static void main(String[] Args) {
		new Demo().test();
	}

	private void test() {
		Exchanger<Integer> ec = new Exchanger<Integer>();
		threadcook tc = new threadcook(ec);
		threadeat te = new threadeat(ec);
		tc.start();
		te.start();

	}

	class threadcook extends Thread {
		private Exchanger<Integer> ec;

		public threadcook(Exchanger<Integer> ec) {
			super();
			this.ec = ec;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub
			int result = 0;
			for (int i = 0; i < 100; i++) {
				result += i;
			}
			try {
				System.out.println("我是做饭的内个~：" + ec.exchange(result));

			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();

			}
		}
	}

	class threadeat extends Thread {
		private Exchanger<Integer> ec;

		public threadeat(Exchanger<Integer> ec) {
			super();
			this.ec = ec;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub

			int result = 0;
			try {
				System.out.println("我是吃饭的内个~：" + ec.exchange(result));
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
	}

}

结果 ：

我是吃饭的内个~：4950
我是做饭的内个~：0

这就对 了~~


同步队列

跟交换器很像，不过这次是单向的，一个线程在向队列里边压数据 ，另一个在取，不过这个交换器的不同就是这个可以是多个线程之间的协作，不像交换器只能支持两个线程。
为了方便我们将上一个例子改一下就好了啦。
为了体现出是队列，我们取100次却只压入10次队列。 

package test;

import java.util.concurrent.Exchanger;
import java.util.concurrent.SynchronousQueue;

import javax.xml.ws.spi.Invoker;

public class Demo {
	private static int num = 0;

	public static void main(String[] Args) {
		new Demo().test();
	}

	private void test() {
		SynchronousQueue<Integer> sq = new SynchronousQueue<Integer>();
		threadcook tc = new threadcook(sq);
		threadeat te = new threadeat(sq);
		tc.start();
		te.start();

	}

	class threadcook extends Thread {
		private SynchronousQueue<Integer> sq;

		public threadcook(SynchronousQueue<Integer> sq) {
			super();
			this.sq = sq;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub
			for (int i = 0; i < 100; i++) {
				try {
					System.out.println(sq.take());
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}

		}
	}

	class threadeat extends Thread {
		private SynchronousQueue<Integer> sq;

		public threadeat(SynchronousQueue<Integer> sq) {
			super();
			this.sq = sq;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub
			for (int i = 0; i < 10; i++) {
				try {
					sq.put(i);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}

		}
	}

}
结果：
0
1
2
3
4
5
6
7
8
9
喵~跟预计的一样。好的呢，今天就到这里了。





Winney_x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java.util.Concurrent.Exchanger 源码
weixin_34324081的博客
11-21 198
2019独角兽企业重金招聘Python工程师标准>>> ...
java并发中的同步器
FLGB
08-08 368
是 Java 并发包中的同步器之一，用于实现一组线程在达到一个共同点之前等待彼此，并在达到共同点后继续执行。是 Java 并发包中的同步器之一，用于实现一种等待机制，允许一个或多个线程等待其他线程完成一组操作后再继续执行。当许可证数量为零时，线程需要等待，直到其他线程释放许可证。在上述示例中，我们创建了一个 CyclicBarrier 实例，初始化等待的线程数量为 3，并设置了栅栏动作。然后创建多个线程，每个线程模拟执行任务后等待其他线程达到栅栏点，当所有线程都达到栅栏点时，栅栏动作会被执行。
java同步器
最新发布
xixingzhe2的博客
11-17 106
描述依赖关系thenApply() 把前面异步任务的结果，交给后面的FunctionthenCompose()用来连接两个有依赖关系的任务，结果由第二个任务返回描述and聚合关系thenCombine 任务合并，有返回值thenAccepetBoth 两个任务执行完成后，将结果交给thenAccepetBoth消耗，无返回值runAfterBoth 两个任务都执行完成后，执行下一步操作（Runnable）描述or聚合关系。
Java中都有哪些同步器?（全面）
zy1992As的博客
04-06 301
CyclicBarrier的使用需要指定参与线程的数量，并通过await()方法等待所有线程到达屏障点，同时通过reset()方法将屏障重置，可以用于多次使用。在Java中，使用synchronized关键字可以对代码块或方法进行同步，使得在同一时刻只有一个线程可以执行该代码块或方法。以上是Java中常用的同步器，不同的同步器有着不同的适用场景和使用方式，需要根据实际情况选择合适的同步器进行使用。Condition是一个条件变量，它可以和Lock一起使用，可以实现更加灵活的线程同步。
Java 并发包锁实现的精髓----队列同步器（AbstractQueuedSynchronizer）
知识共享，你我皆是知识的搬运工
08-15 273
队列同步器理解
java 同步器SynchronousQueue详解及实例
08-30
主要介绍了java 同步器SynchronousQueue详解及实例的相关资料,需要的朋友可以参考下
Java多线程同步器代码详解
08-28
主要介绍了Java多线程同步器代码详解，文章分别介绍了是CountDownLatch，Semaphore，Barrier和Exchanger以及其相关代码示例，具有一定参考价值，需要的朋友可以了解下。
java同步大杀器concurrent 包
11-05
java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大...
java同步开篇入门简单介绍
08-26
java中的CountDownLatch、Semaphore、CyclicBarrier这些类又不属于锁，它们和锁又有很多共同点，都是为了协同多线程的执行，都是一种同步器，所以这里就借用同步来取名字了，也就是“同步系列”的来源。下面小编来...
java并发编程之同步器代码示例
08-28
主要介绍了java并发编程之同步器代码示例，分享了相关代码，具有一定参考价值，需要的朋友可以了解下。
java并发编程之同步器
lklinkang的专栏
11-20 7019
从java5开始juc包为我们提供了很多方便使用的同步器类：    CountDownLatch是一个同步辅助类，在完成一组正在其他线程中执行的操作前需要一个或多个其他的线程处于阻塞状态时我们可以使用它，如田径比赛中，将每一名运动员看做一个工作线程，成绩记录员看做另一线程，显然成绩记录员开始记录员开始记录成绩前需要所有的运动员都先做好比赛准备并且同时开始起跑，我们需要就最后参赛者所的成绩得出一个
Java高级：条件队列与同步器Synchronizer的原理+AQS的应用
qq3164069700的博客
12-24 694
14.构建自定义的同步工具 类库中包含了许多存在状态依赖性的类，例如 FutureTask ， Semaphore和 BlockingQueue等。在这些类中的一些操作中有着基于状态的前提条件，例如，不能从一个空的队列中删除元素，或者获取一个尚未结束的任务的计算结果，在这些操作可以执行之前，必须等到队列进入 “非空 ”状态，或者任务进入 “已完成 ”状态。 创建状态依赖类的最简单方法通常是在类库中现有的状态依赖类的基础上进行构造。本章将介绍实现状态依赖性的各种选择，以及在使用平台提供的状态依赖性机制时需
java简单的多线程同步器实现
tiger_Angle
08-23 171
同步器解释,如:跑步必须在统一起跑线出发。
JAVA并发基础: 同步器的使用
菲购程小序的专栏
09-18 1262
文章目录 前言 一、什么是同步器？ 二、同步器的使用 1.信号量 2.倒计时门栓 总结 前言 Semaphore、CountDownLatch、CyclicBarrier、Exchanger、Phaser 信号量、倒计时门栓、循环屏障、交换器、移相器 一、什么是同步器？ 线程之间相互合作时，需要用到同步器来完成同步，java.util.concurrent包提供了几个能帮助我们管理相互合作的线程集的类。这些机制具有为线程之间的公用集结点提供“预置功能”，这句话通俗理...
java的队列同步器AbstractQueuedSynchronizer（AQS）
weixin_41612174的博客
06-17 290
AQS定义 队列同步器AbstractQueuedSynchronizer（以下简称同步器），是用来构建锁或者其他同步组件的基础框架，它使用了一个int成员变量表示同步状态，通过内置的FIFO双端队列来完成资获取线程的排队工作。 head指向第一个节点，tail指向最后一个节点 节点状态 CANCELLED，值为1，由于在同步队列中等待的线程等待超时或者被中断，需要从同步队列中取消等待，节点进人该状态将不会变化 SIGNAL，值为-1，后继节点的线程处于等待状态，而当前节点的线程如果释放了同步状态或者被
Java多线程（3）----浅谈队列同步器（AQS）
cb的博客
05-24 241
浅谈队列同步器AQS
Java并发编程解析 | 解析AQS基础同步器的设计与实现
java_lujj的博客
09-09 333
在Java领域中，我们可以将锁大致分为基于Java语法层面(关键词)实现的锁和基于JDK层面实现的锁。在Java领域中, 尤其是在并发编程领域，对于多线程并发执行一直有两大核心问题：同步和互斥。互斥(Mutual Exclusion)：一个公共资源同一时刻只能被一个进程或线程使用，多个进程或线程不能同时使用公共资源。即就是同一时刻只允许一个线程访问共享资源的问题。同步(Synchronization)：两个或两个以上的进程或线程在运行过程中协同步调，按预定的先后次序运行。
java同步器有哪些_Java 队列同步器 AQS
weixin_42391580的博客
03-02 203
本文部分摘自《Java 并发编程的艺术》概述队列同步器 AbstractQueuedSynchronize(以下简称同步器)，是用来构建锁(Lock)或者其他同步组件(JUC 并发包)的基础框架，它使用了一个 int 成员变量表示同步状态，通过内置的 FIFO 队列来完成资源获取线程的排队工作同步器的主要使用方式是继承，子类通过继承同步器并实现它的抽象方法来管理同步状态，子类推荐被定义为自定义同步...
java同步器作用_Java 中的同步器
weixin_32581787的博客
02-28 340
CountDownLatchCyclicBarrierSemaphoreCountDownLatch1. CountDownLatch 的使用private void countDownTest() {// 1. 首先我们声明一个CountDownLatch实例，参数为我们需要同步的线程个数final CountDownLatch countDownLatch = new CountDownLat...
java同步方法关键字
05-05
在Java中，每个对象都会有一个锁（也称为监视器）。当一个线程要访问一个对象的同步方法时，它必须先获得这个对象的锁。如果这个锁已经被其他线程持有，那么这个线程就会阻塞，直到这个锁被释放为止。 可以将...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值