java并发原理实战(13)--线程池和Executors

线程池

一. 线程池简介

1. 线程池的概念：
2. 线程池的工作机制
3. 使用线程池的原因：

二. 5种常见的线程池详解

1. 线程池的返回值ExecutorService简介：
2. 具体的5种常用的线程池实现如下：（返回值都是ExecutorService）

①Executors.newCacheThreadPool()：
② Executors.newFixedThreadPool(int n)：
③Executors.newScheduledThreadPool(int n)
④ Executors.newSingleThreadExecutor()：
⑤ Executors.newWorkStealingPool()：

三. 缓冲队列BlockingQueue和自定义线程池ThreadPoolExecutor

1.缓冲队列BlockingQueue简介：
2.常用的几种BlockingQueue：
3.自定义线程池（ThreadPoolExecutor和BlockingQueue连用）：

一. 线程池简介

1. 线程池的概念：

线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

2. 线程池的工作机制

在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。

一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

3. 使用线程池的原因：

多线程运行时间，系统不断的启动和关闭新线程，成本非常高，会过渡消耗系统资源，以及过渡切换线程的危险，从而可能导致系统资源的崩溃。这时，线程池就是最好的选择了。

二. 5种常见的线程池详解

1. 线程池的返回值ExecutorService简介：

ExecutorService是Java提供的用于管理线程池的接口。该接口的两个作用：控制线程数量和重用线程

2. 具体的5种常用的线程池实现如下：（返回值都是ExecutorService）

①Executors.newCacheThreadPool()：

可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务

示例代码：

import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 public class ThreadPoolExecutorTest {
     public static void main(String[] args) {
         //创建一个可缓存线程池
         ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
         for (int i = 0; i < 10; i++) {
             try {
                 //sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             cachedThreadPool.execute(new Runnable() {
                 public void run() {
                     //打印正在执行的缓存线程信息
                     System.out.println(Thread.currentThread().getName()+"正在被执行");
                 }
             });
         }
     }
 }

输出结果：

pool-1-thread-1正在被执行

线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程

② Executors.newFixedThreadPool(int n)：

创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。

示例代码：

import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 public class ThreadPoolExecutorTest {
     public static void main(String[] args) {
         //创建一个可重用固定个数的线程池
         ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
         for (int i = 0; i < 10; i++) {
             fixedThreadPool.execute(new Runnable() {
                 public void run() {
                     try {
                         //打印正在执行的缓存线程信息
                         System.out.println(Thread.currentThread().getName()+"正在被执行");
                         Thread.sleep(2000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             });
         }
     }
 }

输出结果：

pool-1-thread-1正在被执行

pool-1-thread-2正在被执行

pool-1-thread-3正在被执行

pool-1-thread-1正在被执行

pool-1-thread-2正在被执行

pool-1-thread-3正在被执行

pool-1-thread-1正在被执行

pool-1-thread-2正在被执行

pool-1-thread-3正在被执行

pool-1-thread-1正在被执行

因为线程池大小为3，每个任务输出打印结果后sleep 2秒，所以每两秒打印3个结果。

定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

③Executors.newScheduledThreadPool(int n)

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

延迟执行示例代码：

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

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟1秒执行
        scheduledThreadPool.schedule(new Runnable() {
            public void run() {
                System.out.println("延迟1秒执行");
            }
        }, 1, TimeUnit.SECONDS);
    }
}

输出结果：延迟1秒执行

定期执行示例代码：

import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
 public class ThreadPoolExecutorTest {
     public static void main(String[] args) {
         //创建一个定长线程池，支持定时及周期性任务执行——定期执行
         ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
         //延迟1秒后每3秒执行一次
         scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
             public void run() {
                 System.out.println("延迟1秒后每3秒执行一次");
             }
         }, 1, 3, TimeUnit.SECONDS);
     }
 }

输出结果：

延迟1秒后每3秒执行一次

…

④ Executors.newSingleThreadExecutor()：

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

示例代码：

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

public class TestThreadPoolExecutor {
    public static void main(String[] args) {
        //创建一个单线程化的线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                public void run() {
                    try {
                        //结果依次输出，相当于顺序执行各个任务
                        System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

pool-1-thread-1正在被执行,打印的值是:0

pool-1-thread-1正在被执行,打印的值是:1

pool-1-thread-1正在被执行,打印的值是:2

pool-1-thread-1正在被执行,打印的值是:3

pool-1-thread-1正在被执行,打印的值是:4

pool-1-thread-1正在被执行,打印的值是:5

pool-1-thread-1正在被执行,打印的值是:6

pool-1-thread-1正在被执行,打印的值是:7

pool-1-thread-1正在被执行,打印的值是:8

pool-1-thread-1正在被执行,打印的值是:9

⑤ Executors.newWorkStealingPool()：

jdk1.8新增的：每个线程都有要处理的队列中的任务，如果其中的线程完成自己队列中的任务，

那么它可以去其他线程中获取其他线程的任务去执行

import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
/**
 * 线程池
 *    1.固定个数的线程池
 *    2.缓存线程池，开始线程数0
 *         如果需要线程，当前线程池没有，那么创建线程池
 *         如果需要线程，线程池中有没有使用的线程，那么使用已经存在的线程
 *         如果线程池中线程超过60秒(默认)没有使用，那么该线程停止
 *    3.只有1个线程的线程池
 *         保证线程执行的先后顺序
 *    4.ScheduledPool
 *          和DelayedQueue类似,定时执行
 *    5.WorkStealingPool(任务窃取，都是守护线程)
 *          每个线程都有要处理的队列中的任务，如果其中的线程完成自己队列中的任务，
 *          那么它可以去其他线程中获取其他线程的任务去执行
 */
public class Demo {
    /*
        4
        1000:ForkJoinPool-1-worker-1
        1000:ForkJoinPool-1-worker-0
        2000:ForkJoinPool-1-worker-2
        3000:ForkJoinPool-1-worker-3
        2000:ForkJoinPool-1-worker-1
        public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }
     */
    public static void main(String[] args) throws IOException {
        // 根据cpu是几核来开启几个线程
        ExecutorService service = Executors.newWorkStealingPool();
        // 查看当前计算机是几核
        System.out.println(Runtime.getRuntime().availableProcessors());
        service.execute(new R(1000));
        service.execute(new R(2000));
        service.execute(new R(3000));
        service.execute(new R(1000));
        service.execute(new R(2000));
 
        // WorkStealing是精灵线程(守护线程、后台线程)，主线程不阻塞，看不到输出。
        // 虚拟机不停止，守护线程不停止
        System.in.read();
    }
 
    static class R implements Runnable {
        int time;
 
        public R(int time) {
            this.time = time;
        }
 
        @Override
        public void run() {
            try {
                TimeUnit.MILLISECONDS.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(time + ":" + Thread.currentThread().getName());
        }
    }
}

三. 缓冲队列BlockingQueue和自定义线程池ThreadPoolExecutor

1.缓冲队列BlockingQueue简介：

BlockingQueue是双缓冲队列。BlockingQueue内部使用两条队列，允许两个线程同时向队列一个存储，一个取出操作。在保证并发安全的同时，提高了队列的存取效率。

2.常用的几种BlockingQueue：

ArrayBlockingQueue（int i）:规定大小的BlockingQueue，其构造必须指定大小。其所含的对象是FIFO顺序排序的。
LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。
PriorityBlockingQueue（）或者（int i）:类似于LinkedBlockingQueue，但是其所含对象的排序不是FIFO，而是依据对象的自然顺序或者构造函数的Comparator决定。
SynchronizedQueue（）:特殊的BlockingQueue，对其的操作必须是放和取交替完成。

3.自定义线程池（ThreadPoolExecutor和BlockingQueue连用）：

自定义线程池，可以用ThreadPoolExecutor类创建，它有多个构造方法来创建线程池。

常见的构造函数：ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue)

示例代码：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

class TempThread implements Runnable {

    @Override
    public void run() {
        // 打印正在执行的缓存线程信息
        System.out.println(Thread.currentThread().getName() + "正在被执行");
        try {
            // sleep一秒保证3个任务在分别在3个线程上执行
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

public class TestThreadPoolExecutor {
    public static void main(String[] args) {
        // 创建数组型缓冲等待队列
        BlockingQueue<Runnable> bq = new ArrayBlockingQueue<Runnable>(10);
        // ThreadPoolExecutor:创建自定义线程池，池中保存的线程数为3，允许最大的线程数为6
        ThreadPoolExecutor tpe = new ThreadPoolExecutor(3, 6, 50, TimeUnit.MILLISECONDS, bq);

        // 创建3个任务
        Runnable t1 = new TempThread();
        Runnable t2 = new TempThread();
        Runnable t3 = new TempThread();
        // Runnable t4 = new TempThread();
        // Runnable t5 = new TempThread();
        // Runnable t6 = new TempThread();

        // 3个任务在分别在3个线程上执行
        tpe.execute(t1);
        tpe.execute(t2);
        tpe.execute(t3);
        // tpe.execute(t4);
        // tpe.execute(t5);
        // tpe.execute(t6);

        // 关闭自定义线程池
        tpe.shutdown();
    }
}

输出结果：

java并发原理实战(13)--线程池和Executors

线程池

一. 线程池简介

1. 线程池的概念：

2. 线程池的工作机制

3. 使用线程池的原因：

二. 5种常见的线程池详解

1. 线程池的返回值ExecutorService简介：

2. 具体的5种常用的线程池实现如下：（返回值都是ExecutorService）

①Executors.newCacheThreadPool()：

② Executors.newFixedThreadPool(int n)：

③Executors.newScheduledThreadPool(int n)

④ Executors.newSingleThreadExecutor()：

⑤ Executors.newWorkStealingPool()：

三. 缓冲队列BlockingQueue和自定义线程池ThreadPoolExecutor

1.缓冲队列BlockingQueue简介：

2.常用的几种BlockingQueue：

3.自定义线程池（ThreadPoolExecutor和BlockingQueue连用）：

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method