new Thread的弊端如下：
a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。

1、java线程池

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

package com.java.my;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * @author wanjiadong
 * @description
 * @date Create in 14:01 2018/2/1
 */
public class test2 {
    public static void main(String[] args) throws InterruptedException {
        //创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        long beginTime = System.currentTimeMillis();
        for(int i =0;i<10;i++){
            System.out.println("创建线程："+i);
            final int index = i;
            Runnable run = new Runnable() {
                @Override
                public void run() {
                    System.out.println("启动线程："+index);
                }
            };
            // 在未来某个时间执行给定的命令
            executorService.execute(run);
        }
        //关闭启动线程
        executorService.shutdown();
        //等待子线程结束，再执行下面代码
        executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
        System.out.println("所有线程都结束了,用时为："+(System.currentTimeMillis()-beginTime));
    }
}

2、使用SPRING中的线程池ThreadPoolTaskExecutor实现JAVA并发

ThreadPoolTaskExecutor的参数：

　　int corePoolSize:线程池维护线程的最小数量.
　　int maximumPoolSize:线程池维护线程的最大数量.
　　long keepAliveTime:空闲线程的存活时间.
　　TimeUnit unit: 时间单位,现有纳秒,微秒,毫秒,秒枚举值.
　　BlockingQueue<Runnable> workQueue:持有等待执行的任务队列.
　　RejectedExecutionHandler handler: 用来拒绝一个任务的执行，有两种情况会发生这种情况。
　　一是在execute方法中若addIfUnderMaximumPoolSize(command)为false，即线程池已经饱和；
　　二是在execute方法中, 发现runState!=RUNNING || poolSize == 0,即已经shutdown,就调用ensureQueuedTaskHandled(Runnable command)，在该方法中有可能调用reject。

ThredPoolTaskExcutor的处理流程：

　　当池子大小小于corePoolSize，就新建线程，并处理请求

　　当池子大小等于corePoolSize，把请求放入workQueue中，池子里的空闲线程就去workQueue中取任务并处理

　　当workQueue放不下任务时，就新建线程入池，并处理请求，如果池子大小撑到了maximumPoolSize，就用RejectedExecutionHandler来做拒绝处理

　　当池子的线程数大于corePoolSize时，多余的线程会等待keepAliveTime长时间，如果无请求可处理就自行销毁

　　其会优先创建 CorePoolSiz 线程，当继续增加线程时，先放入Queue中，当 CorePoolSiz 和 Queue 都满的时候，就增加创建新线程，当线程达到MaxPoolSize的时候，就会抛出错误 org.springframework.core.task.TaskRejectedException

　　另外MaxPoolSize的设定如果比系统支持的线程数还要大时，会抛出java.lang.OutOfMemoryError: unable to create new native thread 异常。

<!-- 异步线程池 -->
    <bean id="threadPool"  
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor" scope="singleton">   
       <!-- 核心线程数  -->   
        <property name="corePoolSize" value="10" />   
        <!-- 最大线程数 -->   
        <property name="maxPoolSize" value="50" />   
        <!-- 队列最大长度 >=mainExecutor.maxSize -->   
        <property name="queueCapacity" value="10" />   
        <!-- 线程池维护线程所允许的空闲时间 -->   
        <property name="keepAliveSeconds" value="300" />   
        <!-- 线程池对拒绝任务(无线程可用)的处理策略 -->   
        <property name="rejectedExecutionHandler">   
            <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy"/>   
        </property>   
    </bean>

使用

1，初始化线程池

//异步线程池
	@Autowired
	private ThreadPoolTaskExecutor threadPool;

2，在线程池中执行某个线程

threadPool.execute(new Runnable() {...});

2、使用SPRING中的线程池ThreadPoolTaskExecutor实现JAVA并发

2、使用SPRING中的线程池ThreadPoolTaskExecutor实现JAVA并发

猜你喜欢