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：输出
