枚举实现Java线程池
线程池工具类代码如下：
package com.ifly.simple.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public enum EnumThreadPool {
INSTANCE;
private ThreadPoolExecutor threadPool;
public ThreadPoolExecutor getInstance() {
return this.threadPool;
}
/**
* 无返回值直接执行
*/
public void execute(Runnable runnable){
this.threadPool.execute(runnable);
}
/**
* 返回值直接执行
*/
public Future submit(Callable callable){
return this.threadPool.submit(callable);
}
EnumThreadPool() {
//根据cpu的数量动态的配置核心线程数和最大线程数
int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//核心线程数 = CPU核心数 + 1
int CORE_POOL_SIZE = CPU_COUNT + 1;
//线程池最大线程数 = CPU核心数 * 2 + 1
int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
//非核心线程闲置时超时1s
int KEEP_ALIVE = 1;
this.threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS,
new LinkedBlockingDeque(Integer.MAX_VALUE));
}
}
测试用例及使用方法：
package com.ifly.simple.thread;
import java.util.concurrent.EnumThreadPool ;
public class test {
public static void main(String[] args) {
ThreadPoolExecutor sd1 = EnumThreadPool.INSTANCE.getInstance();
ThreadPoolExecutor sd2 = EnumThreadPool.INSTANCE.getInstance();
//验证枚举单例是否正确
System.out.println(sd1.equals(sd2));//true
System.out.println(sd1 == sd2);//true
/**
* 使用方法
*/
//EnumThreadPool.INSTANCE.execute(null);
long runnableStart = System.currentTimeMillis();
for (int i = 0; i < 10; i++) {
try {
final String msg = String.format("无返回值多线程,这是第{%s}条消息", i);
EnumThreadPool.INSTANCE.execute(new Runnable() {
public void run() {
System.out.println(String.format("打印:%s", msg));
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
System.out.println(String.format("无返回值多线程共计耗时{%s}毫秒", System.currentTimeMillis() - runnableStart));
System.out.println("=======================分割线=========================");
//EnumThreadPool.INSTANCE.submit(null);
long callableStart = System.currentTimeMillis();
List> futureList = new ArrayList>();
for (int i = 0; i < 10; i++) {
try {
final String msg = String.format("有返回值多线程,这是第{%s}条消息", i);
Future messageFuture = EnumThreadPool.INSTANCE.submit(new Callable() {
public String call() throws Exception {
Thread.sleep(300);
String response = String.format("打印:%s", msg);
System.out.println(response);
return response;
}
});
futureList.add(messageFuture);
} catch (Exception e) {
e.printStackTrace();
}
}
for (Future message : futureList) {
if(!message.isDone()){
Thread.sleep(1000);
System.out.println("等待1秒......");
}
String messageData = message.get();
System.out.println("线程结束：信息为：" + messageData);
}
System.out.println(String.format("有返回值多线程共计耗时{%s}毫秒", System.currentTimeMillis() - callableStart));
}
}
输出结果
true
true
打印:无返回值多线程,这是第{0}条消息
打印:无返回值多线程,这是第{5}条消息
打印:无返回值多线程,这是第{6}条消息
打印:无返回值多线程,这是第{7}条消息
打印:无返回值多线程,这是第{8}条消息
打印:无返回值多线程,这是第{9}条消息
打印:无返回值多线程,这是第{1}条消息
打印:无返回值多线程,这是第{2}条消息
无返回值多线程共计耗时{30}毫秒
=======================分割线=========================
打印:无返回值多线程,这是第{3}条消息
打印:无返回值多线程,这是第{4}条消息
打印:有返回值多线程,这是第{4}条消息
打印:有返回值多线程,这是第{3}条消息
打印:有返回值多线程,这是第{2}条消息
打印:有返回值多线程,这是第{0}条消息
打印:有返回值多线程,这是第{1}条消息
打印:有返回值多线程,这是第{7}条消息
打印:有返回值多线程,这是第{9}条消息
打印:有返回值多线程,这是第{8}条消息
打印:有返回值多线程,这是第{5}条消息
打印:有返回值多线程,这是第{6}条消息
等待1秒......
线程结束：信息为：打印:有返回值多线程,这是第{0}条消息
线程结束：信息为：打印:有返回值多线程,这是第{1}条消息
线程结束：信息为：打印:有返回值多线程,这是第{2}条消息
线程结束：信息为：打印:有返回值多线程,这是第{3}条消息
线程结束：信息为：打印:有返回值多线程,这是第{4}条消息
线程结束：信息为：打印:有返回值多线程,这是第{5}条消息
线程结束：信息为：打印:有返回值多线程,这是第{6}条消息
线程结束：信息为：打印:有返回值多线程,这是第{7}条消息
线程结束：信息为：打印:有返回值多线程,这是第{8}条消息
线程结束：信息为：打印:有返回值多线程,这是第{9}条消息
有返回值多线程共计耗时{1003}毫秒
匿名内部类实现多线程
//1.thread实现
new Thread() {
代码...
}.start();
//2.runnable实现
new Thread(new Runnable() {
代码...
}){}.start();
示例代码
1 package cn.itcast_11;
2
3 /*
4 * 匿名内部类的格式：
5 * new 类名或者接口名() {
6 * 重写方法;
7 * }
8 *
9 * 本质：是该类的子类对象或者该接口的实现类对象。
10 */
11 public class ThreadDemo {
12 public static void main(String[] args) {
13 // 继承Thread类来实现多线程
14 new Thread() {
15 @Override
16 public void run() {
17 for (int x = 0; x < 100; x++) {
18 System.out.println(Thread.currentThread().getName() + ":" + x);
19 }
20 }
21 }.start();
22
23 // 实现Runnable接口来实现多线程
24 new Thread(new Runnable() {
25 @Override
26 public void run() {
27 for (int x = 0; x < 100; x++) {
28 System.out.println(Thread.currentThread().getName() + ":" + x);
29 }
30 }
31 }) {
32 }.start();
33
34 // 面试题
35 // 到底执行的是Thread类的子类对象的run()，还是执行的是Runnable接口的实现类对象的run()呢？ 答：是Thread类的子类对象的run() world
36 new Thread(new Runnable() {
37 @Override
38 public void run() {
39 for (int x = 0; x < 100; x++) {
40 System.out.println("hello" + ":" + x);
41 }
42 }
43 }) {
44 @Override
45 public void run() {
46 for (int x = 0; x < 100; x++) {
47 System.out.println("world" + ":" + x);
48 }
49 }
50 }.start();
51 }
52 }