面试总结-线程池
- 1.线程池类型及应用
- 1.1newSingleThreadExecutor单个线程的线程池
- 1.2newFixedThreadExecutor(n)固定数量的线程池
- 1.3newCacheThreadExecutor（推荐使用）可缓存线程池
- 1.4newScheduleThreadExecutor大小无限制的线程池
- 2.线程池任务执行流程：
- 3.一个线程有三个方法，怎么保证三个是顺序执行
- 第一种方式：
- 第二种方式：
- 第三种方式：
- 第四种方式：
1.线程池类型及应用
线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。 Executors可以说是一个工厂类，可以用它来创建不同的线程池。
常见的几个线程池
1.1newSingleThreadExecutor单个线程的线程池
ExecutorService sPool = Executors.newSingleThreadExecutor();即线程池中每次只有一个线程工作，单线程串行执行任务。
底层：FinalizableDelegatedExecutorService包装的ThreadPoolExecutor实例，corePoolSize为1；maximumPoolSize为1；keepAliveTime为0L；unit为：TimeUnit.MILLISECONDS；workQueue为：new LinkedBlockingQueue() 无解阻塞队列
通俗：创建只有一个线程的线程池，且线程的存活时间是无限的；当该线程正繁忙时，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：一个任务一个任务执行的场景
1.2newFixedThreadExecutor(n)固定数量的线程池
ExecutorService fPool = Executors.newFixedThreadPool(3);每提交一个任务就是一个线程，直到达到线程池的最大数量，然后后面进入等待队列直到前面的任务完成才继续执行。
底层：返回ThreadPoolExecutor实例，接收参数为所设定线程数量nThread，corePoolSize为nThread，maximumPoolSize为nThread；keepAliveTime为0L(不限时)；unit为：TimeUnit.MILLISECONDS；WorkQueue为：new LinkedBlockingQueue() 无解阻塞队列
通俗：创建可容纳固定数量线程的池子，每隔线程的存活时间是无限的，当池子满了就不在添加线程了；如果池中的所有线程均在繁忙状态，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：执行长期的任务，性能好很多
1.3newCacheThreadExecutor（推荐使用）可缓存线程池
ExecutorService cPool = Executors.newCachedThreadPool();当线程池大小超过了处理任务所需的线程，那么就会回收部分空闲（一般是60秒无执行）的线程，当有任务来时，又智能的添加新线程来执行。
底层：返回ThreadPoolExecutor实例，corePoolSize为0；maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为60L；unit为TimeUnit.SECONDS；workQueue为SynchronousQueue(同步队列)
通俗：当有新任务到来，则插入到SynchronousQueue中，由于SynchronousQueue是同步队列，因此会在池中寻找可用线程来执行，若有可以线程则执行，若没有可用线程则创建一个线程来执行该任务；若池中线程空闲时间超过指定大小，则该线程会被销毁。
适用：执行很多短期异步的小程序或者负载较轻的服务器
1.4newScheduleThreadExecutor大小无限制的线程池
ExecutorService executorService= Executors.newScheduledThreadPool(10);支持定时和周期性的执行线程。
底层：创建ScheduledThreadPoolExecutor实例，corePoolSize为传递来的参数，maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为0；unit为：TimeUnit.NANOSECONDS；workQueue为：new DelayedWorkQueue() 一个按超时时间升序排序的队列
通俗：创建一个固定大小的线程池，线程池内线程存活时间无限制，线程池可以支持定时及周期性任务执行，如果所有线程均处于繁忙状态，对于新任务会进入DelayedWorkQueue队列中，这是一种按照超时时间排序的队列结构
适用：周期性执行任务的场景
2.线程池任务执行流程：
1.当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。
2.当线程池达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行
3.当workQueue已满，且maximumPoolSize>corePoolSize时，新提交任务会创建新线程执行任务
4.当提交任务数超过maximumPoolSize时，新提交任务由RejectedExecutionHandler处理
5.当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程
6.当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭
3.一个线程有三个方法，怎么保证三个是顺序执行
第一种方式：
顺序在线程中创建实例（最容易想到的办法）。
public class TestTwo {
static TestTwo t=new TestTwo();
class T1 extends Thread{
@Override
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//T1线程中要处理的东西
System.out.println("T1线程执行")
}
}
class T2 extends Thread{
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
//T2线程中要处理的东西
System.out.println("T2线程执行");
t.new T1().start();
}
}
class T3 extends Thread{
@Override
public void run() {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
//T3线程中要处理的东西
System.out.println("T3线程执行");
t.new T2().start();
}
}
public static void main(String[] args) {
t.new T3().start();
//打印结果如下：
//T3线程执行
//T2线程执行
//T1线程执行
}
}第二种方式：
看到有人说运用单个线程池（SingleThreadExecutor）来实现，确切的说这里不太符合，从打印结果看出，其实是在一个线程里，执行了三个任务。
Thread t1 = new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " run 1");
}
}, "T1");
Thread t2 = new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " run 2");
}
}, "T2");
Thread t3 = new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " run 3");
}
}, "T3");
//三个线程顺序执行 第一种方案，单个线程池 顺序放入执行队列中
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(t3);
executor.submit(t2);
executor.submit(t1);
executor.shutdown();第三种方式：
thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。
package com.gs.demo1;
public class ThreadTest1 {
public static void main(String[] args) {
Thread t1 = new Thread(new Work(null),"线程t1");
Thread t2 = new Thread(new Work(t1),"线程t2");
Thread t3 = new Thread(new Work(t2),"线程t3");
t1.start();
t2.start();
t3.start();
}
static class Work implements Runnable{
private Thread beforeThread;
public Work(Thread beforeThread) {
this.beforeThread = beforeThread;
}
@Override
public void run() {
if(beforeThread!=null) {
try {
//某线程调用该方法，会让其他线程处于等待状态，让其运行完毕，再执行其他线程.
beforeThread.join();
System.out.println("Thread start:"+Thread.currentThread().getName());
}catch(Exception e){
e.printStackTrace();
}
}else {
System.out.println("Thread start:"+Thread.currentThread().getName());
}
}
}
}第四种方式：
使用CountDownLatch
CountDownLatch(闭锁)是一个很有用的工具类，利用它我们可以拦截一个或多个线程使其在某个条件成熟后再执行。它的内部提供了一个计数器，在构造闭锁时必须指定计数器的初始值，且计数器的初始值必须大于0。另外它还提供了一个countDown方法来操作计数器的值，每调用一次countDown方法计数器都会减1，直到计数器的值减为0时就代表条件已成熟，所有因调用await方法而阻塞的线程都会被唤醒。这就是CountDownLatch的内部机制，看起来很简单，无非就是阻塞一部分线程让其在达到某个条件之后再执行。
package com.gs.demo2;
import java.util.concurrent.CountDownLatch;
public class ThreadTest2 {
public static void main(String[] args) {
CountDownLatch c1 = new CountDownLatch(0);//计数器为0
CountDownLatch c2 = new CountDownLatch(1);//计数器为1
CountDownLatch c3 = new CountDownLatch(1);//计数器为1
Thread t1 = new Thread(new Work(c1, c2),"线程t1");
//c1为0，t1线程可以执行。t1线程的计数器 c2 减1
Thread t2 = new Thread(new Work(c2, c3),"线程t2");
//t1的计数器c2为0时，t2才能执行。t2的计数器c3减1
Thread t3 = new Thread(new Work(c3, c3),"线程t3");
//t3的计数器c3为0时，t3才能执行
t1.start();
t2.start();
t3.start();
}
//定义Work线程类，需要传入开始和结束的CountDownLatch参数
static class Work implements Runnable {
private CountDownLatch c1;
private CountDownLatch c2;
public Work(CountDownLatch c1, CountDownLatch c2) {
super();
this.c1 = c1;
this.c2 = c2;
}
@Override
public void run() {
try {
//当某个线程调用CountDownLatch对象的await方法时，将会阻塞，直到计数器的值变成0才放行。
c1.await();
System.out.println("thread start:" + Thread.currentThread().getName());
c2.countDown(); //本线程计数器减 1
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
