线程池自定义线程工厂并实现三个线程循环输出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();
            }
        }
    }
}

运行结果：