1、new Thread的弊端
new Thread(new Runable(){
@Override
public void run() {
//
}
}).start();
new Thread
弊端
- 每次new Thread 新建对象性能差
- 线程缺乏统一管理,可以无限制创建线程,相互之间竞争,极可能占用过多系统资源导致OOM
- 缺乏更多功能,如:定时执行、线程中断等
优点
- 重用存在的线程,减少对象创建、消亡的开销,性能差
- 可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免阻塞
- 提供定时执行、单线程、并发数控制等等
2、Executors 线程池
newCachedThreadPool :创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,否则新建线程。
newFixedThreadPool:创建一个固定大小的线程池,可控制线程最大并发数,超出的线程会在队列中等待。
newScheduledThreadPool : 创建一个定时线程池,支持定时及周期性任务执行。
newSingleThreadExecutor :创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
(1) newCacheThreadPool
创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
示例:
public class MyThreadTest{
public static ExecutorService executor = Executors.newCachedThreadPool();
//public static ExecutorService executor = Executors.newFixedThreadPool(1);
public static long fm = System.currentTimeMillis();
public static void main(String[] args) throws InterruptedException {
System.out.println("main方法开始,活跃线程数:【" + Thread.activeCount() + "】");
for(int i=0;i<5;i++) { // 开启多个线程
executor.execute(new ThreadTest(i));
}
Thread.sleep(2000);
System.out.println("主线程睡眠2秒之后============================");
for(int i=0;i<5;i++) { // 开启多个线程
executor.execute(new ThreadTest(i));
}
//System.out.println("main方法结束,线程数:【" + Thread.activeCount() + "】");
}
static class ThreadTest implements Runnable {
private int i;
public ThreadTest(final int i){
this.i = i;
}
@Override
public void run() {
System.out.println("线程【Thread_" + i + "】开始时间:" + System.currentTimeMillis() + ",睡眠1s");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程【Thread_" + i + "】结束时间:" + System.currentTimeMillis() + ",活跃线程数:【" + Thread.activeCount() + "】,总执行时间【" + (System.currentTimeMillis()-fm) + "】");
}
}
}
执行结果:
main方法开始,活跃线程数:【1】
线程【Thread_0】开始时间:1552202572537,睡眠1s
线程【Thread_1】开始时间:1552202572537,睡眠1s
线程【Thread_2】开始时间:1552202572537,睡眠1s
线程【Thread_3】开始时间:1552202572538,睡眠1s
线程【Thread_4】开始时间:1552202572538,睡眠1s
线程【Thread_1】结束时间:1552202573537,活跃线程数:【6】,总执行时间【1002】
线程【Thread_0】结束时间:1552202573537,活跃线程数:【6】,总执行时间【1002】
线程【Thread_4】结束时间:1552202573538,活跃线程数:【6】,总执行时间【1003】
线程【Thread_2】结束时间:1552202573538,活跃线程数:【6】,总执行时间【1003】
线程【Thread_3】结束时间:1552202573538,活跃线程数:【6】,总执行时间【1003】
主线程睡眠2秒之后============================
线程【Thread_2】开始时间:1552202574551,睡眠1s
线程【Thread_1】开始时间:1552202574551,睡眠1s
线程【Thread_0】开始时间:1552202574551,睡眠1s
线程【Thread_3】开始时间:1552202574551,睡眠1s
线程【Thread_4】开始时间:1552202574551,睡眠1s
线程【Thread_2】结束时间:1552202575551,活跃线程数:【6】,总执行时间【3016】
线程【Thread_4】结束时间:1552202575551,活跃线程数:【6】,总执行时间【3016】
线程【Thread_3】结束时间:1552202575551,活跃线程数:【6】,总执行时间【3016】
线程【Thread_0】结束时间:1552202575551,活跃线程数:【6】,总执行时间【3016】
线程【Thread_1】结束时间:1552202575551,活跃线程数:【6】,总执行时间【3016】
可以看到main 方法执行是,线程数为1(main 主线程),设置每个线程睡眠1s,同时开启5个子线程,总的执行时间为1s,总线程数为6个。主线程睡眠2s后,再次执行线程方法时,可以看到活跃线程数同样为6,说明此时线程池中缓存了第一次创建的5个。
(2)newFixedThreadPool
创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
示例:将上面示例代码中,更改为固定线程池的创建
执行结果:
main方法开始,活跃线程数:【1】
线程【Thread_0】开始时间:1552202901503,睡眠1s
线程【Thread_0】结束时间:1552202902504,活跃线程数:【2】,总执行时间【1003】
线程【Thread_1】开始时间:1552202902504,睡眠1s
主线程睡眠2秒之后============================
线程【Thread_1】结束时间:1552202903504,活跃线程数:【2】,总执行时间【2003】
线程【Thread_2】开始时间:1552202903504,睡眠1s
线程【Thread_2】结束时间:1552202904505,活跃线程数:【2】,总执行时间【3004】
线程【Thread_3】开始时间:1552202904505,睡眠1s
线程【Thread_3】结束时间:1552202905505,活跃线程数:【2】,总执行时间【4004】
线程【Thread_4】开始时间:1552202905505,睡眠1s
线程【Thread_4】结束时间:1552202906505,活跃线程数:【2】,总执行时间【5004】
线程【Thread_0】开始时间:1552202906505,睡眠1s
线程【Thread_0】结束时间:1552202907505,活跃线程数:【2】,总执行时间【6004】
线程【Thread_1】开始时间:1552202907505,睡眠1s
线程【Thread_1】结束时间:1552202908505,活跃线程数:【2】,总执行时间【7004】
线程【Thread_2】开始时间:1552202908505,睡眠1s
线程【Thread_2】结束时间:1552202909505,活跃线程数:【2】,总执行时间【8004】
线程【Thread_3】开始时间:1552202909505,睡眠1s
线程【Thread_3】结束时间:1552202910505,活跃线程数:【2】,总执行时间【9004】
线程【Thread_4】开始时间:1552202910505,睡眠1s
线程【Thread_4】结束时间:1552202911506,活跃线程数:【2】,总执行时间【10005】
可以看到,总的执行时间为10s,而且活跃的线程数为2(其中一个为主线程main)
(3)newScheduledThreadPool
A : 创建一个定长线程池,支持定时及周期性任务执行, 注意应用接口的不同
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
表示延迟3秒执行
B : 定期执行示例代码如
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);
表示延迟1秒后每3秒执行一次
ScheduledExecutorService比Timer更安全,功能更强大。
(4)newSingleThreadExecutor
创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
3、线程池
A:作用:
线程池作用就是限制系统中执行线程的数量
根据系统的环境情况,可以自动或手动设置线程数量,达到运行的最佳效果;少了浪费系统资源,多了造成系统拥挤效率不高。用线程池控制线程数量,其他线程排队等待。一个任务执行完毕,再从队列中取最前面的任务开始执行。若队列中没有等待线程,线程池的这一资源处于等待。当一个新任务需要运行时,如果线程池中有等待的工作线程,就可以开始运行了;否则进入等待队列。
B:为什么要使用?
- 减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。
2.可以根据系统的承受能力,吊针线程池中工作线程的数目,防止因为消耗过多的内存,而把服务器累趴下
C:使用
Java里面线程池的顶级接口是Executor,但议案个意义上讲Executor并不是一个线程池,而只是一个执行线程的工具。真正的线程池接口是ExecutorService。
比较重要的几个类:
类/接口 | 描述 |
---|---|
ExecutorService | 真正的线程池接口 |
ScheduledExecutorService | 能和Timer/TimerTask类似,解决那些需要任务重复执行的问题 |
ThreadPoolExecutor | ExecutorService的默认实现 |
ScheduledThreadPoolExecutor | 继承ThreadPoolExecutor的ScheduledExecutorService接口实现,周期性任务调度的类实现 |
要配置一个线程池是比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,很有可能配置的线程池不是较优的,因此在Executors类里面提供了一些静态工厂,生成一些常用的线程池。
- newSingleThreadExecutor
创建一个单线程的线程池。这个线程池只有一个线程在工作,也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
2.newFixedThreadPool
创建固定大小的线程池。每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程。
- newCachedThreadPool
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程,
那么就会回收部分空闲(60秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。
4.newScheduledThreadPool
创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
参考文档:
https://www.cnblogs.com/baizhanshi/p/5469948.html