并发工具
(计数器)CountDownLatch
CountDownLatch 类位于java.util.concurrent包下,利用它可以实现类似计数器的功能。比如有一个任务A,它要等待其他4个任务执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了。CountDownLatch是通过一个计数器来实现的,计数器的初始值为线程的数量。每当一个线程完成了自己的任务后,计数器的值就会减1。当计数器值到达0时,它表示所有的线程已经完成了任务,然后在闭锁上等待的线程就可以恢复执行任务。
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(2);
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ",子线程开始执行...");
countDownLatch.countDown();
System.out.println(Thread.currentThread().getName() + ",子线程结束执行...");
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ",子线程开始执行...");
countDownLatch.countDown();//计数器值每次减去1
System.out.println(Thread.currentThread().getName() + ",子线程结束执行...");
}
}).start();
countDownLatch.await();// 減去为0,恢复任务继续执行
System.out.println("两个子线程执行完毕....");
System.out.println("主线程继续执行.....");
for (int i = 0; i <10; i++) {
System.out.println("main,i:"+i);
}
}
(屏障)CyclicBarrier
CyclicBarrier初始化时规定一个数目,然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时,所有进入等待状态的线程被唤醒并继续。
CyclicBarrier就象它名字的意思一样,可看成是个障碍, 所有的线程必须到齐后才能一起通过这个障碍。
CyclicBarrier初始时还可带一个Runnable的参数, 此Runnable任务在CyclicBarrier的数目达到后,所有其它线程被唤醒前被执行。
class Writer extends Thread {
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier){
this.cyclicBarrier=cyclicBarrier;
}
@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 {
cyclicBarrier.await();
} catch (Exception e) {
}
System.out.println("所有线程执行完毕..........");
}
}
public class Test001 {
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();
}
}
}
(计数信号量)Semaphore
Semaphore是一种基于计数的信号量。它可以设定一个阈值,基于此,多个线程竞争获取许可信号,做自己的申请后归还,超过阈值后,线程申请许可信号将会被阻塞。Semaphore可以用来构建一些对象池,资源池之类的,比如数据库连接池,我们也可以创建计数为1的Semaphore,将其作为一种类似互斥锁的机制,这也叫二元信号量,表示两种互斥状态。它的用法如下:
availablePermits函数用来获取当前可用的资源数量
wc.acquire(); //申请资源
wc.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-10号也需要等待正在上厕所的人出来后才能进去,并且谁先进去这得看等待的人是否有素质,是否能遵守先来先上的规则。
代码:
class ThradDemo001 extends Thread {
private String name;
private Semaphore wc;
public ThradDemo001(String name, Semaphore wc) {
this.name = name;
this.wc = wc;
}
@Override
public void run() {
// 剩下的资源
int availablePermits = wc.availablePermits();
if (availablePermits > 0) {
System.out.println(name + "天助我也,终于有茅坑了.....");
} else {
System.out.println(name + "怎么没有茅坑了...");
}
try {
// 申请资源
wc.acquire();
} catch (InterruptedException e) {
}
System.out.println(name + "终于上厕所啦.爽啊" + ",剩下厕所:" + wc.availablePermits());
try {
Thread.sleep(new Random().nextInt(1000));
} catch (Exception e) {
// TODO: handle exception
}
System.out.println(name + "厕所上完啦!");
// 释放资源
wc.release();
}
}
public class TestSemaphore {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(3);
for (int i = 1; i <= 10; i++) {
ThradDemo001 thradDemo001 = new ThradDemo001("第" + i + "个人", semaphore);
thradDemo001.start();
}
}
}
原子类
java.util.concurrent.atomic包:原子类的小工具包,支持在单个变量上解除锁的线程安全编程
原子变量类相当于一种泛化的 volatile 变量,能够支持原子的和有条件的读-改-写操作。AtomicInteger 表示一个int类型的值,并提供了 get 和 set 方法,这些 Volatile 类型的int变量在读取和写入上有着相同的内存语义。它还提供了一个原子的 compareAndSet 方法(如果该方法成功执行,那么将实现与读取/写入一个 volatile 变量相同的内存效果),以及原子的添加、递增和递减等方法。AtomicInteger 表面上非常像一个扩展的 Counter 类,但在发生竞争的情况下能提供更高的可伸缩性,因为它直接利用了硬件对并发的支持。
常用原子类
Java中的原子操作类大致可以分为4类:原子更新基本类型、原子更新数组类型、原子更新引用类型、原子更新属性类型。这些原子类中都是用了无锁的概念,有的地方直接使用CAS操作的线程安全的类型。
AtomicBoolean
AtomicInteger
AtomicLong
AtomicReference
public class Test implements Runnable {
private static Integer count = 1;
private static AtomicInteger atomic = new AtomicInteger();
@Override
public void run() {
while (true) {
int count = getCountAtomic();
System.out.println(count);
if (count >= 150) {
break;
}
}
}
public synchronized Integer getCount() {
try {
Thread.sleep(50);
} catch (Exception e) {
// TODO: handle exception
}
return count++;
}
public Integer getCountAtomic() {
try {
Thread.sleep(50);
} catch (Exception e) {
// TODO: handle exception
}
return atomic.incrementAndGet();
}
public static void main(String[] args) {
Test test = new Test();
Thread t1 = new Thread(test);
Thread t2 = new Thread(test);
t1.start();
t2.start();
}
}