线程池：ThreadPoolExecutor的使用

ThreadPoolExecutor配置

一、ThreadPoolExcutor为一些Executor提供了基本的实现，这些Executor是由Executors中的工厂 newCahceThreadPool、newFixedThreadPool和newScheduledThreadExecutor返回的。 ThreadPoolExecutor是一个灵活的健壮的池实现，允许各种各样的用户定制。

二、线程的创建与销毁

1、核心池大小、最大池大小和存活时间共同管理着线程的创建与销毁。

2、核心池的大小是目标的大小；线程池的实现试图维护池的大小；即使没有任务执行，池的大小也等于核心池的大小，并直到工作队列充满前，池都不会创建更多的线程。如果当前池的大小超过了核心池的大小，线程池就会终止它。

3、最大池的大小是可同时活动的线程数的上限。

4、如果一个线程已经闲置的时间超过了存活时间，它将成为一个被回收的候选者。

5、newFixedThreadPool工厂为请求的池设置了核心池的大小和最大池的大小，而且池永远不会超时

6、newCacheThreadPool工厂将最大池的大小设置为Integer.MAX_VALUE，核心池的大小设置为0，超时设置为一分钟。这样创建了无限扩大的线程池，会在需求量减少的情况下减少线程数量。

三、管理

1、 ThreadPoolExecutor允许你提供一个BlockingQueue来持有等待执行的任务。任务排队有3种基本方法：无限队列、有限队列和同步移交。

2、 newFixedThreadPool和newSingleThreadExectuor默认使用的是一个无限的 LinkedBlockingQueue。如果所有的工作者线程都处于忙碌状态，任务会在队列中等候。如果任务持续快速到达，超过了它们被执行的速度，队列也会无限制地增加。稳妥的策略是使用有限队列，比如ArrayBlockingQueue或有限的LinkedBlockingQueue以及 PriorityBlockingQueue。

3、对于庞大或无限的池，可以使用SynchronousQueue，完全绕开队列，直接将任务由生产者交给工作者线程

4、可以使用PriorityBlockingQueue通过优先级安排任务

ok

废话不多少说，直接开始：

public class ThreadFactory {

    static class ThreadPoolTask implements Runnable, Serializable {
        private Object attachData;

        ThreadPoolTask(Object o){
            this.attachData = o;
        }
        @Override
        public void run() {
            System.out.println("开始任务："+attachData);
        }
    }
    public static final ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(
            10,
            30,
            2000,
            TimeUnit.MILLISECONDS,
            new ArrayBlockingQueue<Runnable>(100));

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i <10 ; i++) {
            String s = "task@"+i;
            System.out.println("创建任务并提交到线程池中：" + s);
            EXECUTOR.execute(new ThreadPoolTask(s));
            Thread.sleep(1000);
        }

    }
}

　　

实例：

1：线程工厂

public class ThreadFactory {

    public static  ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(
            10,
            30,
            2000,
            TimeUnit.MILLISECONDS,
            new ArrayBlockingQueue<Runnable>(100));

}

2：创建任务

public class ThreadPoolTask implements  Runnable, Serializable {

    private Object o ;

    private BaseContext baseContext;

    public ThreadPoolTask(BaseEntity baseEntity,BaseContext baseContext){
        this.o=baseEntity;
        this.baseContext = baseContext;
    }

    @Override
    public void run() {
        System.out.println("线程开始："+o.toString());
        baseContext.add((BaseEntity) o);
    }
}

3：模拟数据库实体

@Component
public class BaseContext {
    private static final Logger LOGGER = LoggerFactory.getLogger(BaseContext.class);

    public List<BaseEntity> baseEntities = Collections.synchronizedList(new ArrayList<BaseEntity>());

    public boolean add(BaseEntity baseEntity){
        LOGGER.info("===============新增===============");
        return baseEntities.add(baseEntity);
    }

    public BaseEntity query(String name){
        for (BaseEntity baseEntity : baseEntities) {
            if (baseEntity.getName().equals(name)){
                LOGGER.info("查询到的实体："+baseEntity.toString());
                return baseEntity;
            }
            break;
        }
        return null;
    }
    public List<BaseEntity> queryList(){
       return baseEntities;
    }
}

4：实体

public class BaseEntity {
    private String name;
    private String age;

    public BaseEntity() {
    }

    public BaseEntity(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "BaseEntity{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}

5：测试类

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {XXXXX.class})
public class DemoApplicationTests {

    @Autowired
    private BaseContext baseContext;
    @Test
    public void contextLoads() {

        for (int i = 0; i <10 ; i++) {
            ThreadFactory.EXECUTOR.execute(new ThreadPoolTask(new BaseEntity(" "+i,"2"),baseContext));
        }
        baseContext.baseEntities.forEach(s->{
            System.out.println(s.toString());
        });
    }

}

6：输出