25_线程池_几个常见的线程池

【线程池简述】

线程池中，当需要使用线程时，会从线程池中获取一个空闲线程，线程完成工作时，不会直接关闭线程，而是将这个线程退回到池子，方便其它人使用。

简而言之，使用线程池后，原来创建线程变成了从线程池获得空闲线程，关闭线程变成了向池子归还线程。

 

【线程池带来的好处】

1.降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的性能消耗。

2.提高响应速度，当任务到达时，任务可以不需要等待线程创建，可以直接执行。

3.提高线程的可管理性，线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

 

【线程池接口、类关系一览】 

 

【说明】

Executor是一个顶级接口，它里面只声明一个方法：execute(Runnable command)，用来执行传进去的任务。

ExecutorService接口继承了Executor接口，并声明了一些方法：submit、shutdown、invokeAll等。

AbstractExecutorService抽象类实现了ExecutorService接口，基本实现了ExecutorService接口的所有方法。

ThreadPoolExecutor继承了类AbstractExecutorService。

 

【Executors框架】

Executors框架提供了各种类型的线程池，主要有以下几种工厂方法：

[ newFixedThreadPool()方法 ]

该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变，当有一个新的任务提交时，线程池中若有空闲线程，则立即处理。

若没有空闲线程，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。

[ newSingleThreadExecutor()方法 ]

该方法返回一个只有一个线程的线程池。

若多多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出顺序执行任务。

[ newCachedThreadPool()方法 ]

该方法返回一个可具实际情况调整线程数量的线程池，线程池的线程数量不确定，但若有空闲线程可以复用，则会有优先使用而可以复用线程。若所有线程均在工作，又有新的任务提交，则会创建新的现场处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

[ newSingleThreadScheduledExecutor()方法 ]

该方法返回一个ScheduleExecutorService对象，线程池大小为1。

ScheduleExecutorService接口在ExecutorService接口之上扩张了在给定时间执行某任务的功能，如：在某个固定的延时之后执行，或者周期性执行某个任务。

[ newScheduleThreadPool()方法 ]

该方法返回一个ScheduleExecutorService对象，但该线程池可以指定线程数量。

 

【固定大小的线程池——newFixedThreadPool()】

package com.test.executor;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorDemo1 {
    
    public static void main(String[] args) {
        MyTask task = new MyTask();
        ExecutorService es = Executors.newFixedThreadPool(5);  //创建固定线程数大小为5的线程池
        for(int i=0;i<10;i++){   //依次向线程池提交了10个任务
            es.submit(task);
        }
    }
}

class MyTask implements Runnable{

    @Override
    public void run() {
        System.out.println(System.currentTimeMillis()+":Thread ID:"+Thread.currentThread().getId());
        try{
            Thread.sleep(1000); //1秒
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    
}

【运行结果】

 

【只有一个线程的线程池——newSingleThreadExecutor()】 

package com.test.executor;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by HigginCui on 2018/4/14.
 */
public class ExecutorDemo1 {

    public static void main(String[] args) {
        MyTask myTask = new MyTask();
        //只有一个线程的线程池
        ExecutorService es = Executors.newSingleThreadExecutor();
        for(int i=0;i<10;i++){
            es.submit(myTask);
        }
    }
}

class MyTask implements Runnable{
    @Override
    public void run() {
        System.out.println(System.currentTimeMillis()/1000 + ":Thread ID:" + Thread.currentThread().getId());
        try {
            Thread.sleep(1000);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

【运行结果】

 

【可根据实际情况调整线程数量的线程池——newCacheThreadPool()】

package com.test.executor;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by HigginCui on 2018/4/14.
 */
public class ExecutorDemo1 {

    public static void main(String[] args) {
        MyTask myTask = new MyTask();
        //可根据实际情况调整线程数量的线程池
        ExecutorService es = Executors.newCachedThreadPool();
        for(int i=0;i<10;i++){
            es.submit(myTask);
        }
    }
}

class MyTask implements Runnable{
    @Override
    public void run() {
        System.out.println(System.currentTimeMillis()/1000 + ":Thread ID:" + Thread.currentThread().getId());
        try {
            Thread.sleep(1000);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

【运行结果】

 

【计划定时任务——newScheduledThreadPool】

package com.test.executor;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * Created by HigginCui on 2018/4/14.
 */
public class ExecutorDemo1 {

    public static void main(String[] args) {

        ScheduledExecutorService ses = Executors.newScheduledThreadPool(10);
        /**
         * scheduleAtFixedRate方法 ：如果前面的任务没有完成，则调度也不会执行！
         * scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);
         */
        ses.scheduleAtFixedRate(new ScheduledTimeTask(), 0, 2, TimeUnit.SECONDS);  //设置每定时2s执行一次
    }

}

class ScheduledTimeTask implements Runnable {
    @Override
    public void run() {
        try {
            //修改这里的任务执行时间
            Thread.sleep(1000);
            System.out.println( System.currentTimeMillis() / 1000 + " : ThreadId = " + Thread.currentThread().getId());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

【设置任务的执行时间为1s（ <定时的2s ）的运行结果】

【设置任务的执行时间为3s（ <定时的2s ）的运行结果（即代码改成Thread.sleep(3000)）】

 

转载于:https://www.cnblogs.com/HigginCui/p/8686653.html