线程池的目的防止线程的随意创建,无法管理,将我们执行的线程放入线程池中执行,实际同时执行的线程数量依赖CPU几核;
1.线程池常用管理处理
并行执行:
threadPool = ThreadPoolManager.getInstance().addParallelTask(new Runnable() {});
串行执行:
threadPool = ThreadPoolManager.getInstance().addSerialTask(new Runnable() {});
package net.sourceforge.simcpux;
import android.util.Log;
import java.util.ArrayDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 线程管理器
*/
public class ThreadPoolManager {
private static final String LOG_TAG = ThreadPoolManager.class.getSimpleName();
//CPU的数量
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
/**
* 在核心线程池至少有2个线程,最多有4线程,比CPU数量少1个避免后台任务使CPU饱和
*/
private static final int CORE_POOL_SIZE = Math.max(2,Math.min(CPU_COUNT-1,4));
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT*2 + 1;
private static final int KEEP_ALIVE_SECONDS = 30;
/**
* 线程工厂
*/
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "ThreadPoolManager #"+mCount.getAndIncrement());
}
};
/**
* 线程池的工作队列
*/
private BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
/**
* 一个被使用去执行并发任务的线程池
*/
private ThreadPoolExecutor THREAD_POOL_EXECUTOR;
/**
* 线程池以串行顺序一次执行一个任务。此序列化是特定进程的全局序列化。
*/
private Executor SERIAL_EXECUTOR;
private volatile Executor sDefaultExecutor;
private static ThreadPoolManager threadPoolManager;
private ThreadPoolManager(){
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE,MAXIMUM_POOL_SIZE,KEEP_ALIVE_SECONDS,TimeUnit.SECONDS,
sPoolWorkQueue,sThreadFactory
);
//当设置allowCoreThreadTimeOut(true)时,线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
SERIAL_EXECUTOR = new SerialExecutor();
sDefaultExecutor = SERIAL_EXECUTOR;
}
public static ThreadPoolManager getInstance(){
if(threadPoolManager == null){
synchronized (ThreadPoolManager.class){
if(threadPoolManager == null){
threadPoolManager = new ThreadPoolManager();
}
}
}
return threadPoolManager;
}
/**
* 串行执行线程任务
*/
private class SerialExecutor implements Executor{
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
//当前执行的线程
Runnable mActive;
/**
* ArrayDeque 非线程安全的
* @param r
*/
@Override
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
@Override
public void run() {
try{
r.run();
}finally {
scheduleNext();
}
}
});
if(mActive == null){
scheduleNext();
}
}
protected synchronized void scheduleNext(){
if((mActive = mTasks.poll()) != null){
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
/**
* 串行执行
* @param runnable
*/
public void addSerialTask(Runnable runnable){
if(runnable == null){
throw new NullPointerException("addTask(Runnable runnable)传入参数为空");
}
Log.i(LOG_TAG,"目前有"+THREAD_POOL_EXECUTOR.getActiveCount()+"个线程正在进行中,有"+sPoolWorkQueue.size()+"个任务正在排队");
sDefaultExecutor.execute(runnable);
}
/**
* 并发执行
* @param runnable
*/
public void addParallelTask(Runnable runnable){
if(runnable == null){
throw new NullPointerException("addTask(Runnable runnable)传入参数为空");
}
Log.i(LOG_TAG,"目前有"+THREAD_POOL_EXECUTOR.getActiveCount()+"个线程正在进行中,有"+sPoolWorkQueue.size()+"个任务正在排队");
THREAD_POOL_EXECUTOR.execute(runnable);
}
/**
* 关闭线程池
*/
public void stopThreadPool(){
if(THREAD_POOL_EXECUTOR != null){
THREAD_POOL_EXECUTOR.shutdown();
THREAD_POOL_EXECUTOR = null;
}
sDefaultExecutor = null;
threadPoolManager = null;
}
}
2.线程池工厂类
/**
* 线程工厂类
*/
public class ThreadFactoryBuilder implements ThreadFactory {
private String name;
private AtomicInteger mCount;
// private int counter;
public ThreadFactoryBuilder(String name){
this.name = name;
// counter = 1;
mCount = new AtomicInteger(1);
}
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r, name);
thread.setName("ThreadFactoryBuilder_" + name + "_" + mCount.getAndIncrement());
return thread;
}
}
Thread线程的状态:
public enum State {
/**
* 新建一个线程对象,线程没有调用start()方法之前的状态
*/
NEW,
/**
* Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“运行”。
* 线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可
* 运行线程池中,等待被线程调度选中,获取CPU的使用权,此时处于就绪状态(ready)。就绪状
* 态的线程在获得CPU时间片后变为运行中状态(running)。
*/
RUNNABLE,
/**
* 在调用Object.wait()以后等待获取锁synchronized block/method或者重新进入
* synchronized block/method的阻塞状态
*/
BLOCKED,
/**
* 进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
*/
WAITING,
/**
* 该状态不同于WAITING,它可以在指定的时间后自行返回。
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* 表示该线程已经执行完毕;
*/
TERMINATED;
}