1.并发工具类


1.CountDownLatch:可以实现线程计数,阻塞后续线程


CountDownLatch类位于java.util.concurrent包下,利用它可以实现类似计数器的功能。比如有一个任务A,它要等待其他4个任务执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了。
countDown()实现计数器-1
await()等待拦截方法,等待计数器为0时再放行,否则则一直阻塞
getCount()获取当前计数器中计数数量

案例:
/**
* 等待子线程全部执行完毕之后再执行主线程内容
* @param args
*/
private static CountDownLatch countDownLatch=new CountDownLatch(2);
public static void main(String[] args) throws InterruptedException {
System.out.println("======主线程开始运行=====");
//第一个子线程
new Thread(()->{
System.out.println("子线程"+Thread.currentThread().getName()+"开始运行~");
//线程数量-1操作,通知该线程运行完毕
countDownLatch.countDown();
}).start();

//第二个子线程
new Thread(()->{
System.out.println("子线程"+Thread.currentThread().getName()+"开始运行~");
//线程数量-1操作,通知该线程运行完毕
countDownLatch.countDown();
}).start();

//等待,等待计数器中线程计数为0时才继续向下执行
countDownLatch.await();
System.out.println("子线程执行完毕,主线程继续执行");

 

//获取当前计数线程数量
/*while (true){
if(countDownLatch.getCount()==0){
System.out.println("子线程执行完毕,主线程继续执行");
break;
}
}*/
}

 


2.CyclicBarrier:类似于栅栏,进行拦截,等待所有线程都准备,然后统一放行,阻塞当前线程


//设置等待线程数量,当线程数量到达指定数量时,统一向下运行
private static CyclicBarrier cyclicBarrier=new CyclicBarrier(10);
public static void main(String[] args) {
//创建10个线程
for (int i = 1; i <=10 ; i++) {
new Thread(()->{
try {
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+"准备就绪");
//等待
cyclicBarrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"开始比赛~");
}).start();
}
}

 

3.Semaphore:可以做资源控制,容器中有几个资源,那么线程执行时先申请资源,资源如果可用则继续执行,如果资源不可用则阻塞等待


当资源占用完毕之后将该资源释放,其他线程排队占用

private static Semaphore semaphore=new Semaphore(3);
public static void main(String[] args) {
for (int i = 1; i <=10 ; i++) {
new Thread(()->{
try {
//申请资源,发生阻塞
System.out.println(Thread.currentThread().getName()+"申请茅坑~");
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+"可以安心上厕所了");
//模拟上厕所时间
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+"舒服,上完了~");
//释放资源
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}


4.Exchanger:可以执行线程的资源交换,线程数量必须为偶数,因为是两两相互交换资源,如果不是偶数默认情况下导致阻塞,可以设置交换资源超时时间


public class ExchangerDemo {
private static String str1="资源1";
private static String str2="资源2";
//构建资源交换对象
private static Exchanger<String> stringExchanger=new Exchanger<>();
public static void main(String[] args) {
//第一个线程
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"初始占用资源:"+str1);
//资源交换,将资源交给其他线程和获取到其他线程交换过来的资源
try {
String newStr = stringExchanger.exchange(str1);
System.out.println(Thread.currentThread().getName()+"交换资源:"+newStr);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();

//第二个线程
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"初始占用资源:"+str2);
//资源交换,将资源交给其他线程和获取到其他线程交换过来的资源
try {
String newStr = stringExchanger.exchange(str2);
System.out.println(Thread.currentThread().getName()+"交换资源:"+newStr);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();

//第三个线程
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"初始占用资源:"+str2);
//资源交换,将资源交给其他线程和获取到其他线程交换过来的资源
try {
//设置资源交换超时时间
String newStr = stringExchanger.exchange(str2,1000, TimeUnit.MILLISECONDS);
System.out.println(Thread.currentThread().getName()+"交换资源:"+newStr);
} catch (InterruptedException | TimeoutException e) {
e.printStackTrace();
}
}).start();
}
}


2.线程池

 


类似于一个池子,可以存放/管理线程


1.使用线程池的好处


第一:降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二:提高响应速度。当任务到达时,任务可以不需要等到线程创建就能立即执行。
第三:提高线程的可管理性


2.如何使用线程池


2.1线程池分类
线程池顶级类ThreadPoolExecutor最终实现Executor接口,在JUC包下,通过Executors类可以创建不同类型的线程池,分类如下
1.newScheduledThreadPool 定时任务线程池,可以设置任务时间
2.newFixedThreadPool 定长线程池
3.newSingleThreadExecutor 利用的是单线程,单线程处理任务,一般不用
4.newCachedThreadPool 带缓存的线程池
2.2 构建线程池
1.newCachedThreadPool线程池,可缓存,可以重复利用
//构建一个线程池,可以重复利用线程
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 1; i <=10 ; i++) {
//创建线程池
executorService.execute(()->{
System.out.println("创建线程池"+Thread.currentThread().getName());
});
}
2.newFixedThreadPool创建一个固定线程数量的线程池
//构建线程池对象
ExecutorService executorService = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
//创建线程
executorService.execute(()->{
System.out.println("创建线程:"+Thread.currentThread().getName());
});
}


3.newScheduledThreadPool


//创建一个线程池
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
for (int i = 0; i < 10; i++) {
scheduledExecutorService.schedule(()->{
System.out.println("创建线程:"+Thread.currentThread().getName());
},1000, TimeUnit.MILLISECONDS);
}


4.newSingleThreadExecutor单线程池


//创建一个线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
executorService.execute(()->{
System.out.println("创建线程:"+Thread.currentThread().getName());
});
}

3.所有的线程池分类底层调用的都是ThreadPoolExecutor()构造方法,该构造方法中每一个参数含义


public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue)

1.corePoolSize代表核心线程池大小,当有任务时,会创建对应线程处理对应任务,当线程到达一定数量后,则会缓存到队列当中,不会再次创建新的线程
2.maximumPoolSize: 线程池最大线程数,它表示在线程池中最多能创建多少个线程
3.keepAliveTime: 表示线程没有任务执行时最多保持多久时间会终止。
4.unit: 参数keepAliveTime的时间单位,有7种取值,在TimeUnit类中有7种静态属性

4.如何确定线程池中创建线程数量
考虑CPU密集和IO密集,如果不考虑IO情况下,一般是处理器数量+1,如果考虑IO,则处理器*2

posted on 2020-03-19 15:59  神剑战王  阅读(188)  评论(0编辑  收藏  举报