多线程-CountDownLatch,CyclicBarrier,Semaphore,Exchanger,Phaser
CountDownLatch
一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。用给定的计数初始化CountDownLatch。调用countDown()计数减一,当计数到达零之前await()方法会一直阻塞,计数无法被重置。
public class CountDownLatch {
private final Sync sync;
public CountDownLatch(int count);
public void countDown() {
sync.releaseShared(1);
}
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
}
CountDownLatch中主要有countDown()和await()方法。
countDown()递减计数,如果计数达到零,则是否所有等待的线程。
1. 如果当前计数大于零,则计数减一;
2. 如果减一之后计数为零,则重新调度所有等待该计数为零的线程;
3. 如果计数已经为零,则不发生任何操作;
await()使当前线程在计数为零之前一直阻塞,除非线程被中断或超出指定的等待时间;
如果计数为零,则立刻返回true
在进入此方法时,当前线程已经设置了中断状态或在等待时被中断,则抛出InterruptedException异常,并且清除当前线程的中断状态。如果超出了指定等待时间,则返回false,如果该时间小于等于零,则此方法根本不会等待。
package org.github.lujiango; import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit; public class Test16 { public static void main(String[] args) throws InterruptedException {
final CountDownLatch begin = new CountDownLatch(1);
final CountDownLatch end = new CountDownLatch(10);
final ExecutorService exec = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
final int no = i + 1;
Runnable run = new Runnable() {
@Override
public void run() {
try {
begin.await();
TimeUnit.MILLISECONDS.sleep((long) (Math.random() * 10000));
System.out.println("No." + no + " arrived");
} catch (Exception e) { } finally {
end.countDown();
}
}
};
exec.submit(run);
} System.out.println("Game start");
begin.countDown();
end.await();
System.out.println("Game over");
exec.shutdown();
} }
CyclicBarrier
一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点。在涉及一组固定大小的线程的程序中,这些线程必须不时的互相等待。
package org.github.lujiango; import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit; public class Test16 { public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
final CyclicBarrier end = new CyclicBarrier(10);
final ExecutorService exec = Executors.newFixedThreadPool(10);
System.out.println("Game start");
for (int i = 0; i < 10; i++) {
final int no = i + 1;
Runnable run = new Runnable() {
@Override
public void run() {
try {
end.await();
TimeUnit.MILLISECONDS.sleep((long) (Math.random() * 10000));
System.out.println("No." + no + " arrived");
} catch (Exception e) { } finally {
}
}
};
exec.submit(run);
}
System.out.println("Game over");
exec.shutdown(); } }
需要所有的子任务都完成时,才执行主任务,这个时候可以选择使用CyclicBarrier。
Semaphore
一个计数信号量,信号量维护了一个许可集,在许可可用之前会阻塞每一个acquire(),然后获取该许可。每个release()释放许可,从而可能释放一个正在阻塞的获取者。
Semaphore只对可用许可的号码进行计数,并采取相应的行动,拿到信号的线程可以进入代码,否则就等待。
package org.github.lujiango; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit; public class Test17 { public static void main(String[] args) {
ExecutorService exec = Executors.newCachedThreadPool();
final Semaphore semp = new Semaphore(5);
for (int i = 0; i < 20; i++) {
final int no = i;
Runnable run = new Runnable() { @Override
public void run() {
try {
semp.acquire();
System.out.println("Accessing: " + no);
TimeUnit.MILLISECONDS.sleep((long) (Math.random() * 10000));
} catch (Exception e) { } finally {
semp.release();
}
}
};
exec.submit(run);
}
exec.shutdown();
} }
Exchanger
Exchanger可以在两个线程之间交换数据,只能在两个线程,不支持更多的线程之间互换数据。
当线程A调用Exchanger对象的exchage()方法后,会阻塞;直到B线程也调用exchange()方法,然后线程以安全的方式交换数据,之后A和B线程继续执行。
package org.github.lujiango; import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Exchanger; public class Test18 { public static void main(String[] args) {
Exchanger<List<Integer>> ex = new Exchanger<List<Integer>>();
new A(ex).start();
new B(ex).start();
} } class A extends Thread {
List<Integer> list = new ArrayList<Integer>();
Exchanger<List<Integer>> ex; public A(Exchanger<List<Integer>> ex) {
this.ex = ex;
} @Override
public void run() {
Random random = new Random();
for (int i = 0; i < 10; i++) {
list.clear();
list.add(random.nextInt(10));
list.add(random.nextInt(10));
list.add(random.nextInt(10));
try {
list = ex.exchange(list);
} catch (Exception e) { }
}
}
} class B extends Thread {
List<Integer> list = new ArrayList<Integer>();
Exchanger<List<Integer>> ex; public B(Exchanger<List<Integer>> ex) {
this.ex = ex;
} @Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
list = ex.exchange(list);
} catch (Exception e) { }
System.out.println(list);
}
}
}
Phaser
Phaser是一个灵活的线程同步工具,它包含了CountDownLatch和CyclicBarrier的相关功能。
CountDownLatch的countDown()和await()可以通过Phaser的arrive()和awaitAdvance(int n)代替
而CyclicBarrier的await可以使用Phaser的arriveAndAwaitAdvance()方法代替
用Phaser代替CountDownLatch:
package org.github.lujiango; import java.util.concurrent.Phaser;
import java.util.concurrent.TimeUnit; public class Test19 { public static void main(String[] args) throws InterruptedException {
final Phaser latch = new Phaser(10);
for (int i = 1; i <= 10; i++) {
final int id = i;
Thread t = new Thread(new Runnable() { @Override
public void run() {
try {
TimeUnit.SECONDS.sleep((long) (Math.random() * 10));
System.out.println("thread: " + id + " is running");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
latch.arrive();
}
}
});
t.start();
}
latch.awaitAdvance(latch.getPhase());
System.out.println("all thread has run"); } }
package org.github.lujiango; import java.util.concurrent.Phaser;
import java.util.concurrent.TimeUnit; public class Test19 { public static void main(String[] args) throws InterruptedException {
final Phaser latch = new Phaser(10);
for (int i = 1; i <= 10; i++) {
final int id = i;
Thread t = new Thread(new Runnable() { @Override
public void run() {
try {
TimeUnit.SECONDS.sleep((long) (Math.random() * 10));
latch.arriveAndAwaitAdvance(); // 所有线程都执行到这里,才会继续执行,否则全部阻塞
System.out.println("thread: " + id + " is running");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
latch.arrive();
}
}
});
t.start();
}
} }
多线程-CountDownLatch,CyclicBarrier,Semaphore,Exchanger,Phaser的更多相关文章
- Java中的4个并发工具类 CountDownLatch CyclicBarrier Semaphore Exchanger
在 java.util.concurrent 包中提供了 4 个有用的并发工具类 CountDownLatch 允许一个或多个线程等待其他线程完成操作,课题点 Thread 类的 join() 方法 ...
- 并发工具类的使用 CountDownLatch,CyclicBarrier,Semaphore,Exchanger
1.CountDownLatch 允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助. A CountDownLatch用给定的计数初始化. await方法阻塞,直到由于countDo ...
- 并发包下常见的同步工具类详解(CountDownLatch,CyclicBarrier,Semaphore)
目录 1. 前言 2. 闭锁CountDownLatch 2.1 CountDownLatch功能简介 2.2 使用CountDownLatch 2.3 CountDownLatch原理浅析 3.循环 ...
- CountDownLatch/CyclicBarrier/Semaphore 使用过吗?
CountDownLatch/CyclicBarrier/Semaphore 使用过吗?下面详细介绍用法: 一,(等待多线程完成的)CountDownLatch 背景; countDownLatch ...
- 并发包下常见的同步工具类(CountDownLatch,CyclicBarrier,Semaphore)
在实际开发中,碰上CPU密集且执行时间非常耗时的任务,通常我们会选择将该任务进行分割,以多线程方式同时执行若干个子任务,等这些子任务都执行完后再将所得的结果进行合并.这正是著名的map-reduce思 ...
- Java并发编程工具类 CountDownLatch CyclicBarrier Semaphore使用Demo
Java并发编程工具类 CountDownLatch CyclicBarrier Semaphore使用Demo CountDownLatch countDownLatch这个类使一个线程等待其他线程 ...
- 多线程中 CountDownLatch CyclicBarrier Semaphore的使用
CountDownLatch 调用await()方法的线程会被挂起,它会等待直到count值为0才继续执行.也可以传入时间,表示时间到之后,count还没有为0的时候,就会继续执行. package ...
- 高并发第十单:J.U.C AQS(AbstractQueuedSynchronizer) 组件:CountDownLatch. CyclicBarrier .Semaphore
这里有一篇介绍AQS的文章 非常好: Java并发之AQS详解 AQS全名:AbstractQueuedSynchronizer,是并发容器J.U.C(java.lang.concurrent)下lo ...
- CountDownLatch CyclicBarrier Semaphore 比较
document CountDownLatch A synchronization aid that allows one or more threads to wait until a set of ...
- 等待某(N)个线程执行完再执行某个线程的几种方法(Thread.join(),CountDownLatch,CyclicBarrier,Semaphore)
1.main线程中先调用threadA.join() ,再调用threadB.join()实现A->B->main线程的执行顺序 调用threadA.join()时,main线程会挂起,等 ...
随机推荐
- mysql错误 Access denied for user 'root'@'xxx.xxx.xxx.xxx' (using password: YES)
mysql -u root -p Aaa111222333 grant all privileges on *.* to root@'%' identified by 'aaa111222333; Q ...
- 开源轻量级即时通讯技术 MobileIMSDK 的常见问题解答
本帖最后由 茜茜asa 于 2015-12-14 17:50 编辑 申明:MobileIMSDK 目前为个人原创开源工程且已发布,现整理了一些有关MobileIMSDK的常见的问题,希望对需要的人有用 ...
- 关停后Bitfinex放贷初探
据说Bitfinex放贷平均日息可达0.1%,现在就此做一番调研: 真的很先进,利率也像牌价一样挂卖: 1.美元利率为0.06%/天 2.美元利率最高,数币较低 参考资料:不买比特币也能赚钱,Bitf ...
- Linux音频驱动简述
一.数字音频 音频信号是一种连续变化的模拟信号,但计算机仅仅能处理和记录二进制的数字信号.由自然音源得到的音频信号必须经过一定的变换,成为数字音频信号之后,才干送到计算机中作进一步的处理. 数字音频系 ...
- iOS: 工具栏控件UIToolBar和工具栏按钮控件UIBarButtonItem的使用
一.工具栏控件:UIToolBar:UIView 介绍: ToolBar工具栏是视图View的属性,可以在工具栏上添加工具栏按钮Bar Button Item(可以是自定义的Custom.也可以是系统 ...
- phpMyAdmin配置
一: (1):下载phpmyadmin,在官方最好 (2):个人建议最好将其安装在apache的htdocs文件中(apache的默认虚拟目录,或web访问目录) ...
- 详解java中的数据结构
线性表,链表,哈希表是常用的数据结构,在进行Java开发时,JDK已经为我们提供了一系列相应的类来实现基本的数据结构.这些类均在java.util包中.本文试图通过简单的描述,向读者阐述各个类的作用以 ...
- phantomjs 抓取房产信息
抓取https://sf.taobao.com/item_list.htm信息 driver=webdriver.PhantomJS(service_args=['--ssl-protocol=any ...
- Spring框架学习(2)IOC学习
内容源自:IOC理解 spring ioc注入的三种方式 ioc工厂bean深入理解 耦合性,在java中表现为类之间的关系,耦合性强说明类之间的依赖关系强: 侵入性:框架对代码的侵入: 在传统 ...
- java中Token验证
什么是Token:它是一个令牌,随机不可预测的. 为什么需要使用Token: 1,防止表单的重复提交 2:,防止跨站点的请求伪造 Token的使用流程是:首先在服务器端生成一个随机的token值并在服 ...