Android线程池

Android中的线程池

这一章和大家分享Android中的线程池，下面我先介绍线程池的几点好处：

1,重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。

2,能有效控制线程池的最大并发数，避免大量的线程之间因相互抢占系统资源而导致的阻塞现象。

3,能够对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能。

Android中的线程池的概念来源于Java中的Executor，Executor为一个接口，从线程池的功能特性上来说，Android的线程池主要分为四类,它们都是直接或间接的通过配置ThreadPoolExecutor来实现自己的功能，因此在介绍它们之前先介绍ThreadPoolExecutor。

ThreadPoolExecutor(int corePoolSize,int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,RejectedExecutionHandler handler) 

corePoolSize(线程池的核心线程数):默认情况下，核心线程会在线程中一直存活，即使他们处于闲置状态。

maximumPoolSize(线程池所能容纳的最大线程数):当活动线程数达到这个数值后，后续的新任务将会被阻塞。

keepAliveTime(非核心线程闲置时的超时时长):当超过这个时长，非核心线程就会被回收。【当ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true时，keepAliveTime同样会作用于核心线程】

Unit(keepAliveTime参数的时间单位):MILLISECONDS(毫秒),SECONDS(秒),MINUTES(分钟)。

workQueue(任务队列):存储execute方法提交的Runnable对象。

threadFactory(线程工厂):为线程池提供创建新线程的功能。

RejectedExecutionHandler handler,主要用于任务队列已满，或者无法执行任务，抛出RejectedExecutionException;

ThreadPoolExecutor执行任务时大致遵循以下几种规则：

1，线程池中线程 < 核心线程，启动一个核心线程来执行任务。 

2，线程池中线程 >= 核心线程，任务插入任务队列中进行排队等待执行。

3，任务队列已满 &&  线程池中线程 < 线程池规定的最大值，会启动一个非核心线程来执行。

4，任务队列已满 && 线程池中线程 >= 线程池规定的最大值,拒绝执行任务，会调用RejectedExecutionHandler.rejectedExecution()来通知调用者。

//CPU 核心数
private static final int CUP_COUNT = Runtime.getRuntime().availableProcessors();
//核心线程数量
private final int CORE_POOL_SIZE = 1;
//线程池最大线程数量
private final int MAXIMUM_POOL_SIZE = CUP_COUNT + 1;
//线程工厂 
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r) {
	return new Thread(r,"AsyncTask #"+mCount.getAndIncrement());
	}
};
//阻塞队列分为 有限队列（SynchronousQueue、ArrayBlockingQueue）	无线队列(LinkedBlockingQueue)
private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(128)
	
@Override
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, 0, TimeUnit.SECONDS, sPoolWorkQueue,sThreadFactory);
    }

从上面代码可以看出：

• 核心线程为1
• 线程池最大线程数量为CPU核心数+1
• 线程队列等待时间为0s【无超时机制】
• 线程队列容量为128

Android线程池的分类：

FixedThreadPool:线程数量固定（且都是核心线程），线程处于休息状态，它们不会被回收，除非线程池关闭。当线程全部处于活动时，新任务需等待。

好处：更快地响应外界的请求。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

从上面可以看出：

• 核心线程数为nThreads 
• 线程池最大数量为nThreads
• 无超时机制

CachedThreadPool:线程数量不定的线程池，它只有非核心线程。线程池处于活动状态时，线程池会创建新的线程来处理新任务，这个超时60秒，超过60秒闲置线程就会被回收。

好处：适合执行大量的耗时较少的任务。

 public static ExecutorService newCachedThreadPool(){
    	return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60l, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
    }

从上面可以看出：

• 核心线程为0
• 线程数最大为Integer.MAX_VALUE
• 60秒的超时时间
• 缓存队列无限大

ScheduledThreadPool:核心线程数固定，而非核心数没有限制，当非核心数处于闲置状态会被回收。

好处：用于执行定时任务和具有固定周期的重复任务

public ScheduledThreadPoolExecutor(int corePoolSize){
    	super(corePoolSize , Integer.MAX_VALUE , 0 , NANOSECONDS , new DelayedWorkQueue());
    }

从上面可以看出：

• 核心线程数为corePoolSize
• 线程数最大为Integer.MAX_VALUE
• 无超时机制

SingleThreadExecutor:只有一个核心线程，所有任务在同一个线程中按顺序执行。

好处：不需要处理线程同步问题

 public static ExecutorService newSingleThreadExector(){
    	return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0, TimeUnit.MICROSECONDS, new LinkedBlockingQueue<Runnable>()));
    }

从上面可以看出：

• 核心线程数为1
• 最大线程数为1
• 无超时机制

Runnable command = new Runnable() {
		int x = 1;
		@Override
		public void run() {
			System.out.print("num:"+(x++));
		}
	};
	
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
        fixedThreadPool.execute(command);
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        cachedThreadPool.execute(command);
        ExecutorService singleThreadPool = Executors.newSingleThreadScheduledExecutor();
        singleThreadPool.execute(command);
        ScheduledExecutorService scheduledThread = Executors.newScheduledThreadPool(4);
        //每隔10s执行一次
        scheduledThread.schedule(command, 10, TimeUnit.SECONDS);
        //第一次延迟10s执行,以后每隔1s执行一次
        scheduledThread.scheduleAtFixedRate(command, 10, 1 , TimeUnit.SECONDS);
        
    }

以上是每个线程池的简单的用法，中途有事耽搁了，很久没有更新了，接下来我会和以往一样每周一篇。

谢谢鉴赏！！！！