一、CountDownLatch
package com.jonychen.test;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 并发编程java.util.concurrent(JUC)
* AQS(AbstractQueuedSynchronizer)
*/
public class JUCAQSDemo {
public static void main(String[] args){
/**
* CountDownLatch用来控制一个线程等待多个线程,维护一个计数器cnt, * 每次调用countDown()会让计数器的值减一, 减到零时, * 那些因为调用await()方法而在等待的线程会被唤醒
*/
final int totalThread=10;
CountDownLatch countDownLatch =new CountDownLatch(totalThread);
ExecutorService executorService =Executors.newCachedThreadPool();
for (int i = 0; i < totalThread; i++) {
executorService.execute(()->{
System.out.println("jonychen run");
countDownLatch.countDown();
});
}
try {
countDownLatch.await();
System.out.println("end...");
executorService.shutdown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行截图:
二、CyclicBarrier
package com.jonychen.thread;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 并发编程java.util.concurrent(JUC)
* AQS(AbstractQueuedSynchronizer)
*/
public class JUCAQSCycliBarrier {
/**
*CyclicBarrier用来控制多个线程相互等待,只有当多个线程都到达时,这些线程才会继续执行,
* 和CountDownLatch相似,都是通过维护计数器实现的,但他的计数器是递增的。每次执行await()
* 方法后,计数器会加1,直到计数器的值和设置的值相同,等待的所有线程才会继续执行,和CountDownLatch
* 的另一个区别是,CyclicBarrier的计数器可以循环使用,所以才叫他循环屏障
*/
public static void main(String[] args){
final int totalThread=10;
CyclicBarrier cyclicBarrier =new CyclicBarrier(totalThread);
ExecutorService executorService=Executors.newCachedThreadPool();
for (int i = 0; i < totalThread; i++) {
executorService.execute(()->{
System.out.println("before..*");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.print("after ");
});
}
executorService.shutdown();
}
}
运行截图:
三、Semaphore
package com.jonychen.thread;
import sun.misc.Cleaner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* 并发编程java.util.concurrent(JUC)
* AQS(AbstractQueuedSynchronizer)
*/
public class JUCAQSSemaphore {
public static void main(String[] args){
/**
*Semaphore就是操作系统中的信号量,可以控制对互斥资源的访问线程数
*以下代码模拟了对某个服务的并发请求,每次只能有30个客户端同时访问,请求总数为 10。
*/
final int clientCount=30;
final int totalRequestCount=10;
Semaphore semaphore =new Semaphore(clientCount);
ExecutorService executorService=Executors.newCachedThreadPool();
for (int i = 0; i < totalRequestCount; i++) {
executorService.execute(()->{
try {
semaphore.acquire();
System.out.println(semaphore.availablePermits() + "");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release();
}
});
}
executorService.shutdown();
}
}
运行截图: