一.概述
今天我们继续研究线程池的使用，因为这块确实可能比较麻烦，不多研究几次是根本不能搞懂的，先看效果图
效果一
效果二
二.代码
效果一(纯ExecutorService、AsyncTask、Runnable关联实现相关文件如下)
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
//任务编号
private static int order = 0;
/**
* 总共多少任务（根据CPU个数决定创建活动线程的个数,这样取的好处就是可以让手机承受得住）
*/
// private static final int count = Runtime.getRuntime().availableProcessors()*2;
private static final int count = 6;//任务总数
/**
* 每次只执行一个任务的线程池
*/
private static ExecutorService sSingleThreadExecutor;
/**
* 没有任务个数限制的线程池
*/
private static ExecutorService sCachedThreadPool;
/**
* 限制任务个数的线程池
*/
private static ExecutorService sFixedThreadPool;
/**
* 按指定时间可周期性执行任务的线程池
*/
private static ExecutorService sScheduledThreadPool;
/**
* 按指定时间可周期性执行任务的线程池,按照指定的工厂模式
*/
private static ExecutorService sScheduledThreadPool1;
private List<PoolTask> mPoolTasks;
private ListView mListView;
private boolean isCancel = false;
private boolean isClick = false;
/**
* 当前线程执行器类型
*/
private static ExecutorService currentExecutor ;
/**
* 方式一，使用默认线程工厂
*/
ThreadFactory ft = Executors.defaultThreadFactory();
/**
* 方式二，创建新线程需要的线程工厂
*/
private static ThreadFactory mThreadFactory = new ThreadFactory() {
private final AtomicInteger count = new AtomicInteger();
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r, "threadPool" + count.getAndIncrement());
thread.setDaemon(true);
return thread;
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mListView = (ListView) findViewById(R.id.listview);
mListView.setOnItemClickListener(mOnItemClickListener);
initData();
}
public void initData(){
sSingleThreadExecutor = Executors.newSingleThreadExecutor();
sCachedThreadPool = Executors.newCachedThreadPool();
sFixedThreadPool = Executors.newFixedThreadPool(3);
sScheduledThreadPool = Executors.newScheduledThreadPool(3);
sScheduledThreadPool1 = Executors.newScheduledThreadPool(4, mThreadFactory);
sSingleThreadExecutor.submit(new Runnable() {
@Override
public void run() {
Log.i(TAG, "run: task is sumbit");
}
});
currentExecutor = sSingleThreadExecutor;
mListView.setAdapter(new ThreadPoolAdapter(this, count));
}
AdapterView.OnItemClickListener mOnItemClickListener = new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
if (position == 0) {
//第一种关闭方式，等待正在执行的任务执行完成
// sCachedThreadPool.shutdown();
/*
shutdownNow：停止正在执行的任务，返回未执行的任务列表，第二次再调用shutDown
不会返回未执行的任务列表，当前执行器会变为空，因为线程池已经关闭了
*/
System.out.println("=========currentExecutor"+currentExecutor);
List<Runnable> runnables = currentExecutor.shutdownNow();
System.out.println("==========="+runnables);
for (Runnable r : runnables) {
System.out.println("=========未执行的任务信息"+r.toString());
}
System.out.println("=========isShoutDown"+currentExecutor.isShutdown());
currentExecutor = null;
}
//以第二项为例进行测试
PoolTask poolTask = mPoolTasks.get(1);
if (position == 1) {
if (!isClick) {
poolTask.cancel(true);
isCancel = true;
isClick = !isClick;
} else {
poolTask.cancel(false);
isCancel = false;
isClick = !isClick;
if (poolTask != null && poolTask.getStatus() == AsyncTask.Status.RUNNING) {
if (poolTask.isCancelled()) {
poolTask = new PoolTask(poolTask.itemview);
} else {
Toast.makeText(MainActivity.this, "任务已经在执行", Toast.LENGTH_SHORT).show();
}
}
if (currentExecutor == null) {
currentExecutor = Executors.newCachedThreadPool();
}
poolTask.executeOnExecutor(currentExecutor);//只能执行一次，也就是说第二个只能点击两次
}
} else {
Toast.makeText(MainActivity.this, "其他的", Toast.LENGTH_SHORT).show();
poolTask.cancel(false);
isCancel =false;
}
}
};
class PoolTask extends AsyncTask<Void, Integer, Void> {
private View itemview;
private final TextView mTextView;
private final ProgressBar mPb;
private String id;
public PoolTask(View itemview){
this.itemview = itemview;
mTextView = (TextView) itemview.findViewById(R.id.textview);
mPb = (ProgressBar) itemview.findViewById(R.id.pb);
if(order<count ||order == count){
id = "执行:" + String.valueOf(++order);
}else{
order = 0;
id = "执行:" + String.valueOf(++order);
}
}
@Override
protected void onPreExecute() {
super.onPreExecute();
mTextView.setText(id);
}
@Override
protected Void doInBackground(Void... params) {
if(!isCancelled()&&isCancel == false){ //这个地方很关键，如果不设置标志位的话，直接setCancel（true）是无效的
int prog = 0;
while (prog<101){
if ((prog > 0 || prog == 0) && prog < 70) // 小于70%时，加快进度条更新
{
SystemClock.sleep(100);
}
else
// 大于70%时，减慢进度条更新
{
SystemClock.sleep(300);
}
publishProgress(prog); // 更新进度条
prog++;
}
}
return null;
}
@Override
protected void onProgressUpdate(Integer... values) {//values是从publishProgress方法传过来的
super.onProgressUpdate(values);
mPb.setProgress(values[0]);
}
}
class ThreadPoolAdapter extends BaseAdapter{
private Context mContext;
private LayoutInflater mInflater;
private int taskcount;
public ThreadPoolAdapter(Context context,int taskCount){
mContext = context;
taskcount = taskCount;
mInflater = LayoutInflater.from(mContext);
mPoolTasks = new ArrayList<>();
}
@Override
public int getCount() {
return taskcount;
}
@Override
public Object getItem(int position) {
return mPoolTasks.get(position);
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
if(convertView == null){
convertView = mInflater.inflate(R.layout.list_view_item,null);
PoolTask poolTask = new PoolTask(convertView);
//根据指定的执行器执行任务
poolTask.executeOnExecutor(currentExecutor);
mPoolTasks.add(poolTask);
}
return convertView;
}
}
}
效果二(Runnable、ConcurrentLinkedQueue、ConcurrentMap、Future、ExecutorService关联实现)
public class MainActivity extends AppCompatActivity {
//线程池是否处于运行状态
private boolean isRunning = true;
//是否唤醒线程池工作
private boolean isNotify = true;
//在此类中使用同步锁时使用如下lock对象即可，官方推荐的，不推荐直接使用MainActivity.this类型的
private Object lock = new Object();
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
mProgressBar.setProgress(msg.what);
}
};
//任务执行队列
private ConcurrentLinkedQueue<MyRunnable> taskQueue;
//正在等待执行或者已经完成的任务队列，线程安全的(HashMap是线程不安全的)
private ConcurrentHashMap<Future, MyRunnable> taskMap;
//创建一个不限制大小的线程池 此类主要有以下好处 1,以共享的无界队列方式来运行这些线程. 2，执行效率高。
// 3，在任意点，在大多数 nThreads 线程会处于处理任务的活动状态
//4，如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。
private ExecutorService mCachedThreadPool;
private ProgressBar mProgressBar;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mProgressBar = (ProgressBar) findViewById(R.id.progressBar1);
taskQueue = new ConcurrentLinkedQueue<MyRunnable>();
taskMap = new ConcurrentHashMap<Future, MyRunnable>();
if (mCachedThreadPool == null) {
mCachedThreadPool = Executors.newCachedThreadPool();
}
}
public void click(View view) {
switch (view.getId()) {
case R.id.add:
addTask(new MyRunnable(mHandler));
break;
case R.id.start:
startTask();
break;
case R.id.cancel:
cancelTask();
break;
case R.id.release:
releaseTask();
break;
case R.id.reload:
reloadTask(new MyRunnable(mHandler));
break;
}
}
public void addTask(final MyRunnable myRunnable){
mHandler.sendEmptyMessage(0);
if(mCachedThreadPool == null){
mCachedThreadPool = Executors.newCachedThreadPool();
notifyWork();
}
if(taskMap == null){
taskMap = new ConcurrentHashMap<>();
}
if(taskQueue == null){
taskQueue = new ConcurrentLinkedQueue<>();
}
mCachedThreadPool.execute(new Runnable() {
@Override
public void run() {
taskQueue.offer(myRunnable);//插入一个Runnable到任务队列
notifyWork();
}
});
Toast.makeText(MainActivity.this, "已添加一个新任务到线程池中 ！",Toast.LENGTH_SHORT).show();
}
public void startTask(){
if(mCachedThreadPool == null||taskMap == null||taskQueue == null){
return;
}
mCachedThreadPool.execute(new Runnable() {
private MyRunnable mMyRunnable;
@Override
public void run() {
if(isRunning){
synchronized (lock){
mMyRunnable = taskQueue.poll();//从线程队列里面取出一个Runnable用来执行
if(mMyRunnable == null){
isNotify = true;
}
}
if(mMyRunnable!=null){
taskMap.put(mCachedThreadPool.submit(mMyRunnable),mMyRunnable);
}
}
}
});
}
public void cancelTask(){
Toast.makeText(this, "任务被取消", Toast.LENGTH_SHORT).show();
for(MyRunnable mr:taskMap.values()){
mr.setCancelTask(true);
}
}
public void reloadTask(final MyRunnable myRunnable){
mHandler.sendEmptyMessage(0);
if(mCachedThreadPool == null){
mCachedThreadPool = Executors.newCachedThreadPool();
notifyWork();
}
if(taskMap == null){
taskMap = new ConcurrentHashMap<>();
}
if(taskQueue == null){
taskQueue = new ConcurrentLinkedQueue<>();
}
mCachedThreadPool.execute(new Runnable() {
@Override
public void run() {
//插入一个Runnable对象到任务队列
taskQueue.offer(myRunnable);
notifyWork();
}
});
mCachedThreadPool.execute(new Runnable() {
@Override
public void run() {
if(isRunning){
MyRunnable myRunnable = null;
synchronized (lock){
myRunnable = taskQueue.poll();
if(myRunnable == null){
isNotify = true;
}
}
if(myRunnable!=null){
taskMap.put(mCachedThreadPool.submit(myRunnable),myRunnable);
}
}
}
});
}
public void releaseTask(){
Toast.makeText(this, "释放资源", Toast.LENGTH_SHORT).show();
mHandler.sendEmptyMessage(0);
Iterator<Map.Entry<Future, MyRunnable>> iterator = taskMap.entrySet().iterator();
while (iterator.hasNext()){
Map.Entry<Future,MyRunnable> entry = iterator.next();
Future future = entry.getKey();
if(future == null){
continue;
}
future.cancel(true);
taskMap.remove(future);//移除键对应的值
}
if(mCachedThreadPool!=null){
mCachedThreadPool.shutdown();//关闭执行器
}
mCachedThreadPool = null;
taskMap = null;
taskQueue = null;
}
public void notifyWork(){
synchronized (lock){
if(isNotify){
lock.notifyAll();
isNotify = !isNotify;
}
}
}
}
最后给出一篇写的比较好的关于线程池介绍的文章
线程池的使用