Executors框架创建线程池

一、线程池的简介
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。

二、图解线程池的流程

三、线程池的六个基本要素
(1).任务队列：用来存放多余的任务，例如有10个任务交给线程池处理，但是线程池一次性只能有6个线程处理任务，那多出来的4个任务就放在任务队列中。
(2).线程池: 管理线程 initThread <= coreThread <= maxThread。
(3)拒绝策略：当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略。
(4)线程工厂
(5)任务队列的大小
(6).时间间隔

四、Executors创建的4种线程池的使用
①首先创建一个工作类(任务)，让线程可以介绍并且执行任务

package ThreadPool;

/**
 * @author czd
 */
public class Worker implements  Runnable {
    private String name;
    public Worker(String name){
        this.name = name;
    }


    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始执行任务  任务编号: -->" + name);
        try {
            Thread.sleep(1000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "完成任务   任务编号:-->" + name);
    }
}

② newCachedThreadPool
创建一个可缓存线程池，应用中存在的线程数可以无限大

package ThreadPool;

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

/**
 * @author czd
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        //创建pool
        //创建一个可缓存线程池，应用中存在的线程数可以无限大
        ExecutorService pool = Executors.newCachedThreadPool();
        //创建一定数量的任务
        //pool接收任务并且执行
        for (int i = 1; i <= 10; i++){
            Worker worker = new Worker(i + "");
            pool.execute(worker);
        }
        //关闭pool
        pool.shutdown();

        while (!pool.isTerminated()){
            //自旋
        }
        System.out.println("全部任务完成!");
    }
}

输出结果

③newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

package ThreadPool;

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

/**
 * @author czd
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        //创建pool
        //创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
        ExecutorService pool = Executors.newFixedThreadPool(5);
        //创建一定数量的任务
        //pool接收任务并且执行
        for (int i = 1; i <= 10; i++){
            Worker worker = new Worker(i + "");
            pool.execute(worker);
        }
        //关闭pool
        pool.shutdown();

        while (!pool.isTerminated()){
            //自旋
        }
        System.out.println("全部任务完成!");
    }
}

输出结果

④newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行

package ThreadPool;

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

/**
 * @author czd
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        //创建pool
        //创建一个定长线程池，支持定时及周期性任务执行
        ExecutorService pool = Executors.newScheduledThreadPool(6);
        //创建一定数量的任务
        //pool接收任务并且执行
        for (int i = 1; i <= 10; i++){
            Worker worker = new Worker(i + "");
            //没有延迟，两秒执行一次任务
//            ((ScheduledExecutorService) pool).scheduleAtFixedRate(worker,0,2, TimeUnit.SECONDS);
            //1秒后执行任务，两秒执行一次任务
            ((ScheduledExecutorService) pool).scheduleAtFixedRate(worker,1,2, TimeUnit.SECONDS);
            pool.execute(worker);
        }
        //关闭pool
        pool.shutdown();

        while (!pool.isTerminated()){
            //自旋
        }
        System.out.println("全部任务完成!");
    }
}

输出结果：延迟1秒之后执行，除了延迟执行之外和newFixedThreadPool基本相同，可以用来执行定时任务

⑤newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务

package ThreadPool;

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

/**
 * @author czd
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        //创建pool
        //创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
        ExecutorService pool = Executors.newSingleThreadExecutor();
        //创建一定数量的任务
        //pool接收任务并且执行
        for (int i = 1; i <= 10; i++){
            Worker worker = new Worker(i + "");
            pool.execute(worker);
        }
        //关闭pool
        pool.shutdown();

        while (!pool.isTerminated()){
            //自旋
        }
        System.out.println("全部任务完成!");
    }
}

输出结果