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
创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
网友评论