【Java并发】几个常用API
并发包
(计数器)CountDownLatch
CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。
import java.util.concurrent.CountDownLatch;
public class CountDownlatchTest {
public static void main(String[] args) {
CountDownLatch count = new CountDownLatch(2);
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "开始执行-->" + System.currentTimeMillis());
count.countDown();
System.out.println(Thread.currentThread().getName() + "结束执行-->" + System.currentTimeMillis());
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "开始执行-->" + System.currentTimeMillis());
count.countDown();
System.out.println(Thread.currentThread().getName() + "结束执行-->" + System.currentTimeMillis());
}
}).start();
try {
count.await(); // 当Count减为0 时，执行后面的代码
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("两个子线程执行完毕....");
System.out.println("主线程继续执行.....");
for (int i = 0; i < 10; i++) {
System.out.println("main,i:" + i);
}
}
}
执行结果
Thread-0开始执行-->1564281731639
Thread-0结束执行-->1564281731639
Thread-1开始执行-->1564281731639
Thread-1结束执行-->1564281731639
两个子线程执行完毕....
主线程继续执行.....
main,i:0
main,i:1
main,i:2
main,i:3
main,i:4
main,i:5
main,i:6
main,i:7
main,i:8
main,i:9
(屏障)CyclicBarrier
CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续。
CyclicBarrier就象它名字的意思一样，可看成是个障碍， 所有的线程必须到齐后才能一起通过这个障碍。
CyclicBarrier初始时还可带一个Runnable的参数， 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierTest {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
for (int i = 0; i < 5; i++) {
Writer writer = new Writer(cyclicBarrier);
writer.start();
}
}
}
class Writer extends Thread {
private CyclicBarrier cyc;
public Writer(CyclicBarrier cyc) {
this.cyc = cyc;
}
@Override
public void run() {
System.out.println("线程" + Thread.currentThread().getName() + ",正在写入数据");
try {
Thread.sleep(3000);
} catch (Exception e) {
// TODO: handle exception
}
System.out.println("线程" + Thread.currentThread().getName() + ",写入数据成功.....");
try {
cyc.await();
} catch (Exception e) {
}
System.out.println("所有线程执行完毕..........");
}
}
执行结果
线程Thread-0,正在写入数据
线程Thread-2,正在写入数据
线程Thread-1,正在写入数据
线程Thread-3,正在写入数据
线程Thread-4,正在写入数据
线程Thread-3,写入数据成功.....
线程Thread-1,写入数据成功.....
线程Thread-0,写入数据成功.....
线程Thread-2,写入数据成功.....
线程Thread-4,写入数据成功.....
所有线程执行完毕..........
所有线程执行完毕..........
所有线程执行完毕..........
所有线程执行完毕..........
所有线程执行完毕..........
(计数信号量)Semaphore
Semaphore是一种基于计数的信号量。它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞。
Semaphore可以用来构建一些对象池，资源池之类的，比如数据库连接池，我们也可以创建计数为1的Semaphore，将其作为一种类似互斥锁的机制，这也叫二元信号量，表示两种互斥状态。它的用法如下：
semp.availablePermits()//函数用来获取当前可用的资源数量
semp.acquire(); //申请资源
semp.release();// 释放资源
// 创建一个计数阈值为5的信号量对象
// 只能5个线程同时访问
Semaphore semp = new Semaphore(5);
try {
// 申请许可
semp.acquire();
try {
// 业务逻辑
}catch (Exception e){
} finally {
// 释放许可
semp.release();
}
}catch(InterruptedException e){ }
案例:
需求:
一个商店只有3个抓娃娃机，但是有10个人要来抓娃娃，那怎么办？假设10的人的编号分别为1-10，并且1号先到，10号最后到。那么1-3号来的时候必然有可用抓娃娃机，可以开始抓娃娃，4号来的时候需要看看前面3人是否有人抓完了，如果有人抓完，4号就开始抓娃娃，否则等待。同样的道理，4-10号也需要等待正在抓娃娃的人抓完才能抓，并且谁先开始抓娃娃要看等待的人是否有素质，是否能遵守先来先用抓玩玩机的规则。
代码:
import java.util.Random;
import java.util.concurrent.Semaphore;
public class SemaphoreTest {
public static void main(String[] args) {
Semaphore semp = new Semaphore(3);
for (int i = 0; i <= 10; i++) {
CatchDollThread thread = new CatchDollThread("thread-" + i, semp);
thread.start();
}
}
}
class CatchDollThread extends Thread {
private String name;
private Semaphore cad;
public CatchDollThread(String name, Semaphore cad) {
this.name = name;
this.cad = cad;
}
@Override
public void run() {
int availablePermits = cad.availablePermits();
if (availablePermits > 0) {
System.out.println(this.name + "说: 有空闲的抓娃娃机");
} else {
System.out.println(this.name + "说: 没有空闲的娃娃机了");
}
try {
// 申请资源
cad.acquire();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.name + "开始抓娃娃" + ",此时空闲的机器:" + cad.availablePermits());
try {
Thread.sleep(new Random().nextInt(1000));
} catch (Exception e) {
}
System.out.println(this.name + "抓完娃娃");
// 释放资源
cad.release();
}
}
执行结果
thread-1说: 有空闲的抓娃娃机
thread-3说: 有空闲的抓娃娃机
thread-2说: 有空闲的抓娃娃机
thread-0说: 有空闲的抓娃娃机
thread-4说: 没有空闲的娃娃机了
thread-2开始抓娃娃,此时空闲的机器:0
thread-3开始抓娃娃,此时空闲的机器:1
thread-1开始抓娃娃,此时空闲的机器:2
thread-5说: 没有空闲的娃娃机了
thread-6说: 没有空闲的娃娃机了
thread-7说: 没有空闲的娃娃机了
thread-8说: 没有空闲的娃娃机了
thread-9说: 没有空闲的娃娃机了
thread-10说: 没有空闲的娃娃机了
thread-1抓完娃娃
thread-0开始抓娃娃,此时空闲的机器:0
thread-3抓完娃娃
thread-4开始抓娃娃,此时空闲的机器:0
thread-4抓完娃娃
thread-5开始抓娃娃,此时空闲的机器:0
thread-0抓完娃娃
thread-6开始抓娃娃,此时空闲的机器:0
thread-2抓完娃娃
thread-7开始抓娃娃,此时空闲的机器:0
thread-6抓完娃娃
thread-8开始抓娃娃,此时空闲的机器:0
thread-5抓完娃娃
thread-9开始抓娃娃,此时空闲的机器:0
thread-8抓完娃娃
thread-10开始抓娃娃,此时空闲的机器:0
thread-10抓完娃娃
thread-7抓完娃娃
thread-9抓完娃娃
************ **供自己学习查阅使用(我只想静静的写篇博客，自我总结下[手动狗头]) by Pavel** *********
