多线程系列--线程池--Executors

简介

常见线程池种类

种类

核心线程数

最大线程数

描述

SingleThreadPool

1

1

只一个线程在工作,相当于单线程顺序串行执行所有任务。

FixedThreadPool

存在

无(虽然有但实际不起作用)

 

CachedThreadPool

0

无限大

动态增删线程数

ScheduleThreadPool

存在

无限大

周期性执行任务

常用方法

方法

作用

说明

ThreadPoolExecutor参数

newFixed

ThreadPool

创建固定大小的线程池。

每提交一个任务就创建一个线程,直到线程数到线程池的最大数

线程池的大小一旦达到最大值就会保持不变。

若某线程因异常而结束,线程池会补充一个新线程。

nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()

//nThreads是传进来的参数

newSingle

ThreadExecutor

创建一个单线程的线程池。

 

只一个线程在工作,相当于单线程串行执行所有任务。

若这个唯一的线程因为异常结束,会有一个新的线程来替代它。

此线程池保证所有任务的执行顺序按照任务的提交顺序执行

1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()

newSingleThread

ScheduledExecutor

创建一个单线程的定时线程池。

此线程池支持定时以及周期性执行任务的需求。

return new DelegatedScheduledExecutorService

(newScheduledThreadPoolExecutor(1));

newCached

ThreadPool

创建一个可缓存的线程池。

 

若线程池的数量超过了处理任务所需要的线程,就回收部分空闲(60秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添加新线程来处理任务。

此线程池大小为Integer的最大值。

0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>()

newScheduled

ThreadPool

创建一个固定大小的定时线程池。

此线程池支持定时以及周期性执行任务的需求。

其他网址:https://www.jianshu.com/p/925dba9f5969

corePoolSize, Integer.MAX_VALUE,

0, NANOSECONDS,
new DelayedWorkQueue()

//corePoolSize是传进来的参数

这些方法的返回值是ExecutorService对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。

FixedThreadPool

简介

FixedThreadPool的execute流程

参考网址:线程池的几种实现方式 - 简书

对上图的说明如下。

  1)如果当前运行的线程数少于corePoolSize(即线程池中无运行的线程),则创建一个新线程来执行任务。
  2)在线程池完线程的创建之后,将任务加入Linked- BlockingQueue。
  3)线程会在一个无限循环中反复从LinkedBlockingQueue获取任务来执行。

        FixedThreadPool使用无界队列LinkedBlockingQueue作为线程池的工作队列(队列的容量为 Integer.MAX_VALUE)。使用无界队列作为工作队列会对线程池带来如下影响:

1)线程池中的线程数达到corePoolSize后,新任务将在无界队列中等待,因此线程池中的线程数不会超过corePoolSize。
2)由于1,使用无界队列时maximumPoolSize将是一个无效参数。 
3)由于1和2,使用无界队列时keepAliveTime将是一个无效参数。
4)由于使用无界队列,运行中的FixedThreadPool(未执行方法shutdown()或 shutdownNow())不会拒绝任务(不会调用RejectedExecutionHandler.rejectedExecution方法)。

实例

package org.example.a;

import java.util.concurrent.*;

class MyTask implements Runnable {
    private int taskNum;

    public MyTask(int num) {
        this.taskNum = num;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " " + "正在执行task "+taskNum);
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " " + "-------------------执行task "+taskNum + " 完毕!!!");
    }
}

public class Demo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for(int i=0;i<6;i++){
            MyTask myTask = new MyTask(i);
            executor.execute(myTask);
        }
        executor.shutdown();
    }
}

执行结果

pool-1-thread-2 正在执行task 1
pool-1-thread-3 正在执行task 2
pool-1-thread-1 正在执行task 0
pool-1-thread-3 -------------------执行task 2 完毕!!!
pool-1-thread-3 正在执行task 3
pool-1-thread-2 -------------------执行task 1 完毕!!!
pool-1-thread-2 正在执行task 4
pool-1-thread-1 -------------------执行task 0 完毕!!!
pool-1-thread-1 正在执行task 5
pool-1-thread-1 -------------------执行task 5 完毕!!!
pool-1-thread-3 -------------------执行task 3 完毕!!!
pool-1-thread-2 -------------------执行task 4 完毕!!!

SingleThreadPool

简介

SingleThreadPool的execute流程

参考网址:线程池的几种实现方式 - 简书

对上图的说明如下。

    1)如果当前运行的线程数少于corePoolSize(即线程池中无运行的线程),则创建一个新线程来执行任务。
    2)在线程池完线程的创建之后,将任务加入Linked- BlockingQueue。
    3)线程会在一个无限循环中反复从LinkedBlockingQueue获取任务来执行。

实例

package org.example.a;

import java.util.concurrent.*;

class MyTask implements Runnable {
    private int taskNum;

    public MyTask(int num) {
        this.taskNum = num;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " " + "正在执行task "+taskNum);
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " " + "-------------------执行task "+taskNum + " 完毕!!!");
    }
}

public class Demo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        for(int i=0;i<6;i++){
            MyTask myTask = new MyTask(i);
            executor.execute(myTask);
        }
        executor.shutdown();
    }
}

执行结果

pool-1-thread-1 正在执行task 0
pool-1-thread-1 -------------------执行task 0 完毕!!!
pool-1-thread-1 正在执行task 1
pool-1-thread-1 -------------------执行task 1 完毕!!!
pool-1-thread-1 正在执行task 2
pool-1-thread-1 -------------------执行task 2 完毕!!!
pool-1-thread-1 正在执行task 3
pool-1-thread-1 -------------------执行task 3 完毕!!!
pool-1-thread-1 正在执行task 4
pool-1-thread-1 -------------------执行task 4 完毕!!!
pool-1-thread-1 正在执行task 5
pool-1-thread-1 -------------------执行task 5 完毕!!!

CachedThreadPool

简介

CachedThreadPool的execute流程

参考网址:线程池的几种实现方式 - 简书

对上图的说明如下。

        首先执行SynchronousQueue.offer(Runnable task)。如果当前maximumPool中有空闲线程正在执行      
 SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS),那么主线程执行offer操作与空闲线程执行的poll操作配对成功,主线程把任务交给空闲线程执行,execute()方法执行完成;否则执行下面的步骤

        当初始maximumPool为空,或者maximumPool中当前没有空闲线程时,将没有线程执行 
SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)。这种情况下,步骤(1)将失败。此时CachedThreadPool会创建一个新线程执行任务,execute()方法执行完成。

        在步骤(2)中新创建的线程将任务执行完后,会执行 SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)。这个poll操作会让空闲线程最多在SynchronousQueue中等待60秒钟。如果60秒钟内主线程提交了一个新任务(主线程执行步骤(1)),那么这个空闲线程将执行主线程提交的新任务;否则,这个空闲线程将终止。由于空闲60秒的空闲线程会被终止,因此长时间保持空闲的CachedThreadPool不会使用任何资源。

        前面提到过,SynchronousQueue是一个没有容量的阻塞队列。每个插入操作必须等待另一个线程的对应移除操作,反之亦然。CachedThreadPool使用SynchronousQueue,把主线程提交的任务传递给空闲线程执行。CachedThreadPool中任务传递的示意图如图所示。

CachedThreadPool是一个会根据需要创建新线程的线程池。下面是创建CachedThreadPool的源代码。
public static ExecutorService newCachedThreadPool() {     
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,new SynchronousQueue());
}
        CachedThreadPool的corePoolSize被设置为0,即corePool为空;maximumPoolSize被设置为 Integer.MAX_VALUE,即maximumPool是无界的。这里把keepAliveTime设置为60L,意味着 CachedThreadPool中的空闲线程等待新任务的最长时间为60秒,空闲线程超过60秒后将会被终止。
        FixedThreadPool和SingleThreadExecutor使用无界队列LinkedBlockingQueue作为线程池的工作队列。CachedThreadPool使用没有容量的SynchronousQueue作为线程池的工作队列,但 CachedThreadPool的maximumPool是无界的。这意味着,如果主线程提交任务的速度高于 maximumPool中线程处理任务的速度时,CachedThreadPool会不断创建新线程。极端情况下, 
CachedThreadPool会因为创建过多线程而耗尽CPU和内存资源

SingleScheduledExecutorService

简介

其他网址

ScheduledExecutorService的scheduleAtFixedRate和scheduleWithFixedDelay方法的区别_18875541的博客-CSDN博客

另见:《Java并发编程之美》=> 第9章 Java 并发包中ScheduledThreadPoolExecutor 原理探究

方法 说明 备注
scheduleAtFixedRate 以上一次任务的开始时间为间隔的,并且当任务执行时间大于设置的间隔时间时,真正间隔的时间由任务执行时间为准 scheduleAtFixedRate和scheduleWithFixedRate第2个参数:延时多长时间之后运行第一次任务
scheduleWithFixedDelay 以上次任务的结束时间为间隔,即:上一个任务结束后,延时定义的时间间隔,然后再次执行。

实例

程序1:(间隔时间(3s)大于任务的执行时间(1s))

package org.example.a;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.*;

class MyTask implements Runnable {
    @Override
    public void run() {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
            System.out.println(sdf.format(new Date()) + " " + "正在执行task");
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-------------------执行task " + " 完毕!!!");
    }
}

public class Demo {
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        executor.scheduleAtFixedRate(new MyTask(), 0, 3, TimeUnit.SECONDS);
        // executor.scheduleWithFixedRate(new MyTask(), 0, 3, TimeUnit.SECONDS);
        //不能加这句
        //executor.shutdown();
    }
}

运行结果

scheduleAtFixedRate:可见,每3秒运行一次

22:54:15 正在执行task
-------------------执行task  完毕!!!
22:54:18 正在执行task
-------------------执行task  完毕!!!
22:54:21 正在执行task
-------------------执行task  完毕!!!
22:54:24 正在执行task
-------------------执行task  完毕!!!
22:54:27 正在执行task
-------------------执行task  完毕!!!
22:54:30 正在执行task
-------------------执行task  完毕!!!
22:54:33 正在执行task
-------------------执行task  完毕!!!

 scheduleWithFixedRate:可见,每4秒运行一次

23:04:08 正在执行task
-------------------执行task  完毕!!!
23:04:12 正在执行task
-------------------执行task  完毕!!!
23:04:16 正在执行task
-------------------执行task  完毕!!!
23:04:20 正在执行task
-------------------执行task  完毕!!!
23:04:24 正在执行task
-------------------执行task  完毕!!!
23:04:28 正在执行task

程序2 :(间隔时间(3s)小于任务的执行时间(4s))

package org.example.a;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.*;

class MyTask implements Runnable {
    @Override
    public void run() {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
            System.out.println(sdf.format(new Date()) + " " + "正在执行task");
            Thread.currentThread().sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-------------------执行task " + " 完毕!!!");
    }
}

public class Demo {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        executor.scheduleAtFixedDelay(new MyTask(), 0, 3, TimeUnit.SECONDS);
        //executor.scheduleWithFixedDelay(new MyTask(), 0, 3, TimeUnit.SECONDS);
        //这句不要写
        //executor.shutdown();
    }
}

运行结果

scheduleAtFixedRate:可见,此时间隔时间失效,会以任务执行时间为准。上一个任务一结束就开始下一个任务

22:58:53 正在执行task
-------------------执行task  完毕!!!
22:58:57 正在执行task
-------------------执行task  完毕!!!
22:59:01 正在执行task
-------------------执行task  完毕!!!
22:59:05 正在执行task
-------------------执行task  完毕!!!
22:59:09 正在执行task
-------------------执行task  完毕!!!

 scheduleWithFixedRate:

23:08:31 正在执行task
-------------------执行task  完毕!!!
23:08:38 正在执行task
-------------------执行task  完毕!!!
23:08:45 正在执行task
-------------------执行task  完毕!!!
23:08:52 正在执行task
-------------------执行task  完毕!!!
23:08:59 正在执行task
-------------------执行task  完毕!!!

异常处理

        若程序中捕获了异常,则不影响下一个任务执行,若不捕获,则会影响下一个任务执行。

程序1:不捕获异常

package org.example.a;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.*;

class MyTask implements Runnable {
    int i = 0;
    int[] a = {1, 2, 3};
    @Override
    public void run() {
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        System.out.println(sdf.format(new Date()) + " " + "正在执行task");
        System.out.println(a[i++]);
        System.out.println("-------------------执行task " + " 完毕!!!");
    }
}

public class Demo {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        executor.scheduleWithFixedDelay(new MyTask(), 0, 1, TimeUnit.SECONDS);
        //这句不要写
        //executor.shutdown();
    }
}

运行结果(异常后,直接卡死)

23:15:28 正在执行task
1
-------------------执行task  完毕!!!
23:15:29 正在执行task
2
-------------------执行task  完毕!!!
23:15:30 正在执行task
3
-------------------执行task  完毕!!!
23:15:31 正在执行task

程序2:捕获异常

package org.example.a;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.*;

class MyTask implements Runnable {
    int i = 0;
    int[] a = {1, 2, 3};
    @Override
    public void run() {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
            System.out.println(sdf.format(new Date()) + " " + "正在执行task");
            System.out.println(a[i++]);
            System.out.println("-------------------执行task " + " 完毕!!!");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

public class Demo {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        executor.scheduleWithFixedDelay(new MyTask(), 0, 1, TimeUnit.SECONDS);
        //这句不要写
        //executor.shutdown();
    }
}

执行结果(一直往下执行)

23:17:10 正在执行task
1
-------------------执行task  完毕!!!
23:17:11 正在执行task
2
-------------------执行task  完毕!!!
23:17:12 正在执行task
3
-------------------执行task  完毕!!!
23:17:13 正在执行task
java.lang.ArrayIndexOutOfBoundsException: 3
	at org.example.a.MyTask.run(Demo.java:15)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
	at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:308)
	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:180)
	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:294)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
23:17:14 正在执行task
java.lang.ArrayIndexOutOfBoundsException: 4
	at org.example.a.MyTask.run(Demo.java:15)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
	at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:308)
	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:180)
	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:294)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
23:17:15 正在执行task
java.lang.ArrayIndexOutOfBoundsException: 5
	at org.example.a.MyTask.run(Demo.java:15)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
	at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:308)
	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:180)
	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:294)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)

 

MySQL数据库从入门实战课

12-31
限时福利1:购课进答疑群专享柳峰(刘运强)老师答疑服务。 限时福利2:购课后添加学习助手(微信号:csdn590),按消息提示即可领取编程大礼包! 注意:原价129的课程,最后2天限时秒杀仅需49元!! 为什么说每一个程序员都应该学习MySQL? 根据《2019-2020年中国开发者调查报告》显示,超83%的开发者都在使用MySQL数据库。 使用量大同时,掌握MySQL早已是运维、DBA的必备技能,甚至部分IT开发岗位也要求对数据库使用和原理有深入的了解和掌握。 学习编程,你可能会犹豫选择 C++ 还是 Java;入门数据科学,你可能会纠结于选择 Python 还是 R;但无论如何, MySQL 都是 IT 从业人员不可或缺的技能! 【课程设计】 在本课程中,刘运强老师会结合自己十多年来对MySQL的心得体会,通过课程给你分享一条高效的MySQL入门捷径,让学员少走弯路,彻底搞懂MySQL。 本课程包含3大模块:  一、基础篇: 主要以最新的MySQL8.0安装为例帮助学员解决安装与配置MySQL的问题,并对MySQL8.0的新特性做一定介绍,为后续的课程展开做好环境部署。 二、SQL语言篇: 本篇主要讲解SQL语言的四大部分数据查询语言DQL,数据操纵语言DML,数据定义语言DDL,数据控制语言DCL,学会熟练对库表进行增删改查等必备技能。 三、MySQL进阶篇: 本篇可以帮助学员更加高效的管理线上的MySQL数据库;具备MySQL的日常运维能力,语句调优、备份恢复等思路。  
©️2020 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值