Java多线程
一、简介
1、什么是进程?什么是线程?
进程是:一个应用程序(1个进程是一个软件)。
线程是:一个进程中的执行场景/执行单元。
注意: 一个进程可以启动多个线程。
例子:
对于java程序来说,当在DOS命令窗口中输入:
java HelloWorld 回车之后。会先启动JVM,而JVM就是一个进程。
JVM再启动一个主线程调用main方法(main方法就是主线程)。
同时再启动一个垃圾回收线程负责看护,回收垃圾。
最起码,现在的java程序中至少有两个线程并发,一个是 垃圾回收线程,一个是 执行main方法的主线程。
2、进程和线程是什么关系?
进程:可以看做是现实生活当中的公司。
线程:可以看做是公司当中的某个员工。
注意:进程A和进程B的 内存独立不共享。
例子:
DNF游戏是一个进程
网易音乐是一个进程
这两个进程是独立的,不共享资源。
3、线程A和线程B是什么关系?
在java语言中:
线程A和线程B,堆内存 和 方法区 内存共享。但是 栈内存 独立,一个线程一个栈。
例子1:
假设启动10个线程,会有10个栈空间,每个栈和每个栈之间,互不干扰,各自执行各自的,这就是多线程并发。
例子2:
火车站,可以看做是一个进程。
火车站中的每一个售票窗口可以看做是一个线程。
我在窗口1购票,你可以在窗口2购票,你不需要等我,我也不需要等你。所以多线程并发可以提高效率。
java中之所以有多线程机制,目的就是为了 提高程序的处理效率。
4、思考一个问题
使用了多线程机制之后,main方法结束,是不是有可能程序也不会结束?
main方法结束只是主线程结束了,主栈空了,其它的栈(线程)可能还在压栈弹栈。
5.分析一个问题
对于单核的CPU来说,真的可以做到真正的多线程并发吗?
对于多核的CPU电脑来说,真正的多线程并发是没问题的。4核CPU表示同一个时间点上,可以真正的有4个进程并发执行。
单核的CPU表示只有一个大脑:
不能够做到真正的多线程并发,但是可以做到给人一种“多线程并发”的感觉。
对于单核的CPU来说,在某一个时间点上实际上只能处理一件事情,但是由于CPU的处理速度极快,多个线程之间频繁切换执行,给别人的感觉是:多个事情同时在做!!!
6、什么是真正的多线程并发?
t1线程执行t1的。
t2线程执行t2的。
t1不会影响t2,t2也不会影响t1。这叫做真正的多线程并发。
7、关于线程对象的生命周期
- 新建状态
- 就绪状态
- 运行状态
- 阻塞状态
- 死亡状态

二、多线程的实现方法
继承 Thread 类
通过继承 Thread 类实现多线程的步骤如下:
创建 MyThread 类,让其继承 Thread 类并重写 run() 方法。
创建 MyThread 类的实例对象,即创建一个新线程。
调用 start() 方法,启动线程。
java
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("我是通过继承 Thread 类创建的多线程,我叫" + Thread.currentThread().getName());
}
}
class TestMyThread {
public static void main(String[] args) {
MyThread myThread1 = new MyThread();
myThread1.setName("Thread-1");
MyThread myThread2 = new MyThread();
myThread2.setName("Thread-2");
MyThread myThread3 = new MyThread();
myThread3.setName("Thread-3");
myThread1.start();
myThread2.start();
myThread3.start();
}
}
为了演示线程执行顺序的随机性,我特意创建了三个线程,并为每一个线程命名,下面是我运行3次程序的执行结果:
java
// 第一次
我是通过继承 Thread 类创建的多线程,我叫Thread-2
我是通过继承 Thread 类创建的多线程,我叫Thread-1
我是通过继承 Thread 类创建的多线程,我叫Thread-3
// 第二次
我是通过继承 Thread 类创建的多线程,我叫Thread-1
我是通过继承 Thread 类创建的多线程,我叫Thread-3
我是通过继承 Thread 类创建的多线程,我叫Thread-2
// 第三次
我是通过继承 Thread 类创建的多线程,我叫Thread-1
我是通过继承 Thread 类创建的多线程,我叫Thread-3
我是通过继承 Thread 类创建的多线程,我叫Thread-2
从上面的执行结果我们可以看到线程的执行顺序和代码中编写的顺序没有关系,线程的执行顺序是具有随机性的。
实现 Runnable 接口
Runnable 接口只有一个 run() 方法,源码如下:
java
public interface Runnable {
public abstract void run();
}
通过实现 Runnable 接口实现多线程的步骤如下:
创建 MyRunnable 类实现 Runnable 接口。
创建 MyRunnable 类的实例对象 myRunnable 。
把实例对象 myRunnable 作为参数来创建 Thread 类的实例对象 thread,实例对象 thread 就是一个新线程。
调用 start() 方法,启动线程。
代码示例如下:
java
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("我是通过实现 Runnable 接口创建的多线程,我叫" + Thread.currentThread().getName());
}
}
class TestMyRunnable {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
}
}
执行结果如下:
java
我是通过实现 Runnable 接口创建的多线程,我叫Thread-0
相比于继承 Thread 类的方法来说,实现 Runnable 接口是一个更好地选择,因为 Java 不支持多继承,但是可以实现多个接口。
有一点值得注意的是 Thread 类也实现了 Runnable 接口,这意味着构造函数 Thread(Runnable target) 不仅可以传入 Runnable 接口的对象,而且可以传入一个 Thread 类的对象,这样就可以将一个 Thread 对象中的 run() 方法交由其他线程进行调用。
实现 Callable 接口
Callable 接口只有一个 call() 方法,源码如下:
java
public interface Callable<V> {
V call() throws Exception;
}
从源码我们可以看到 Callable 接口和 Runnable 接口类似,它们之间的区别在于 run() 方法没有返回值,而 call() 方法是有返回值的。
通过实现 Callable 接口实现多线程的步骤如下:
创建 MyCallable 类实现 Callable 接口。
创建 MyCallable 类的实例对象 myCallable。
把实例对象 myCallable 作为参数来创建 FutureTask 类的实例对象 futureTask。
把实例对象 futureTask 作为参数来创建 Thread 类的实例对象 thread,实例对象 thread 就是一个新线程。
调用 start() 方法,启动线程。
代码示例如下:
java
public class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int a = 6;
int b = 9;
System.out.println("我是通过实现 Callable 接口创建的多线程,我叫" + Thread.currentThread().getName());
return a + b;
}
}
class TestMyCallable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyCallable myCallable = new MyCallable();
FutureTask<Integer> futureTask = new FutureTask(myCallable);
Thread thread = new Thread(futureTask);
thread.start();
System.out.println("返回值为:" + futureTask.get());
}
}
执行结果如下:
java
我是通过实现 Callable 接口创建的多线程,我叫Thread-0
返回值为:15
FutureTask 类提供了一个 get() 方法用来获取 call() 方法的返回值,但需要注意的是调用这个方法会导致程序阻塞,必须要等到线程结束后才会得到返回值。
线程池
下边介绍
三、练习
1、抢红包
需求:

编写实现:
java
/**
* @author Salmon
* @date 2023/4/6 11:43
*/
public class MyThread extends Thread {
//共享数据
//100块,分成了3个包
static BigDecimal money = new BigDecimal("100");
static int count = 3;
//最小的中奖金额
static final BigDecimal MIN = new BigDecimal("0.01");
@Override
public void run() {
//同步代码块
synchronized (MyThread.class) {
if (count == 0) {
//判断共享数据是否到了末尾(已经到尾)
System.out.println(Thread.currentThread().getName() + "没抢到");
} else {
BigDecimal prize = BigDecimal.ZERO;
//判断共享数据是否到了末尾(没有到尾)
if (count == 1) {
prize = money;
} else {
double random = new Random().nextDouble(money.subtract(MIN.multiply(BigDecimal.valueOf(count - 1))).doubleValue());
prize = BigDecimal.valueOf(random).setScale(2, RoundingMode.HALF_UP);
}
if (prize.compareTo(MIN) < 0) {
prize = MIN;
}
System.out.println(getName() + "抢到了" + prize + "元");
count--;
money = money.subtract(prize);
}
}
}
}
编写测试类:
java
/**
* 抢红包
*
* @author Salmon
* @date 2023/4/6 11:39
*/
public class Test {
public static void main(String[] args) {
/**
抢红包也用到了多线程。
假设:100块,分成了3个包,现在有5个人去抢。
其中,红包是共享数据
5个人是5条线程。
打印结果如下:
XXX抢到了XXX元
XXX抢到了XXX元
XXX抢到了XXX元
XXX没抢到
XXX没抢到
*/
MyThread thread1 = new MyThread();
thread1.setName("小明");
thread1.start();
MyThread thread2 = new MyThread();
thread2.setName("小红");
thread2.start();
MyThread thread3 = new MyThread();
thread3.setName("小刚");
thread3.start();
MyThread thread4 = new MyThread();
thread4.setName("小李");
thread4.start();
MyThread thread5 = new MyThread();
thread5.setName("小黄");
thread5.start();
}
}
执行结果:

2、抽奖箱抽奖
需求:

编写实现:
java
/**
* @author Salmon
* @date 2023/4/6 12:31
*/
public class MyThread extends Thread {
ArrayList<Integer> prizePool;
public MyThread(ArrayList<Integer> prizePool) {
this.prizePool = prizePool;
}
@Override
public void run() {
while (true) {
synchronized (MyThread.class) {
if (prizePool.size() == 0) {
break;
}
Collections.shuffle(prizePool);
int prize = prizePool.remove(0);
System.out.println(getName() + "又产生了一个 " + prize + " 元大奖");
if (prizePool.size() == 0) {
break;
}
}
//使结果尽可能明显
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
编写测试类:
java
/**
* 抽奖箱抽奖
*
* @author Salmon
* @date 2023/4/6 12:32
*/
public class Test {
public static void main(String[] args) {
/**
有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为
{10,5,20,50,100,200,500,800,2,80,300,700};
创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”,“抽奖箱2”
随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
每次抽出一个奖项就打印一个(随机)
抽奖箱1 又产生了一个 10 元大奖
抽奖箱1 又产生了一个 100 元大奖
抽奖箱1 又产生了一个 200 元大奖
抽奖箱1 又产生了一个 800 元大奖
抽奖箱2 又产生了一个 700 元大奖
*/
//抽奖池
ArrayList<Integer> prizePool = new ArrayList<>();
Collections.addAll(prizePool, 10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700);
MyThread thread1 = new MyThread(prizePool);
thread1.setName("抽奖箱1");
thread1.start();
MyThread thread2 = new MyThread(prizePool);
thread2.setName("抽奖箱2");
thread2.start();
}
}
执行结果:

3、多线程统计并求最大值
需求:

编写实现:
java
/**
* @author Salmon
* @date 2023/4/6 13:28
*/
public class MyThread extends Thread{
ArrayList<Integer> prizePool;
public MyThread(ArrayList<Integer> prizePool) {
this.prizePool = prizePool;
}
@Override
public void run() {
ArrayList<Integer> result = new ArrayList<>();
while (true) {
synchronized (MyThread.class) {
if (prizePool.size() == 0) {
break;
}
Collections.shuffle(prizePool);
int prize = prizePool.remove(0);
result.add(prize);
if (prizePool.size() == 0) {
break;
}
}
//使结果尽可能明显
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
StringBuilder str = new StringBuilder();
int sum = 0, max = 0;
for (int i = 0; i < result.size(); i++) {
Integer current = result.get(i);
sum += current;
if (max < current) {
max = current;
}
String suffix = ",";
if (i == result.size() - 1) {
suffix = "";
}
str.append(current).append(suffix);
}
System.out.println("在此过程中," + getName() + "总共产生了" + result.size() + "个奖项\n分别为:"
+ str + "最高奖项为" + max + "元,总计额为" + sum + "元");
}
}
编写测试类:
java
/**
* 多线程统计并求最大值
*
* @author Salmon
* @date 2023/4/6 13:28
*/
public class Test {
public static void main(String[] args) {
/**
在上一题基础上继续完成如下需求:
每次抽的过程中,不打印,抽完时一次性打印(随机)在此次抽奖过程中,抽奖箱1总共产生了6个奖项。
例如:
分别为:10,20,100,500,2,300最高奖项为300元,总计额为932元在此次抽奖过程中,抽奖箱2总共产生了6个奖项。
分别为:5,50,200,800,80,700最高奖项为800元,总计额为1835元
*/
//抽奖池
ArrayList<Integer> prizePool = new ArrayList<>();
Collections.addAll(prizePool, 10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700);
MyThread thread1 = new MyThread(prizePool);
thread1.setName("抽奖箱1");
thread1.start();
MyThread thread2 = new MyThread(prizePool);
thread2.setName("抽奖箱2");
thread2.start();
}
}
执行结果:

4、多线程之间的比较
需求:

编写实现:
java
/**
* @author Salmon
* @date 2023/4/6 13:42
*/
public class MyCallable implements Callable<Integer> {
ArrayList<Integer> prizePool;
public MyCallable(ArrayList<Integer> prizePool) {
this.prizePool = prizePool;
}
@Override
public Integer call() throws Exception {
ArrayList<Integer> result = new ArrayList<>();
while (true) {
synchronized (MyCallable.class) {
if (prizePool.size() == 0) {
break;
}
Collections.shuffle(prizePool);
int prize = prizePool.remove(0);
result.add(prize);
if (prizePool.size() == 0) {
break;
}
}
//使结果尽可能明显
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
StringBuilder str = new StringBuilder();
int sum = 0, max = 0;
for (int i = 0; i < result.size(); i++) {
Integer current = result.get(i);
sum += current;
if (max < current) {
max = current;
}
String suffix = ",";
if (i == result.size() - 1) {
suffix = "";
}
str.append(current).append(suffix);
}
System.out.println("在此过程中," + Thread.currentThread().getName() + "总共产生了" + result.size() + "个奖项\n分别为:"
+ str + "最高奖项为" + max + "元,总计额为" + sum + "元");
return Collections.max(result);
}
}
编写测试类:
java
import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 多线程之间的比较
*
* @author Salmon
* @date 2023/4/6 13:42
*/
public class Test {
public static void main(String[] args) {
/**
在上一题基础上继续完成如下需求:
在此次抽奖过程中,抽奖箱1总共产生了6个奖项,分别为:10,20,100,500,2,300
最高奖项为300元,总计额为932元
在此次抽奖过程中,抽奖箱2总共产生了6个奖项,分别为:5,50,200,800,80,700
最高奖项为800元,总计额为1835元
在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元
以上打印效果只是数据模拟,实际代码运行的效果会有差异
*/
//抽奖池
ArrayList<Integer> prizePool = new ArrayList<>();
Collections.addAll(prizePool, 10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700);
//创建多线程要运行的参数对象
MyCallable mc = new MyCallable(prizePool);
//创建多线程运行结果的管理者对象
FutureTask<Integer> task1 = new FutureTask<>(mc);
FutureTask<Integer> task2 = new FutureTask<>(mc);
Thread thread1 = new Thread(task1);
thread1.setName("抽奖箱1");
thread1.start();
Thread thread2 = new Thread(task2);
thread2.setName("抽奖箱2");
thread2.start();
try {
String name = thread1.getName();
int max = task1.get();
Integer b = task2.get();
if (max < b) {
max = b;
name = thread2.getName();
}
System.out.println("在此次抽奖过程中," + name + "中产生了最大奖项,该奖项金额为" + max + "元");
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
执行结果:

四、线程池的创建方式
Java通过Executors创建线程池,分别为:
1、Executors.newCachedThreadPool()
创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程, 适用于服务器负载较轻,执行很多短期异步任务
java
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
2、Executors.newFixedThreadPool(3)
创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待,适用于可以预测线程数量的业务中,或者服务器负载较重,对当前线程数量进行限制。
java
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
3、Executors.newScheduledThreadPool(3)
创建一个定长线程池,支持定时及周期性任务执行,适用于需要多个后台线程执行周期任务的场景。
java
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}
4、newSingleThreadExecutor()
创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行,适用于需要保证顺序执行各个任务,并且在任意时间点,不会有多个线程时活动的场景。
java
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
5、Executors.newWorkStealingPool()
创建一个拥有多个任务队列的线程池,可以减少连接数,创建当前可用cpu数量的线程来并行执行,适用于大耗时的操作,可以并行来执行
java
public static ExecutorService newWorkStealingPool() {
return new ForkJoinPool
(Runtime.getRuntime().availableProcessors(),
ForkJoinPool.defaultForkJoinWorkerThreadFactory,
null, true);
}
线程池核心的参数
java
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
- corePoolSize 线程池核心线程大小
- maximumPoolSize 线程池最大线程数量
- keepAliveTime 空闲线程存活时间
- unit 空闲线程存活时间单位
- workQueue 工作队列
- threadFactory 线程工厂
- handler 拒绝策略
线程池四种拒绝任务策略
- 直接丢弃(DiscardPolicy)
- 丢弃队列中最早的任务(DiscardOldestPolicy)
- 抛异常(AbortPolicy)
- 将任务分给调用线程来执行(CallerRunsPolicy)
工作队列
①ArrayBlockingQueue
基于数组的有界阻塞队列,按FIFO排序。新任务进来后,会放到该队列的队尾,有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后,再有新任务进来,则会将任务放入该队列的队尾,等待被调度。如果队列已经是满的,则创建一个新线程,如果线程数量已经达到maxPoolSize,则会执行拒绝策略。
②LinkedBlockingQuene
基于链表的无界阻塞队列(其实最大容量为Interger.MAX),按照FIFO排序。由于该队列的近似无界性,当线程池中线程数量达到corePoolSize后,再有新任务进来,会一直存入该队列,而基本不会去创建新线程直到maxPoolSize(很难达到Interger.MAX这个数),因此使用该工作队列时,参数maxPoolSize其实是不起作用的。
③SynchronousQuene
一个不缓存任务的阻塞队列,生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时,不会缓存,而是直接被调度执行该任务,如果没有可用线程,则创建新线程,如果线程数量达到maxPoolSize,则执行拒绝策略。
④PriorityBlockingQueue
具有优先级的无界阻塞队列,优先级通过参数Comparator实现。
java
public PriorityBlockingQueue(int initialCapacity,
Comparator<? super E> comparator) {
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.lock = new ReentrantLock();
this.notEmpty = lock.newCondition();
this.comparator = comparator;
this.queue = new Object[initialCapacity];
}
测试ThreadPoolExecutor对线程的执行顺序及拒绝策略
测试ThreadPoolExecutor对线程的执行顺序及拒绝策略
java
import java.time.LocalTime;
import java.util.concurrent.*;
/**
* 测试ThreadPoolExecutor对线程的执行顺序
*
* @author Salmon
* @date 2023/4/6 13:58
*/
public class ThreadPoolTest {
public static void main(String[] args) {
//核心线程数
int corePoolSize = 3;
//最大线程数
int maximumPoolSize = 6;
//超过 corePoolSize 线程数量的线程最大空闲时间
long keepAliveTime = 2;
//以秒为时间单位
TimeUnit unit = TimeUnit.SECONDS;
//创建工作队列,用于存放提交的等待执行任务
BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(3);
ThreadPoolExecutor threadPoolExecutor = null;
//ExecutorService pool = Executors.newFixedThreadPool(5);
try {
//创建线程池
threadPoolExecutor = new ThreadPoolExecutor(corePoolSize,
maximumPoolSize,
keepAliveTime,
unit,
workQueue,
new ThreadPoolExecutor.CallerRunsPolicy());
//循环提交任务
for (int i = 0; i < 10; i++) {
//提交任务的索引
final int index = (i + 1);
threadPoolExecutor.submit(() -> {
//线程打印输出
System.out.println("【" + LocalTime.now() + "】线程 " + Thread.currentThread() + "正在执行任务" + index);
try {
//模拟线程执行时间
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
//每个任务提交后休眠500ms再提交下一个任务,用于保证提交顺序
Thread.sleep(500);
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
threadPoolExecutor.shutdown();
}
}
}
测试不同的拒绝策略:修改new ThreadPoolExecutor.CallerRunsPolicy();执行结果分别为:
java
CallerRunsPolicy
【10:31:33.086】线程 Thread[pool-1-thread-1,5,main]正在执行任务1
【10:31:33.545】线程 Thread[pool-1-thread-2,5,main]正在执行任务2
【10:31:34.056】线程 Thread[pool-1-thread-3,5,main]正在执行任务3
【10:31:36.103】线程 Thread[pool-1-thread-4,5,main]正在执行任务7
【10:31:36.609】线程 Thread[pool-1-thread-5,5,main]正在执行任务8
【10:31:37.116】线程 Thread[pool-1-thread-6,5,main]正在执行任务9
【10:31:37.625】线程 Thread[main,5,main]正在执行任务10
【10:31:38.090】线程 Thread[pool-1-thread-1,5,main]正在执行任务4
【10:31:38.557】线程 Thread[pool-1-thread-2,5,main]正在执行任务5
【10:31:39.070】线程 Thread[pool-1-thread-3,5,main]正在执行任务6
java
DiscardOldestPolicy
【10:35:34.600】线程 Thread[pool-1-thread-1,5,main]正在执行任务1
【10:35:35.034】线程 Thread[pool-1-thread-2,5,main]正在执行任务2
【10:35:35.544】线程 Thread[pool-1-thread-3,5,main]正在执行任务3
【10:35:37.581】线程 Thread[pool-1-thread-4,5,main]正在执行任务7
【10:35:38.091】线程 Thread[pool-1-thread-5,5,main]正在执行任务8
【10:35:38.600】线程 Thread[pool-1-thread-6,5,main]正在执行任务9
【10:35:39.617】线程 Thread[pool-1-thread-1,5,main]正在执行任务5
【10:35:40.035】线程 Thread[pool-1-thread-2,5,main]正在执行任务6
【10:35:40.546】线程 Thread[pool-1-thread-3,5,main]正在执行任务10
java
DisCardPolicy
【10:34:03.585】线程 Thread[pool-1-thread-1,5,main]正在执行任务1
【10:34:04.014】线程 Thread[pool-1-thread-2,5,main]正在执行任务2
【10:34:04.526】线程 Thread[pool-1-thread-3,5,main]正在执行任务3
【10:34:06.573】线程 Thread[pool-1-thread-4,5,main]正在执行任务7
【10:34:07.082】线程 Thread[pool-1-thread-5,5,main]正在执行任务8
【10:34:07.583】线程 Thread[pool-1-thread-6,5,main]正在执行任务9
【10:34:08.594】线程 Thread[pool-1-thread-1,5,main]正在执行任务4
【10:34:09.015】线程 Thread[pool-1-thread-2,5,main]正在执行任务5
【10:34:09.529】线程 Thread[pool-1-thread-3,5,main]正在执行任务6
java
AbortPolicy
【10:36:38.723】线程 Thread[pool-1-thread-1,5,main]正在执行任务1
【10:36:39.164】线程 Thread[pool-1-thread-2,5,main]正在执行任务2
【10:36:39.675】线程 Thread[pool-1-thread-3,5,main]正在执行任务3
【10:36:41.720】线程 Thread[pool-1-thread-4,5,main]正在执行任务7
【10:36:42.232】线程 Thread[pool-1-thread-5,5,main]正在执行任务8
【10:36:42.744】线程 Thread[pool-1-thread-6,5,main]正在执行任务9
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@77556fd rejected from java.util.concurrent.ThreadPoolExecutor@368239c8[Running, pool size = 6, active threads = 6, queued tasks = 3, completed tasks = 0]
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
at java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:112)
at com.formssi.mall.pay.application.ThreadPoolTest.main(ThreadPoolTest.java:44)
【10:36:43.725】线程 Thread[pool-1-thread-1,5,main]正在执行任务4
【10:36:44.178】线程 Thread[pool-1-thread-2,5,main]正在执行任务5
【10:36:44.678】线程 Thread[pool-1-thread-3,5,main]正在执行任务6
Process finished with exit code 1