线程池的使用

自定义线程管理器 CustomThreadManager

package com.example.demo.thread;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class CustomThreadManager {
	/**
	 * 默认核心线程数
	 */
	private static final Integer CORE_POOL_SIZE = 10;
	/**
	 * 默认最大线程数
	 */
	private static final Integer MAXIMUM_POOL_SIZE = 100;
	/**
	 * 默认线程存活时间10s
	 */
	private static final Integer KEEP_ALIVE_TIME = 10;
	/**
	 * 默认等待队列容量
	 */
	private static final Integer WORK_QUEUE_SIZE = 20000;

	/**
	 * 生成线程池对象
	 *
	 * @param customThreadFactory 自定义线程工厂类
	 * @return java.util.concurrent.ThreadPoolExecutor
	 * @since v2.7.0
	 */
	public static ThreadPoolExecutor newThreadPool(CustomThreadFactory customThreadFactory) {
		CustomThreadFactory factory = customThreadFactory;
		if (null == factory) {
			factory = new CustomThreadFactory("License");
		}
		ThreadPoolExecutor executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_TIME,
			TimeUnit.SECONDS,
			new LinkedBlockingQueue<>(WORK_QUEUE_SIZE), factory,
			new CustomRejectedThreadHandler());
		return executor;
	}
}

自定义线程工厂 CustomThreadFactory

package com.example.demo.thread;



import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;


public class CustomThreadFactory implements ThreadFactory {

	private static final AtomicInteger POOL_NUMBER = new AtomicInteger(1);
	private final ThreadGroup group;
	private final AtomicInteger threadNumber = new AtomicInteger(1);
	private final String namePrefix;

	public CustomThreadFactory() {
		SecurityManager s = System.getSecurityManager();
		group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
		namePrefix = "pool-" + POOL_NUMBER.getAndIncrement() + "-thread-";
	}

	public CustomThreadFactory(String poolPrefix) {
		if (poolPrefix == null) {
			poolPrefix = "pool-";
		}
		SecurityManager s = System.getSecurityManager();
		group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
		namePrefix = poolPrefix + POOL_NUMBER.getAndIncrement() + "-thread-";
	}

	@Override
	public Thread newThread(Runnable r) {
		Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
		if (t.isDaemon()) {
			t.setDaemon(false);
		}
		if (t.getPriority() != Thread.NORM_PRIORITY) {
			t.setPriority(Thread.NORM_PRIORITY);
		}
		return t;
	}

}

自定义拒绝策略 CustomRejectedThreadHandler

package com.example.demo.thread;

import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;


public class CustomRejectedThreadHandler implements RejectedExecutionHandler {

	public CustomRejectedThreadHandler() {
	}

	@Override
	public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
		throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString());
	}
}

举个例子

1.简单线程池的使用

package com.example.demo.thread;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;
import java.util.concurrent.ThreadPoolExecutor;

@Slf4j
public class TestOneThread {

    private static final ThreadPoolExecutor THERAD_ONE = CustomThreadManager.newThreadPool(new CustomThreadFactory("threadName"));

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            int finalI = i;
            THERAD_ONE.submit(() -> {
                log.info(String.valueOf(finalI));
            });
        }
        System.out.println("执行完毕");
    }
}

2.等待子线程执行完毕在执行主线程逻辑

package com.example.demo.thread;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadPoolExecutor;

@Slf4j
public class TestTwoThread {

    private static final ThreadPoolExecutor THERAD_TWO = CustomThreadManager.newThreadPool(new CustomThreadFactory("threadName"));

    public static void main(String[] args) {
        final CountDownLatch countDownLatch = new CountDownLatch(100);
        for (int i = 0; i < 100; i++) {
            int finalI = i;
            THERAD_TWO.submit(() -> {
                try {
                    log.info(String.valueOf(finalI));
                } catch (Exception e) {

                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("子线程执行完毕，继续执行主线程！");
    }
}

3.带返回值的多线程

package com.example.demo.thread;

import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

@Slf4j
public class TestThreeThread {

    private static final ThreadPoolExecutor THREE_THREAD = CustomThreadManager.newThreadPool(new CustomThreadFactory("threadName"));


    public static void main(String[] args) {
        List<Future<Book>> futureResults = new ArrayList<>();
        for (int e = 0; e < 100; e++) {
            futureResults.add(THREE_THREAD.submit(new BuildUnitNumberThread(e, e + 1)));
        }
        futureResults.forEach(future -> {
            try {
                Book book = future.get();
                System.out.println("测试带返回值数据" + book.getSum());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });

    }

    @Getter
    @Setter
    public static class Book {

        private Integer sum;

        public Book(Integer sum) {
            this.sum = sum;
        }

    }

    @Data
    static
    class BuildUnitNumberThread implements Callable<Book> {

        private Integer A1;
        private Integer A2;

        public BuildUnitNumberThread(Integer a1, Integer a2) {
            A1 = a1;
            A2 = a2;
        }

        @Override
        public Book call() {
            return new Book(A1 + A2);
        }
    }
}