【2·基础知识】Java线程池
Java中创建线程的三种方式
1.通过继承Thread类并重写run方法（线程体和任务捆绑在一起）
2.通过实现Runnable接口并重写run方法（线程体和任务分离，相互独立）
3.实现Callable接口并重写call方法 & 使用FutureTask类包装Callable对象
通过继承Thread类并重写run方法
package com.biaogexf.tools.thread;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// Java创建线程的三种方式之一：继承Thread类并重写run方法
public class InheritThreadClass extends Thread {
// InheritThreadClass.class：可以打印出当前所在的类
private static final Logger log = LoggerFactory.getLogger(InheritThreadClass.class);
private int i = 0;
// 线程体
@Override
public void run() {
for (; i < 10; i++) {
log.info("{}-{}", i, Thread.currentThread().getName());
}
}
public static void main(String[] args) {
// 创建任务
InheritThreadClass taskOne = new InheritThreadClass();
InheritThreadClass taskTwo = new InheritThreadClass();
// 执行任务
taskOne.start();
taskTwo.start();
}
}
通过实现Runnable接口并重写run方法
package com.biaogexf.tools.thread;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ImplementRunnableTest implements Runnable {
private static final Logger log = LoggerFactory.getLogger(ImplementRunnableTest.class);
private int i = 0;
// 线程要执行的内容：任务
@Override
public void run() {
for (; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " is running: " + i);
}
}
public static void main(String[] args) {
// 任务(线程1 和 线程2的共享资源）
ImplementRunnableTest task = new ImplementRunnableTest();
new Thread(task, "线程1").start();
new Thread(task, "线程2").start();
}
}
Callable接口 + FutureTask类
package com.biaogexf.tools.thread;
import com.biaogexf.tools.FileRegularExpressionTest;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
// 实现Callable接口 + 使用FutureTask包装
public class CallableFutureTaskTest implements Callable {
// 有返回值 & 可抛出异常
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 10; i++) {
sum += i;
}
System.out.println(Thread.currentThread().getName() + " is running: " + sum);
return sum;
}
public static void main(String[] args) {
// 创建Callable接口实现类的实例
CallableFutureTaskTest callObj = new CallableFutureTaskTest();
// 使用FutureTask类包装Callable实现类的实例
FutureTask futureTask = new FutureTask<>(callObj);
new Thread(futureTask).start();
try {
// 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
System.out.println("子线程返回值：" + futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
Java中创建线程池的五种方法
JAVA中创建线程池主要有两类方法，一类是通过Executors工厂类提供的方法，该类提供了4种不同的线程池可供使用。
另一类是通过ThreadPoolExecutor类进行自定义创建。
Executors工厂类提供了4种不同的线程池
newCachedThreadPool：创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程。
因为初始线程池没有线程，而线程不足会不断新建线程，所以线程名都是不一样的。
package com.biaogexf.tools.thread.pools;
import org.assertj.core.util.DateUtil;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import static java.lang.Thread.sleep;
public class NewCachedThreadPoolTest {
/**
* 创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程。
*
* 因为初始线程池没有线程，而线程不足会不断新建线程，所以线程名都是不一样的。
*/
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
executorService.execute(() -> {
// 输出线程名称,默认格式:pool-1-thread-1
System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
// 睡眠2秒 模拟线程操作
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
}
}
newFixedThreadPool：创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。
因为线程池大小是固定的，这里设置的是3个线程，所以线程名只有3个。因为线程不足会进入队列等待线程空闲，所以日志间隔2秒输出。
package com.biaogexf.tools.thread.pools;
import org.assertj.core.util.DateUtil;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class NewFixedThreadPoolTest {
/**
* newFixedThreadPool
* 创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。
*
* 因为线程池大小是固定的，这里设置的是3个线程，所以线程名只有3个。因为线程不足会进入队列等待线程空闲，所以日志间隔2秒输出。
* @param args
*/
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
executorService.execute(() -> {
// 线程要执行的内容
System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
// 模拟进行IO操作
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
}
}
newScheduledThreadPool：创建一个周期性的线程池，支持定时及周期性执行任务。
package com.biaogexf.tools.thread.pools;
import org.assertj.core.util.DateUtil;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class NewScheduledThreadPoolTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
System.out.println(DateUtil.now() + "延时3秒" + "提交任务");
for (int i = 0; i < 10; i++) {
final int index = i;
scheduledExecutorService.schedule(() -> {
System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}, 3, TimeUnit.SECONDS);
}
}
}
Fri May 07 15:02:39 CST 2021延时3秒提交任务
Fri May 07 15:02:42 CST 2021 pool-1-thread-3 0
Fri May 07 15:02:42 CST 2021 pool-1-thread-1 2
Fri May 07 15:02:42 CST 2021 pool-1-thread-2 1
Fri May 07 15:02:44 CST 2021 pool-1-thread-1 3
Fri May 07 15:02:44 CST 2021 pool-1-thread-2 4
Fri May 07 15:02:44 CST 2021 pool-1-thread-3 5
Fri May 07 15:02:46 CST 2021 pool-1-thread-2 6
Fri May 07 15:02:46 CST 2021 pool-1-thread-1 7
Fri May 07 15:02:46 CST 2021 pool-1-thread-3 8
Fri May 07 15:02:48 CST 2021 pool-1-thread-1 9因为设置了延迟3秒，所以提交后3秒才开始执行任务。因为这里设置核心线程数为3个，而线程不足会进入队列等待线程空闲，所以日志间隔2秒输出。
newSingleThreadExecutor：创建一个单线程的线程池，可保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
package com.biaogexf.tools.thread.pools;
import org.assertj.core.util.DateUtil;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class NewSingleThreadExecutorTest {
public static void main(String[] args) {
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
executorService.execute(() -> {
System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
}
}
Fri May 07 14:59:18 CST 2021 pool-1-thread-1 0
Fri May 07 14:59:20 CST 2021 pool-1-thread-1 1
Fri May 07 14:59:22 CST 2021 pool-1-thread-1 2
Fri May 07 14:59:24 CST 2021 pool-1-thread-1 3
Fri May 07 14:59:26 CST 2021 pool-1-thread-1 4
Fri May 07 14:59:28 CST 2021 pool-1-thread-1 5
Fri May 07 14:59:30 CST 2021 pool-1-thread-1 6
Fri May 07 14:59:32 CST 2021 pool-1-thread-1 7
Fri May 07 14:59:34 CST 2021 pool-1-thread-1 8
Fri May 07 14:59:36 CST 2021 pool-1-thread-1 9因为只有一个线程，所以线程名均相同，且是每隔2秒按顺序输出的。
通过ThreadPoolExecutor类自定义
ThreadPoolExecutor：自定义线程池
package com.biaogexf.tools.thread.pools;
import org.assertj.core.util.DateUtil;
import java.util.concurrent.*;
public class ThreadPoolExecutorTest {
/**
* ThreadPoolExecutor
* @param args
*/
public static void main(String[] args) {
ExecutorService executorService = new ThreadPoolExecutor(2, 10, 1,
TimeUnit.MINUTES, new ArrayBlockingQueue<>(5, true),
Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i < 10; i++) {
final int index = i;
executorService.execute(() -> {
System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
// 有序关闭线程池，不会接受新任务，但是会在关闭前执行完已经提交的任务
executorService.shutdown();
}
}
Fri May 07 14:54:02 CST 2021 pool-1-thread-4 8
Fri May 07 14:54:02 CST 2021 pool-1-thread-2 1
Fri May 07 14:54:02 CST 2021 pool-1-thread-1 0
Fri May 07 14:54:02 CST 2021 pool-1-thread-3 7
Fri May 07 14:54:02 CST 2021 pool-1-thread-5 9
Fri May 07 14:54:04 CST 2021 pool-1-thread-4 2
Fri May 07 14:54:04 CST 2021 pool-1-thread-2 3
Fri May 07 14:54:04 CST 2021 pool-1-thread-1 4
Fri May 07 14:54:04 CST 2021 pool-1-thread-3 5
Fri May 07 14:54:04 CST 2021 pool-1-thread-5 6因为核心线程数为2，队列大小为5，存活时间1分钟，所以流程是第0-1号任务来时，陆续创建2个线程，然后第2-6号任务来时，因为无线程可用，均进入了队列等待，第7-9号任务来时，没有空闲线程，队列也满了，所以陆续又创建了3个线程。所以你会发现7-9号任务反而是先执行的。又因为各任务只需要2秒，而线程存活时间有1分钟，所以线程进行了复用，所以总共只创建了5个线程。
阿里代码规范《阿里巴巴Java开发手册》
【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
Executors返回的线程池对象的弊端如下:
FixedThreadPool和SingleThreadPool：允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
CachedThreadPool和ScheduledThreadPool：允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。
扫一扫
2440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
