微分享-spring线程池实战

一般在使用多线程的时候都会使用到线程池，好处网上有很多，最主要的好处是线程池中的线程可以重复利用，减少线程创建销毁带来的资源浪费。

java实现线程池一般有两种：

• java自带的线程池Executor；
• Spring封装的线程池。

如果使用java自带的线程池编写起来比较麻烦，找了个网络的例子：

import java.util.concurrent.ArrayBlockingQueue;   
import java.util.concurrent.BlockingQueue;   
import java.util.concurrent.ThreadPoolExecutor;   
import java.util.concurrent.TimeUnit;   

public class ThreadPoolTest{   
    public static void main(String[] args){   
        //创建等待队列   
        BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);   
        //创建线程池，池中保存的线程数为3，允许的最大线程数为5  
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3,5,50,TimeUnit.MILLISECONDS,bqueue);   
        //创建七个任务   
        Runnable t1 = new MyThread();   
        Runnable t2 = new MyThread();   
        Runnable t3 = new MyThread();   
        Runnable t4 = new MyThread();   
        Runnable t5 = new MyThread();   
        Runnable t6 = new MyThread();   
        Runnable t7 = new MyThread();   
        //每个任务会在一个线程上执行  
        pool.execute(t1);   
        pool.execute(t2);   
        pool.execute(t3);   
        pool.execute(t4);   
        pool.execute(t5);   
        pool.execute(t6);   
        pool.execute(t7);   
        //关闭线程池   
        pool.shutdown();   
    }   
}   

class MyThread implements Runnable{   
    @Override   
    public void run(){   
        System.out.println(Thread.currentThread().getName() + "正在执行。。。");   
        try{   
            Thread.sleep(100);   
        }catch(InterruptedException e){   
            e.printStackTrace();   
        }   
    }   
}  

• 首先你自定义一个queue；
• 你还要创建一个java的ThreadPoolExecutor的线程，构造方法中有一大最参数；
• 还要定义Runnable。

看着太麻烦了。不要着急Spring这些已经帮咱们做了。

一个忠告：在开发时，如果遇到通用的功能，试着到开源社区寻找，一般都能找到现成的方法或解决方案，切勿闭门造车。

来让我们看看使用Spring是怎样开发的。

    <bean id="cacheExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!-- 线程池维护线程的核心数量 -->
        <property name="corePoolSize" value="2"/>
        <!-- 线程池维护线程的最大数量 -->
        <property name="maxPoolSize" value="4"/>
        <!-- 缓存队列 -->
        <property name="queueCapacity" value="64"/>
        <!-- 线程池的名称 -->
        <property name="threadNamePrefix" value="CACHE_DISTANCE" />
        <!-- 对拒绝task的处理策略 -->
        <property name="rejectedExecutionHandler">
            <bean class="java.util.concurrent.ThreadPoolExecutor.AbortPolicy"/>
        </property>
    </bean>

// 通过spring注入到需要的类中
@Autowired
ThreadPoolTaskExecutor cacheExecutor;

// 在需要使用的方法中    
public void startCacheThreads() {
    cacheExecutor.submit(new Runnable() {
        @Override
        public void run() {
            try {
                // 是我们需要多线程实现的方法
                doCacheTask();
            } catch (Exception ex) {
                logger.info("更新缓存失败：{}", Thread.currentThread().getName(), ex);
            }
        }
    });
}    

是不是这么写很高效，有容易理解。
在实战开发中会用到自定义rejectedExecutionHandler，就是任务太多导致线程池中queue已经塞满的拒绝策略，spring提供了这么几个策略：

• ThreadPoolExecutor.AbortPolicy策略，是默认的策略,处理程序遭到拒绝将抛出运行时 RejectedExecutionException；
• ThreadPoolExecutor.CallerRunsPolicy策略 ,调用者的线程会执行该任务,如果执行器已关闭,则丢弃；
• ThreadPoolExecutor.DiscardPolicy策略，不能执行的任务将被丢弃；
• ThreadPoolExecutor.DiscardOldestPolicy策略，如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。

但是有些情况下，我们想监控到底有多少被抛弃掉了，那么我们就需要自定义策略，怎么写呢，也很简单。

<bean id="uploadCoordinateToNearbyExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <property name="corePoolSize" value="1"/>
        <property name="maxPoolSize" value="2"/>
        <property name="queueCapacity" value="16384"/>
        <property name="threadNamePrefix" value="UPLOADCOORDINATETONEARBY_EXECUTOR" />
        <property name="rejectedExecutionHandler">
            <bean class="com.yd.util.UploadToNearbyDiscardPolicy">
                <constructor-arg value="uploadCoordinateToNearby"/>
            </bean>
        </property>
    </bean>

com.yd.util.UploadToNearbyDiscardPolicy就是自定义路由,代码需要implements RejectedExecutionHandler接口。

public class UploadToNearbyDiscardPolicy implements RejectedExecutionHandler {

    private static final Logger logger = LoggerFactory.getLogger(UploadToNearbyDiscardPolicy.class);
    public final String name;
    public long discardTimes;

    public UploadToNearbyDiscardPolicy(String name) {
        this.name = name;
    }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        ++StatObject.instance.uploadToNearbyDiscardCount;
        logger.warn("{}线程池太忙丢弃任务:{}", name, ++discardTimes);

    }
}

在上面的例子中，可以添加计数器，也可以将其数量上报的监控系统中。

多说一个Guava线程池返回数据的使用方法ListenableFuture。在开发中会常常遇到多线程计算后返回数据，常见的会写一个while效率一直检查线程是否处理完成，这个也可以，不过Guava提供了一个更下高效优雅的方法。

public static void main(String[] args) {

    // 将 ExecutorService 转为 ListeningExecutorService，可以使用MoreExecutors.listeningDecorator(ExecutorService)进行装饰 
    ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
    // 多线程处理并返回结果
    ListenableFuture explosion = service.submit(new Callable() {
          public Explosion call() {
            return pushBigRedButton();
          }
    });


    Futures.addCallback(explosion, new FutureCallback() {
          // we want this handler to run immediately after we push the big red button!
          public void onSuccess(Explosion explosion) {
            walkAwayFrom(explosion);
          }
          public void onFailure(Throwable thrown) {
            // 抛出异常时走这里
            battleArchNemesis(); // escaped the explosion!
      } 
    });
}

更下详尽的例子可以参考这篇blog，Guava - 并行编程Futures

参考：
http://ifeve.com/google-guava-listenablefuture/