本文聚焦Android开发，介绍为避免主线程阻塞，将文件读写、网络请求等耗时操作放子线程处理。阐述了Thread、Runable、HandlerThread、AsyncTask等异步处理技术，还讲解了线程池的概念、使用原因及常见的四种线程池实现方式。
在android开发过程中，有很多耗时的操作需要放到子线程中，为了避免主线程进行耗时的操作而导致线程阻塞，可以将耗时操作放到子线程中去处理，这些操作主要包括文件的读写、网络请求、从服务器下载文件等等。
目前主要的异步处理技术有结构继承关系如下：
- Thread方式开启线程
1、定义一个类继承thread
2、重写run（）方法
public class MyThread extends Thread{
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
mHandler.sendEmptyMessage(0);
}
}
//开启线程
new MyThread （）.start();
- Runable方式开启线程
public class MyRunnable implements Runnable{
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
mHandler.sendEmptyMessage(0);
}
}
//开启线程
new thread(new MyRunnable()).start();
- HandlerThread 方式
HandlerThread 内部封装了Handler和继承了继承Thread类
实现步骤：
步骤1：创建HandlerThread实例对象
HandlerThread mHandlerThread = new HandlerThread("handlerThread");
步骤2 ：启动线程
// 步骤2：启动线程
mHandlerThread.start();
步骤3：创建工作线程Handler和重写handleMessage（）方法，// 作用：关联HandlerThread的Looper对象、实现消息处理操作 & 与其他线程进行通信
// 注：消息处理操作（HandlerMessage（））的执行线程 = mHandlerThread所创建的工作线程中执行
Handler workHandler = new Handler( mhandlerThread.getLooper() ) {
@Override
public boolean handleMessage(Message msg) {
...//消息处理
return true;
}
});
步骤4 ：使用工作线程Handler向工作线程的消息队列发送消息
Message msg = Message.obtain();
msg.what = 2;
msg.obj = "我是一条消息";
//通过Handler发送消息到其绑定的消息队列
workHandler.sendMessage(msg);
步骤5： // 步骤5：结束线程，即停止线程的消息循环
mHandlerThread.quit();
- AsyncTask
AsyncTask就是一个封装过的后台的异步任务执行类，AsyncTask定义了三种泛型类型 Params，Progress和Result。Params 启动任务执行的输入参数，比如HTTP请求的URL。Progress 后台任务执行的百分比。Result 后台执行任务最终返回的结果，比如返回String。对应到上面的线面的例子就是Integer, String, String。doInBackground(Params…) 方法在后台执行，比较耗时的操作都可以放在这里。在这里执行的是耗时操作，不能放在主线程中运行，此方法在后台线程执行。在执行过程中可以调用publicProgress(Progress…)来更新任务的进度。onProgressUpdate(String… Progress)这里对应的是doInBackground中调用的publicProgress，在这里进行处理，这里是UI主线程可以进行界面的更新onPreExecute（）这里相当于线程的开始，可以进行UI的处理。onPostExecute(Result) 相当于Handler 处理UI的方式，在这里面可以使用在doInBackground 得到的结果处理操作UI。 此方法在主线程执行，任务执行的结果作为此方法的参数返回。
public class MyAsyncTask extends AsyncTask<Integer, String, String> {
private Button btn;
public MyAsyncTask(Button btn) {
super();
this.btn = btn;
}
@Override
protected String doInBackground(Integer... integers) {
Log.e("xxxxxx","xxxxxxexecute传入参数="+integers[0]);
try {
Thread.sleep(1000);
publishProgress("过了一秒");
Thread.sleep(1000);
publishProgress("过了两秒");
Thread.sleep(1000);
publishProgress("过了三秒");
} catch (InterruptedException e) {
e.printStackTrace();
}
return "doInBackground的返回";
}
/**
* 这里的String参数对应AsyncTask中的第三个参数（也就是接收doInBackground的返回值）
* 在doInBackground方法执行结束之后在运行，并且运行在UI线程当中 可以对UI空间进行设置
*/
@Override
protected void onPostExecute(String result) {
btn.setText("线程结束" + result);
}
//该方法运行在UI线程当中,并且运行在UI线程当中 可以对UI空间进行设置
@Override
protected void onPreExecute() {
btn.setText("开始执行异步线程");
}
/**
* 这里的Intege参数对应AsyncTask中的第二个参数
* 在doInBackground方法当中，，每次调用publishProgress方法都会触发onProgressUpdate执行
* onProgressUpdate是在UI线程中执行，所有可以对UI空间进行操作
*/
@Override
protected void onProgressUpdate(String... values) {
String vlaue = values[0]+"";
Log.e("xxxxxx","xxxxxx vlaue="+vlaue);
btn.setText(vlaue+"");
}
}
如何启动任务：
//执行任务
new MyAsyncTask（）.execute();
- 线程池
1、线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。线程池为系统节约了大量的内存资源，省去了线程创建和销毁的系统所开销的内存。
2、为什么药使用线程池？
多线程运行时间，系统不断的启动和关闭新线程，成本非常高，会过渡消耗系统资源，以及过渡切换线程的危险，从而可能导致系统资源的崩溃。
具体常见的四种线程池的实现如下：
（1）、 Executors.newCacheThreadPool()
可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
//创建一个可缓存的线程池
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
try {
//sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
public void run() {
//打印正在执行的缓存线程信息
System.out.println(Thread.currentThread().getName()+"正在被执行");
}
});
}
}
}
（2）、Executors.newFixedThreadPool(int n)
创建一个可重用固定个数的线程池，指定当前线程池中线程的数量。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
//创建一个可重用固定个数的线程池
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
for (int i = 0; i < 10; i++) {
fixedThreadPool.execute(new Runnable() {
public void run() {
try {
//打印正在执行的缓存线程信息
System.out.println(Thread.currentThread().getName()+"正在被执行");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
(3)、Executors.newScheduledThreadPool(int n)
创建一个定长线程池，支持定时及周期性任务执行。
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
//创建一个定长线程池，支持定时及周期性任务执行——延迟执行
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
//延迟1秒执行
scheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println("延迟1秒执行");
}
}, 1, TimeUnit.SECONDS);
}
}
（4）、Executors.newSingleThreadExecutor()
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestThreadPoolExecutor {
public static void main(String[] args) {
//创建一个单线程化的线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
try {
//结果依次输出，相当于顺序执行各个任务
System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
扫一扫
1672
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
