java 线程池ThreadPoolExecutor 如何与 AsyncTask() 组合使用。

转载请声明出处谢谢!https://cloud.tencent.com/developer/user/1148436/activities

这里主要使用Executors中的4种静态创建线程池实例方法中的 newFixedThreadPool()来举例讲解。

简单说下Executors类,提供的一系列创建线程池的方法:

他们都有两个构造方法

1. --------newFixedThreadPool

(创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。)

public static ExecutorService newFixedThreadPool(int nThreads); public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory);

2. --------newSingleThreadExecutor

(创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。)

public static ExecutorService newSingleThreadExecutor(); public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory);

3. --------newCachedThreadPool

(创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程) public static ExecutorService newCachedThreadPool(); public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory);

4. --------newScheduledThreadPool

(创建一个定长线程池,支持定时及周期性任务执行。)

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize); public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory);

*******************************************

定长线程池-newFixedThreadPool 的第一个构造方法

public static ExecutorService newFixedThreadPool(int nThreads);传入的参数nThreads是最大的同时进行、并发的线程数。如果我定义它是3,那么同时执行3个,超过的了就要排队等待,流水线操作形式。

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory);

这个构造函数的第一个参数和上面的一个样,第二个是线程工厂,它的作用:

文档中是这样说的:

这是什么意思呢? 其实就是说,在把线程加入线程池之前,都对它们共同进行一些操作,例如改变一些属性。比如说setName(),thread-1和2、3、4 依次通过一个for 循环加入到线程池 中,他们的 Name 都会被改变。

线程池一般的使用方法:

通过 Executors.newFixedThreadPool(...).execute(Runnable()) 并发运行,例如下面的代码片段

 1 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
 2 for (int i = 0; i < 10; i++) {
 3     final int index = i;
 4     fixedThreadPool.execute(new Runnable() {
 5  
 6         @Override
 7         public void run() {
 8             try {
 9                 Log.d("******", Thread.currentThread().getId() + "  thread name: " + Thread.currentThread().getName()+"--"+index);
10                 Thread.sleep(2000);
11             } catch (InterruptedException e) {
12                 // TODO Auto-generated catch block
13                 e.printStackTrace();
14             }
15         }
16     });
17 }

运行结果如下

因为线程池大小为3,最多3个同时运行,每个输出index后sleep 2秒,所以每两秒打印3个数字。

线程池和AsyncTask()结合使用:

AsyncTask() 知识恶补入口:http://www.2cto.com/kf/201203/122729.html

这里只说下 AsyncTask()的executeOnExecutor() 方法,它是3.0后新增的一个方法。executeOnExecutor(Executor exec, Object... params),

该方法接受2个参数:

第一个参数是Executor,即是我们的线程池实例,默认的可以传入AsyncTask.THREAD_POOL_EXECUTOR,多线程并发,我们上面的是自定义的线程池,默认的最大并发5个,队列最大128个,当然,我们可以new 一个ThreadPoolExecutor 实例,通过传入参数改变这些限制;

第二个是任务参数。即是AsyncTask()中的第一个参数,我们可以在doInBackground()中获取它,我下面的例子中,这个参数是字符串。

下面通过运行代码看看它和 AsyncTask() 是怎样联系的:

  1 package cn.mr.ams.threadpool;
  2 
  3 import android.app.Activity;
  4 import android.os.AsyncTask;
  5 import android.os.Bundle;
  6 import android.util.Log;
  7 import android.view.Menu;
  8 import android.view.MenuItem;
  9 
 10 import java.util.concurrent.CyclicBarrier;
 11 import java.util.concurrent.ExecutorService;
 12 import java.util.concurrent.Executors;
 13 import java.util.concurrent.ThreadFactory;
 14 
 15 
 16 public class MyActivity extends Activity {
 17 
 18     CyclicBarrier barrier = new CyclicBarrier(3);
 19     public static int j = 0 ;
 20     public final Object myTPLock = new Object();//对象锁,主要用来实现同步,我这里并没有使用
 21     public static ExecutorService myTP = null;//和 AsyncTask() 连用
 22     public static ExecutorService myTP_1 = Executors.newFixedThreadPool(3);//第一种构造函数
 23     //private List<String> test = new ArrayList<String>();
 24 
 25     private String[] test = new String[]{"a--","b--","c--","d--","e--"};
 26 
 27     @Override
 28     protected void onCreate(Bundle savedInstanceState) {
 29         super.onCreate(savedInstanceState);
 30         setContentView(R.layout.activity_my);
 31         //采用 第二种 构造方法,改写下 线程工厂 对象,使每次加入线程池中的线程都能被设置定义的属性
 32         myTP = Executors.newFixedThreadPool(3, new ThreadFactory() {
 33             @Override
 34             public Thread newThread(Runnable r) {
 35                 Thread t = new Thread(r);
 36                 //我把所加入到改线程池的线程全改名了
 37                 t.setName("LinGuanHong");
 38                 // 设置线程的优先级别
 39                 t.setPriority(Thread.NORM_PRIORITY - 1);
 40                 return t;
 41             }
 42         });
 43         for(String item : test) {
 44             //通过 for 循环,把 AsyncTask() 异步线程逐个 加入到线程池中
 45             new myThread(barrier).executeOnExecutor(myTP,item);
 46             //SystemClock.sleep(10);//能起到一定的延时,实现按顺序进行
 47         }
 48         /*for (int i = 0; i < 10; i++) {
 49             final int index = i;
 50             myTP_1.execute(new Runnable() {
 51                 @Override
 52                 public void run() {
 53                     try {
 54                         Log.d("******", Thread.currentThread().getId() + "  thread name: " + Thread.currentThread().getName()+"--"+index);
 55                         Thread.sleep(2000);
 56                     } catch (InterruptedException e) {
 57                         // TODO Auto-generated catch block
 58                         e.printStackTrace();
 59                     }
 60                 }
 61             });
 62         }*/
 63 
 64     }
 65 
 66 
 67 public class myThread extends AsyncTask<Object, Void, String> {
 68     private CyclicBarrier barrier = null;
 69     public myThread(CyclicBarrier barrier){
 70         this.barrier = barrier;
 71     }
 72 
 73     @Override
 74     protected String doInBackground(Object[] params) {
 75         Object id = params[0];
 76         String idString = id.toString();
 77         //synchronized (myTPLock) {
 78         Log.d("******", idString + " id: " + Thread.currentThread().getId() + "  " +
 79                 "thread name: " + Thread.currentThread().getName()+" "+MyActivity.j);
 80         //}
 81         MyActivity.j++;
 82         return null;
 83     }
 84 }
 85 
 86 
 87     @Override
 88     public boolean onCreateOptionsMenu(Menu menu) {
 89         // Inflate the menu; this adds items to the action bar if it is present.
 90         getMenuInflater().inflate(R.menu.my, menu);
 91         return true;
 92     }
 93 
 94     @Override
 95     public boolean onOptionsItemSelected(MenuItem item) {
 96         // Handle action bar item clicks here. The action bar will
 97         // automatically handle clicks on the Home/Up button, so long
 98         // as you specify a parent activity in AndroidManifest.xml.
 99         int id = item.getItemId();
100         if (id == R.id.action_settings) {
101             return true;
102         }
103         return super.onOptionsItemSelected(item);
104     }
105 }

运行结果

在这里我们可以验证,我们采用第二种构造方法,在线程工厂中改变 各线程的名字。

在我的代码45行中,我通过for 循环有顺序地传入 a~e 字符串,但是这里的线程并没有按照顺序运行。即是并发了,因为AsyncTask本身是异步线程,我们再看上述代码19行,我设置了个静态的 int 标记,在 AsyncTask() 里面 78~81行没打一次 log 就++,按照我们对异步、并发线程的理解,和可能就会出现,输出的0~5是不按照顺序的,但是上面是按照顺序的,不仅仅是一次的截图,我自己测试过很多次,0~5的输出都是按顺序的。

我自己的总结,可能不一定对,有错请大家指出:

把AsyncTask()异步线程加入到线程池中运行,能够很高效地提高执行任务的速度,如果不加其他操作限制,每个线程的执行可能是不按照顺序的,但是,他们却没有出现抢占资源的状况??

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏MelonTeam专栏

Fork/Join 框架

1. 简介 1.1 什么是Fork/Join框架 Java 5 引入了 Executor 和 ExecutorService 接口,使得 Java在并发支持...

1846
来自专栏java一日一条

Java NIO 核心组件学习笔记

对于I/O操作,根据Oracle官网的文档,同步异步的划分标准是“调用者是否需要等待I/O操作完成”,这个“等待I/O操作完成”的意思不是指一定要读取到数据或者...

612
来自专栏无题

JDK中Concurrent包工具类指南

这篇翻译指南很能解决问题,对于初步建立并发包的认识很有帮助,感谢原作者和翻译者 Java 并发工具包 java.util.concurrent 用户指南 ...

4966
来自专栏函数式编程语言及工具

Akka(24): Stream:从外部系统控制数据流-control live stream from external system

 在数据流应用的现实场景中常常会遇到与外界系统对接的需求。这些外部系统可能是Actor系统又或者是一些其它类型的系统。与这些外界系统对接的意思是在另一个线程...

20110
来自专栏逸鹏说道

分享一个自制的 .net线程池2

/// <summary> /// 该方法必须在 locked 下执行 /// </summary> ...

2315
来自专栏JavaQ

concurrent包下线程池类小结

并发包下的线程池技术虽然常用,但是知识点较多易忘。所以,参考网络资源做了一个小结,便于复习。 Executor接口 用于执行已提交的Runnable任务。 ? ...

3014
来自专栏Java与Android技术栈

RxJava 之 ParallelFlowable

RxJava 2.0.5 版本新增了 ParallelFlowable API,它允许并行地执行一些运算符,譬如map、filter、concatMap、fla...

542
来自专栏Java架构沉思录

优雅实现延时任务之zookeeper篇

在《优雅实现延时任务之Redis篇》一文中提到,实现延时任务的关键点,是要存储任务的描述和任务的执行时间,还要能根据任务执行时间进行排序,那么我们可不可以使用z...

623
来自专栏码洞

Java高阶必备之Netty基础原理

Netty是Java程序员通向高阶之路必须要过的门槛之一。干了几年的Java程序员发现业务开发似乎就是在SSH的世界里摸滚打爬的时候,会开始感到迷茫,难道程序员...

742
来自专栏飞雪无情的博客

Go语言实战笔记(二十)| Go Context

控制并发有两种经典的方式,一种是WaitGroup,另外一种就是Context,今天我就谈谈Context。

943

扫码关注云+社区