线程池自定义线程工厂并实现三个线程循环输出1-100
构建自定义线程工厂
自定义线程工厂能够自定义业务名称以及线程名称的显示,能够帮助我们更快的定位错误,比原本自带的无意义的线程id更加符合规范。
package multipleThread.src;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
public final class NamingThreadFactory implements ThreadFactory {
//原有的线程工厂
public final ThreadFactory threadFactory;
//线程名称
public final String name;
//原子类,用于保证多个线程创建递增的名称id
private final AtomicInteger ThreadNum=new AtomicInteger(1);
public NamingThreadFactory(ThreadFactory threadFactory,String name) {
this.threadFactory = threadFactory;
this.name=name;
}
@Override
public Thread newThread(Runnable r){
Thread t=threadFactory.newThread(r);
t.setName(name+"[#"+ThreadNum.getAndIncrement()+"]");
return t;
}
}
线程池3个核心线程依次循环输出1-100
- 使用线程池相比于创建三个线程分别启动更加贴合实际业务,代码也更加简洁具有较好的维护性,可以轻易的扩展到n个线程循环输出xxxx
- 通过execute继承了Runnable的类重写run方法实现
package multipleThread.src;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPool {
//最大数
public static final int MAX_VALUE = 100;
//volatile保证变量可见性
public static volatile int cnt = 1;
//同步锁,保证原子性
public static Object lock = new Object();
public static void main(String[] args) {
//创建自定义线程池,核心线程数为3,这样新建的线程会优先分配到核心线程数中,保证依次出现
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3,
4,
0L,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(1),
//自定义线程工厂,自定义线程名称
new NamingThreadFactory(new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
return new Thread(r);
}
}, "测试线程"),
//拒绝策略为回退给原线程
new ThreadPoolExecutor.CallerRunsPolicy());
//开3个线程(3个以上也可以,只不过多的线程会被拒绝策略给返回没什么用,反而会增大开销)
for (int i = 1; i <= 3; i++) {
threadPoolExecutor.execute(new MyTask(i));
}
//关闭线程池
try {
//shutdown不会立刻关闭线程池
threadPoolExecutor.shutdown();
// awaitTermination可以等待所有线程完成,或者超时时间到达
if (!threadPoolExecutor.awaitTermination(10, TimeUnit.SECONDS)) {
// 如果超时,可以选择强制关闭线程池
threadPoolExecutor.shutdownNow();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//继承Runnable类实现Run方法
public static class MyTask implements Runnable {
public int threadId;
MyTask(int threadId) {
this.threadId = threadId;
}
@Override
public void run() {
//同步锁保证原子性,放在外面能最后释放锁,程序退出,放在里面由于先释放后等待锁,因此无法释放锁程序不会退出
synchronized (lock) {
while (cnt <= MAX_VALUE) {
//循环1-3的线程,若1-10个线程则可改此处
while ((cnt + 2) % 3 + 1 == threadId) {
System.out.println("当前线程:" + Thread.currentThread().getName() + "输出:" + (cnt++));
System.out.println("线程id:" + threadId);
lock.notifyAll();
}
try {
lock.wait();
} catch (Exception e) {
e.printStackTrace();
}
}
//释放空闲的锁
lock.notifyAll();
}
}
}
}