1.为什么使用线程池
- 线程缺乏统一管理,占用过多系统资源
-
缺乏更多功能,如定时执行、定期执行等
2.使用线程池的好处
- 重用存在的线程,减少对象创建、消亡的开销
-
有效控制最大并发数,提高系统资源使用率
-
定时执行、定期执行
3.JAVA,线程池API
- 线程池所在包java.util.concurrent
-
*接口是Executor ,真正的线程池接口是ExecutorService
-
java.util.concurrent. Executors类提供创建线程池的方法
可以下载 帮助文档，去了解更多
3.1使用newCachedThreadPool ( )方法创建线程池
1 import java.util.concurrent.ExecutorService;
2 import java.util.concurrent.Executors;
3
4 /**
5 * 使用newCachedThreadPool ( )方法创建线程池
6 * 缓存线程池
7 */
8 public class Test {
9 public static void main(String[] args) {
10 ExecutorService cache= Executors.newCachedThreadPool();//创建一个线程池
11 //在线程池面执行10任务
12 for (int i=0;i<10;i++){
13 cache.execute(new MyRunnable(i));
14 // try {
15 // Thread.sleep(500);//模拟网络延迟
16 //} catch (InterruptedException e) {
17 //e.printStackTrace();
18 // }
19 }
20 }
21 }
22 class MyRunnable implements Runnable{
23 int num;//代表任务数
24 public MyRunnable(int num){
25 this.num=num;
26 }
27 @Override
28 public void run() {
29 System.out.println(Thread.currentThread().getName()+":"+num);
30 }
31 }
3.2.使用newSingle ThreadExecutor()创建一个单线程池
1 import java.util.concurrent.ExecutorService;
2 import java.util.concurrent.Executors;
3
4 /**
5 * 使用newSingle ThreadExecutor()创建一个单线程池
6 */
7 public class Single {
8 public static void main(String[] args) {
9 ExecutorService cache= Executors.newSingleThreadExecutor();//创建一个线程池
10 for (int i=0;i<10;i++){
11 cache.execute(new MyRunnable(i)) ;
12 }
13 }
14 }
3.3.使用newFixedThreadPool( )方法创建线程池
1 import java.util.concurrent.ExecutorService;
2 import java.util.concurrent.Executors;
3
4 /**
5 * 使用newFixedThreadPool( )方法创建线程池
6 */
7 public class Fixed {
8 public static void main(String[] args) {
9 ExecutorService cache= Executors.newFixedThreadPool(3);//创建一个线程池,可以设置创建线程池的个数
10 for (int i=0;i<10;i++){
11 cache.execute(new MyRunnable(i)) ;
12 }
13 }
14 }
3.4.使用newScheduledThreadPool ( )方法来创建线程池
1 import java.util.concurrent.Executors;
2 import java.util.concurrent.ScheduledExecutorService;
3 import java.util.concurrent.TimeUnit;
4
5 /**
6 * 使用newScheduledThreadPool ( )方法来创建线程池
7 */
8 public class Sched {
9 public static void main(String[] args) {
10 ScheduledExecutorService sched=Executors.newScheduledThreadPool(3);//设置创建线程池的个数
11 System.out.println("**************开始执行**************");
12 sched.scheduleAtFixedRate(new MYrunnable() ,1,2,TimeUnit.SECONDS);
13 }
14 }
15 class MYrunnable implements Runnable{
16
17 @Override
18 public void run() {
19 System.out.println(Thread.currentThread().getName()+"延时时间1秒，每2秒执行一次");
20 }
21 }
4.ThreadPool Executor类
4.1.构造器中各个参数的含义
-
corePoolSize :核心池的大小
-
maximumPoolSize :线程池最大线程数
-
keepAliveTime :表示线程没有任务执行时最多保持多久时间会终止
-
unit :参数keepAliveTime的时间单位
- workQueue : -个阻塞队列,用来存储等待执行的任务
-
threadFactory :线程工厂,主要用来创建线程
-
handler :表示当拒绝处理任务时的策略
1 import java.util.concurrent.ArrayBlockingQueue;
2 import java.util.concurrent.ThreadPoolExecutor;
3 import java.util.concurrent.TimeUnit;
4
5 /**
6 * 创建自定义线程池
7 */
8 public class Diamond {
9 public static void main(String[] args) {
10 //创建一个自定义的线程池
11 ThreadPoolExecutor executor=new ThreadPoolExecutor(5,7,300, TimeUnit.MICROSECONDS,new ArrayBlockingQueue<Runnable>(4));
12 for(int i=0;i<12;i++){
13 executor.execute(new ryunnable(i));
14 System.out.println("线程池中的线程数"+executor.getPoolSize()+",队列中等待执行的任务数:"+executor.getQueue().size()+",你执行完的任务数:"+executor.getCompletedTaskCount());
15 }
16 executor.shutdown();
17 }
18 }
19 class ryunnable implements Runnable{
20 int num;//第几个任务
21 public ryunnable(int num){
22 this.num=num;
23 }
24
25 @Override
26 public void run() {
27 System.out.println("正在执行任务"+num);
28 try {
29 Thread.sleep(2000);
30 } catch (InterruptedException e) {
31 e.printStackTrace();
32 }
33 System.out.println("任务"+num+"执行完毕");
34 }
35 }