理论:
1 Executors 预置 4种线程池: Fixed SingleThread cached Scheduled
2 FutureTask 使用方法: 新建callable<T>对象;将Callable对象submit 线程池中,会返回Future对象,然后 可以通过get 获取对应数据,但是会等待
3 ExecutorCompletionService 接收线程队列,内置一个BlockingQueue,有数据才返回
线程池:
ThreadPoolExecutor :
CorepoolSize 核心池大小
MaxPoolSize 最大池大小 ,只有工作对列满了,才会扩大最大池
KeepAliveTime 空闲线程保留时间
TimeUnit 保留单位
WorkQueue 工作对列,
ThreadFactory 线程工厂,主要定制线程名称
RejectedExecutionHandler :饱和策略,默认为AbortPolicy, 饱和就废弃,但是会抛出 RejectedExecutionException(非检查异常)
线程池 | 使用说明 | corepoolsize | maxpoolsize | 后台使用队列 |
newCachedThreadPool | 无限容量线程池运行队列; | 0 | Integer.MAX_VALUE | SynchronousQueue:无容量、无缓冲队列 |
newFixedThreadPool | 固定线程池队列 Executors.newFixedThreadPool(1); | 定义时指定 | 与corepoolsize 相同 | LinkedBlockingQueue 无限队列 |
newSingleThreadExecutor | 顺序运行队列,FIFO,一次只执行一个线程 | 1 | 1 | LinkedBlockingQueue 无限队列 |
newScheduledThreadPool | 线程定时任务执行器;可以放置无限多线程执行,并且可以使用固定周期 与固定时延方式运行线程,一般用于执行定时任务,不会放置无限多线程。 | 定义时指定 | Integer.MAX_VALUE | DelayedWorkQueue 无限容量堆数组 |
TestCachedThreadExecutors
/**
* newCachedThreadPool corepool size 0, maxpool 无限大,
* 后台使用了 SynchronousQueue 无容量无缓冲等待队列,线程直接交给maxpool去执行
* 可以并行运行无限大线程池,并且线程池可以复用(前一个线程用完即可)
*/
public class TestCachedThreadExecutors {
private CountDownLatch cdLatch = new CountDownLatch(3);
public static void main(String[] args) {
Executor cachedExecutors = Executors.newCachedThreadPool();
ThreadTask t1 = new ThreadTask();
ThreadTask t2 = new ThreadTask();
ThreadTask t3 = new ThreadTask();
cachedExecutors.execute(t1);
cachedExecutors.execute(t2);
cachedExecutors.execute(t3);
showVM();
for(int i=0;i<1000;i++){
ThreadTask t = new ThreadTask();
cachedExecutors.execute(t);
if(i%100==0){showVM();
System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
}
}
public static class ThreadTask implements Runnable{
private Byte[] datas = new Byte[10240];
@Override
public void run() {
try {
Thread.sleep(5000l);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private static void showVM(){
List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
System.out.println("Name:" + memoryPoolMXBean.getName());
System.out.println("Usage:" + memoryPoolMXBean.getUsage());
System.out.println("Manager:" +","+ memoryPoolMXBean.getMemoryManagerNames());
System.out.println("Type:" + memoryPoolMXBean.getType());
System.out.println("--------------------------");
}
}
}
TestFixedThreadExecutors
/**
* newFixedThreadPool corePoolSize = maxPoolSize,
* 后台使用了 LinkedBlockingQueue 无限队列,可以放置无限多线程
*/
public class TestFixedThreadExecutors {
private CountDownLatch cdLatch = new CountDownLatch(3);
public static void main(String[] args) {
Executor fixedExecutors = Executors.newFixedThreadPool(1);
ThreadTask t1 = new ThreadTask();
ThreadTask t2 = new ThreadTask();
ThreadTask t3 = new ThreadTask();
fixedExecutors.execute(t1);
fixedExecutors.execute(t2);
fixedExecutors.execute(t3);
showVM();
for(int i=0;i<1000;i++){
ThreadTask t = new ThreadTask();
fixedExecutors.execute(t);
if(i%100==0){showVM();
System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
}
}
public static class ThreadTask implements Runnable{
private Byte[] datas = new Byte[1024000];
@Override
public void run() {
try {
Thread.sleep(5000l);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private static void showVM(){
List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
System.out.println("Name:" + memoryPoolMXBean.getName());
System.out.println("Usage:" + memoryPoolMXBean.getUsage());
System.out.println("Manager:" +","+ memoryPoolMXBean.getMemoryManagerNames());
System.out.println("Type:" + memoryPoolMXBean.getType());
System.out.println("--------------------------");
}
}
}
TestSingleThreadExecutors
/**
* newSingleThreadExecutor 一次执行一个线程,并且保证线程顺序执行,
* 后台使用了 LinkedBlockingQueue 无限队列,可以放置无限多线程
*/
public class TestSingleThreadExecutors {
private CountDownLatch cdLatch = new CountDownLatch(3);
public static void main(String[] args) {
Executor singleExecutors = Executors.newSingleThreadExecutor();
ThreadTask t1 = new ThreadTask();
ThreadTask t2 = new ThreadTask();
ThreadTask t3 = new ThreadTask();
singleExecutors.execute(t1);
singleExecutors.execute(t2);
singleExecutors.execute(t3);
showVM();
for(int i=0;i<1000;i++){
ThreadTask t = new ThreadTask();
singleExecutors.execute(t);
if(i%100==0){showVM();
System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
}
}
public static class ThreadTask implements Runnable{
private Byte[] datas = new Byte[1024];
@Override
public void run() {
try {
Thread.sleep(5000l);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private static void showVM(){
List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
System.out.println("Name:" + memoryPoolMXBean.getName());
System.out.println("Usage:" + memoryPoolMXBean.getUsage());
System.out.println("Manager:" +","+ memoryPoolMXBean.getMemoryManagerNames());
System.out.println("Type:" + memoryPoolMXBean.getType());
System.out.println("--------------------------");
}
}
}
TestScheduledThreadExecutors
/**
* newScheduledThreadPool corepool 用户设置, maxpool 无限大,
* 后台使用了 DelayedWorkQueue 无限制容量堆数组,线程直接交给maxpool去执行
* 可以放置无限多线程执行,并且可以使用固定周期 与固定 时延方式运行线程
* 一般不会放置无限多线程。
*/
public class TestScheduledThreadExecutors {
private CountDownLatch cdLatch = new CountDownLatch(3);
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
ThreadTask t1 = new ThreadTask();
ThreadTask t2 = new ThreadTask();
ThreadTask t3 = new ThreadTask();
scheduledExecutorService.schedule(t1,3, TimeUnit.SECONDS);
scheduledExecutorService.scheduleAtFixedRate(t2,2000,2000,TimeUnit.SECONDS);
scheduledExecutorService.scheduleWithFixedDelay(t3,2000,2000,TimeUnit.SECONDS);
showVM();
for(int i=0;i<1000;i++){
ThreadTask t = new ThreadTask();
scheduledExecutorService.execute(t);
if(i%100==0){showVM();
System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
}
}
public static class ThreadTask implements Runnable{
private Byte[] datas = new Byte[10240];
@Override
public void run() {
try {
Thread.sleep(5000l);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private static void showVM(){
List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
System.out.println("Name:" + memoryPoolMXBean.getName());
System.out.println("Usage:" + memoryPoolMXBean.getUsage());
System.out.println("Manager:" +","+ memoryPoolMXBean.getMemoryManagerNames());
System.out.println("Type:" + memoryPoolMXBean.getType());
System.out.println("--------------------------");
}
}
}
TestCompletionService
/**
* 实现原理:ExecutorCompletionService 类,内部定义了一个 BlockingQueue<Future<T>>;
* 当线程执行完成,有返回时,往 BlockingQueue 中add Futurn<T>;
* 具体怎么判断线程执行完成呢:重载类FutureTask.done()方法,完成相关功能
*
* 使用场景:当使用线程池运行需要有返回值的线程时,为了获取结果不被阻塞,需要使用此方法
*/
public class TestCompletionService {
public static void main(String[] args) throws InterruptedException, ExecutionException {
Executor executorService = Executors.newFixedThreadPool(3);
List<Callable<String>> callableList = new ArrayList<>();
for (int i = 0; i < 5; i++) {
final String name = "name" + i;
final int sleepTime = new Random().nextInt(10);
Callable<String> callable = new Callable<String>() {
@Override
public String call() throws Exception {
System.out.println("Thread name :" + name + ",sleeptime :" + sleepTime);
TimeUnit.SECONDS.sleep(sleepTime);
return "found " + name;
}
};
callableList.add(callable);
}
CompletionService<String> completionService = new ExecutorCompletionService<String>(executorService);
for (int i = 0; i < callableList.size(); i++)
completionService.submit(callableList.get(i));
for (int i = 0; i < callableList.size(); i++) {
System.out.println("等待打印" + (i + 1) + "个返回值");
System.out.println(completionService.take().get());
}
}
}
TestExecutorInvokeAll
public class TestExecutorInvokeAll {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(5);
List<Callable<String>> callableList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
final String name = "Thread " + i;
final int sleepTime = new Random().nextInt(10);
Callable<String> callable = new Callable<String>() {
@Override
public String call() throws Exception {
System.out.println("begin " + name);
TimeUnit.SECONDS.sleep(sleepTime);
return name;
}
};
callableList.add(callable);
}
List<Future<String>> futureList = executorService.invokeAll(callableList, 5, TimeUnit.SECONDS);
for (int i = 0; i < futureList.size(); i++) {
if (!futureList.get(i).isCancelled()) {
System.out.println(futureList.get(i).get());
} else {
System.out.println(callableList);
}
}
}
}
TestThreadInterrupt
/**
* interrupt结论:
* 1 interrupt() 可以中断线程;
* 2 Thread.sleep() wait() /join()方法 检测到线程中断后,会抛出 InterruptedException 异常,然后清除中断状态(),线程回到正常状态
* 3 Thread.interrupted() 判断当前线程状态,若未中断状态则返回true,并清除中断状态,线程回到正常状态; 若未中断,返回false,不去中断线程;
* 4 Thread.currentThread().isInterrupted() 仅判断当前线程状态,若中断返回true,否则返回false;
*interrupt 使用步骤:
*1 制定中断策略
*2 在合适地方中断线程,interrupt()
*3 在业务流程决策点判断 线程中断状态
*4 捕获线程中断异常,处理中断逻辑
*/
public class TestThreadInterrupt {
public static void main(String[] args) throws InterruptedException {
MyRunnable myRunnable = new MyRunnable("Thread test");
Thread t1 = new Thread(myRunnable);
t1.start();
Thread.sleep(10000l);
t1.interrupt();
}
static class MyRunnable implements Runnable {
private String name;
public MyRunnable(String name) {
this.name = name;
}
@Override
public void run() {
int i = 0;
System.out.println("begin thread " + name);
while (i < 10 && !Thread.currentThread().isInterrupted()) {
try {
TimeUnit.SECONDS.sleep(2);
i++;
System.out.println("finish loop " + i);
} catch (InterruptedException e) {
System.out.println("Thread " + name + " loop " + i + " encounter InterruptedException , and interrupt status: " + Thread.currentThread().isInterrupted());
System.out.println("after interruptedException check, thread isInterrupted() = " + Thread.currentThread().isInterrupted());
boolean interruptedFlag = Thread.interrupted();
System.out.println("after interrupted() once , thread isInterrupted() = " + Thread.currentThread().isInterrupted() + ", interruptedFlag = " + interruptedFlag);
interruptedFlag = Thread.interrupted();
System.out.println("after interrupted() twice , thread isInterrupted() = " + Thread.currentThread().isInterrupted() + ", interruptedFlag = " + interruptedFlag);
Thread.currentThread().interrupt();
System.out.println("after interrupt() , thread isInterrupted() = " + Thread.currentThread().isInterrupted() );
interruptedFlag = Thread.interrupted();
System.out.println(" interrupted() after interrupted(), interruptedFlag = " + interruptedFlag + ",thread isInterrupted() = " + Thread.currentThread().isInterrupted() );
}
}
System.out.println("end thread " + name);
}
}
}