线程池的应用--＞2
1.自定义线程工程
-
当需要自定义线程的名字，线程的优先级，精灵线程状态时，需要自定义线程工厂。
-
如何自定义线程工厂
-
自定义工厂类，实现ThreadFactory接口，重写方法
newThread() -
在创建线程池对象时，传递上述线程工厂对象
-
public class Test5 {public static void main(String[] args) {System.out.println("------------------------");ThreadPoolExecutor pool = new ThreadPoolExecutor(5,15,5, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),new MyThreadFactory());pool.execute(()->{System.out.println("---->"+Thread.currentThread().getName());});}
}class MyThreadFactory implements ThreadFactory{//int count = 1 ;AtomicInteger count = new AtomicInteger(1);@Overridepublic Thread newThread(Runnable r) {Thread t = new Thread(r);t.setName("pool-a-thread-"+count.getAndIncrement());t.setPriority(8);//t.setDaemon(true);return t;}
}2.自定义拒绝策略
实现，当前线程池能力不足时，交给另一个线程池来执行。
-
自定义拒绝策略类，
-
创建线程池对象时，传递自定义拒绝策略对象
3.自动获得线程池
提供了5个方法可以快速获得线程池对象
//适合任务量大，功能简单的任务，需要确保每一次任务都需要快速反应
ExecutorService pool = Executors.newCachedThreadPool();//线程池中只有一个线程，确保任务顺序执行
//当内部的线程执行任务出错时，会创建一个新线程。
ExecutorService pool = Executors.newSingleThreadExecutor();//线程池内装载固定数量的线程
ExecutorService pool = Executors.newFixedThreadPool(5);//可以执行定时任务的线程池
ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);//工作窃取线程池
//1. 本质是ForkJoinPool
//2. 提供了2个重载构造器，一个传参指定内部线程的数量，第二个不传参默认是逻辑处理器的数量
//3. 工作窃取线程池的机制
// 所有的线程都是精灵线程
// 之前的线程池，无论有多少个线程，都只有一个任务队列
// 当一瞬间有多个线程同时完成任务时，就会同时去队列中获得新任务，此时就会发生阻塞（性能低）
// 工作窃取线程池内部，每一个线程都配有一个任务队列，当完成任务时，去自己的队列中获取新任务
// 当自己的队列中的任务完成后，就去其他线程任务队列中"窃取"任务执行
// 每一个队列都是双端队列，当前线程从a端获取任务，其他线程从b端窃取任务
ExecutorService pool = Executors.newWorkStealingPool();//延迟指定时间执行
//
pool.schedule(()->{System.out.println("-----------------------------");
},5, TimeUnit.SECONDS);//延迟指定时间，开始执行
//执行后，每隔指定时间，重复执行
//每次执行的时间 会与 间隔时间叠加pool.scheduleAtFixedRate(()->{for(int i = 1 ;i<=2;i++){System.out.println(i);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}},5,2,TimeUnit.SECONDS);//延迟指定时间，开始执行
//执行后，每隔指定时间，重复执行
//每次执行的时间 不会与 间隔时间叠加pool.scheduleWithFixedDelay(()->{for(int i = 1 ;i<=2;i++){System.out.println(i);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}},5,2,TimeUnit.SECONDS);4.线程池生命周期
线程的生命周期
创建 -> 就绪 -> 运行 -> 销毁
|
暂停
线程池生命周期
-
运行状态 RUNNING
状态切换：随着线程池对象的创建，就立刻进入运行状态
状态效果：运行时的线程池，可以接收任务，处理任务，缓存任务
-
关闭状态 SHUTDOWN
状态切换：在运行状态时，调用
pool.shutdown()方法状态效果：线程池不再接收新任务，但会执行完先有的任务及队列中的任务
-
停止状态 STOP
状态切换：运行时直接调用
pool.shutdownNow()方法或处于shutdown状态的线程池完成了所有手头任务，自动进入stop状态
状态效果：线程池不再接收新任务，清除队列中的任务，中断正在执行的任务
-
整理状态 TIDYING
状态切换：没有方法能直接切换到整理状态
处于stop状态的线程池，完成了所有任务处理工作，自动调用terminated()
状态效果：逻辑上就是整理，释放资源，类似于finally中做的事
-
终结状态 TERMINATED
状态切换：没有方法能直接切换到终结状态
处于整理状态的线程池，执行完terminated方法，自动进入终结状态
状态效果：完全关闭线程池
5.并发工具
5.1CountDownLatch类
-
提供计数器，当所有的线程都执行完毕后，当前线程再执行。
-
可以代替多线程中的join作用
CountDownLatch latch = new CountDownLatch(5);
latch.countDown() ;//计数器-1
latch.await();//等待计数器为0（阻塞）public class Test9 {static int count = 0 ;public static void main(String[] args) throws InterruptedException {ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(5);CountDownLatch latch = new CountDownLatch(5);//循环5次，完成5个任务（通过5个线程）for(int i=0;i<5;i++){pool.execute(()->{try {Thread.sleep((int)((Math.random()*4+1)*1000));} catch (InterruptedException e) {throw new RuntimeException(e);}//每个任务对count累加1000次for(int j=0;j<1000;j++){count++ ;}System.out.println(Thread.currentThread().getName()+"执行完毕");latch.countDown();});}latch.await();System.out.println(count);}
}5.2Semaphore类
-
信号量
-
提供一组信号量，每一个线程都可以申请信号量， 确保指定数量的线程同时执行。
-
每一个线程执行完毕后，需要释放信号量
Semaphore s = new Semaphore(5);
s.acquire();
s.release();public static void main(String[] args) {Semaphore s = new Semaphore(5);ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);for(int i = 1;i<=10;i++) {pool.execute(()->{try {s.acquire();System.out.println(Thread.currentThread().getName()+"正在执行");Thread.sleep(5000);s.release();} catch (InterruptedException e) {throw new RuntimeException(e);}});}}