Android基础知识：多线程基础总结

柔光的暖阳◎ 2024-04-17 13:55 148阅读 0赞

1、前言

Android中由于主线程不能进行耗时操作，所以耗时操作都要放到子线程中去做，所以多线程开发在实际中几乎无法避免。这篇文章就来总结一下与多线程有关的基础知识。

2、线程状态

一个线程有以下几种状态：
1. New： 新创建状态。线程被创建还没被调用start方法。在线程运行前还有些基础工作要做。
2. Runnable： 可运行状态。调用过start方法。一个可运行的线程可能正在运行也可能没在运行。
3. Blocked： 阻塞状态。表示线程被锁阻塞，暂时不活动。
4. Waiting： 等待状态。线程暂时不活动，直到线程调度器重新激活它。
5. Time waiting： 超时等待状态。和等待状态不用的是它是可以在指定的时间自行返回。
6. Terminated： 终止状态。表示当前线程已经执行完毕。

各个状态之间的转换关系如下图。

线程状态

3、线程的创建与终止

Java中创建线程的方法有三种：

3.1 继承Thread类，复写run方法。

  1. class MyThread extends Thread {
  2.         @Override
  3.         public void run() {
  4.             Log.d(TAG, "MyThread线程名：" + Thread.currentThread().getName());
  5.             Log.d(TAG, "MyThread is running");
  6.         }
  7.     }
  9.     private void createThread() {
  10.         MyThread myThread = new MyThread();
  11.         myThread.start();
  12.     }
  13. 复制代码

3.2 实现Runnable接口，实现run方法

  1. class MyRunnable implements Runnable {
  2.         @Override
  3.         public void run() {
  4.             Log.d(TAG, "MyRunnable线程名：" + Thread.currentThread().getName());
  5.             Log.d(TAG, "MyRunnable is running");
  6.         }
  7.     }
  9.     private void createRunnable() {
  10.         MyRunnable myRunnable = new MyRunnable();
  11.         Thread thread = new Thread(myRunnable);
  12.         thread.start();
  13.     }
  14. 复制代码

3.3 实现Callable接口，实现call方法。

  1. class MyCallable implements Callable<String> {
  2.         @Override
  3.         public String call() throws Exception {
  4.             Log.d(TAG, "MyCallable线程名：" + Thread.currentThread().getName());
  5.             Log.d(TAG, "MyCallable is running");
  6.             return "callable return";
  7.         }
  8.     }
  10.     private void createCallable() throws ExecutionException, InterruptedException {
  11.         MyCallable myCallable = new MyCallable();
  12.         FutureTask<String> futureTask = new FutureTask<>(myCallable);
  13.         Thread thread = new Thread(futureTask);
  14.         thread.start();
  15.         //获取返回值
  16.         String result = futureTask.get();
  17.         Log.d(TAG, result);
  18.     }
  19. 复制代码

Thread和Runnable平时见得很多了，而关于Callable相对比较少，它与Runnnable接口类似，但是它有两点与Runnnable接口不同：

  1. Runnnable中的run方法无法抛出异常，而Callable的call方法可以。
  2. Runnnable中的run方法没有返回值，而Callable的call方法可以。Callable可以拿到一个Future对象，表示异步任务的返回结果，调用get方法可以获取结果，如果此时异步任务还没完成会阻塞当前进程直到返回结果。

下面举个Callable使用的例子，模拟一个买菜做菜的过程。先用Runnable实现，再用Callable实现，做一下对比。

  1. private void runnableCook() throws InterruptedException {
  2.         //买食材线程
  3.         Thread foodThread = new Thread(new Runnable() {
  4.             @Override
  5.             public void run() {
  6.                 try {
  7.                     //买食材耗时
  8.                     Thread.sleep(5000);
  9.                 } catch (InterruptedException e) {
  10.                     e.printStackTrace();
  11.                 }
  12.                 Log.d(TAG, "五花肉已买");
  13.                 food = new String("五花肉");
  14.             }
  15.         });
  16.         Log.d(TAG, "我要开始做菜了");
  17.         Log.d(TAG, "我准备做红烧肉");
  18.         Log.d(TAG, "我没有食材");
  19.         //开启购买食材线程
  20.         Log.d(TAG, "叫隔壁老王帮我出门去买食材");
  21.         foodThread.start();
  22.         //模拟清洗厨具准备的耗时操作
  23.         Log.d(TAG, "清洗厨具准备调料，准备做菜");
  24.         Thread.sleep(3000);
  25.         //要等到食材买回来才能开始做菜，所以将食材线程join
  26.         foodThread.join();
  27.         Log.d(TAG, "开始做菜了");
  28.         cook(food);
  29.     }
  31.     private void cook(String food) {
  32.         if (TextUtils.isEmpty(food)) {
  33.             //没调用foodThread.join就会走这里
  34.             Log.d(TAG, "没有食材没法做菜");
  35.             return;
  36.         }
  37.         Log.d(TAG, "菜做好了，开吃了");
  38.     }
  39. 复制代码

代码很简单，就是定义一个买菜的线程做买菜的耗时任务，然后主线程打印做菜日志，因为Runnable没有返回值，在做完做菜准备之后需要调用foodThread.join()等待食材买回，再进行cook工作，如果不等到foodThread工作结束就调用cook方法，就会发现没有食材做菜。

未调用foodThread.join方法调用foodThread.join方法

接下来使用Callable来完成这个过程。

  1. private void callableCook() throws InterruptedException, ExecutionException {
  2.         Callable<String> callable = new Callable<String>() {
  3.             @Override
  4.             public String call() throws Exception {
  5.                 Thread.sleep(5000);
  6.                 Log.d(TAG, "五花肉已买");
  7.                 return "五花肉";
  8.             }
  9.         };
  10.         FutureTask<String> futureTask = new FutureTask<String>(callable);
  11.         Thread foodThread = new Thread(futureTask);
  12.         Log.d(TAG, "我要开始做菜了");
  13.         Log.d(TAG, "我准备做红烧肉");
  14.         Log.d(TAG, "我没有食材");
  15.         Log.d(TAG, "叫隔壁小王出门去买食材");
  16.         foodThread.start();
  17.         Log.d(TAG, "清洗厨具准备调料，准备做菜");
  18.         Thread.sleep(3000);
  19.         if (!futureTask.isDone()) {
  20.             Log.d(TAG, "食材还没到啊，小王好慢啊");
  21.         }
  22.         food = futureTask.get();
  23.         Log.d(TAG, "开始做菜了");
  24.         cook(food);
  25.     }
  27.        private void cook(String food) {
  28.         if (TextUtils.isEmpty(food)) {
  29.             //没调用foodThread.join就会走这里
  30.             Log.d(TAG, "没有食材没法做菜");
  31.             return;
  32.         }
  33.         Log.d(TAG, "菜做好了，开吃了");
  34.     }
  35. 复制代码

Callable接口的使用方法和Runnable类似。

第一步先实现Callable接口并为其指定一个泛型，这个泛型类型就是call方法要返回的类型，实现call方法在其中做耗时任务，并将任务结果通过return返回。

第二步创建一个FutrueTask，同样设置返回类型泛型，并将刚实现的Callable对象传入，这个FutrueTask后面就用来获得异步任务的结果。

最后一步和Runnable一样，新建一个Thread对象，将FutrueTask传入，然后开启线程即可。

与Runnable不同的是FutrueTask提供一个isDone方法用来判断异步任务是否完成，并且提供futureTask.get方法来获取异步任务的返回结果，如果此时任务还没结束，则会阻塞当前线程直到任务完成。这样就不会出现食材还没买回来就开始做菜了。

callable实现

3.4 终止线程

一个线程的run方法运行完成或者方法中刚出现异常之后这个线程就会终止。除此之外Thread类提供了stop和interrupt方法终止线程，其中stop已过时被弃用，而调用interrupt方法，线程会将自己的终止标识为true，线程会一直检测这个标识位以判断是否被终止。

安全停止线程的方法：采用布尔值变量
  1. private volatile boolean flag = true;
  3.   private void createFlagThread() {
  4.         flag = true;
  5.         count = 0;
  6.         thread = new Thread(new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 while (flag) {
  10.                     Log.d(TAG, "flag count:" + count++);
  11.                 }
  12.             }
  13.         });
  14.         thread.start();
  15.     }
  17.     private void changeFlag() {
  18.         flag = false;
  19.     }
  20. 复制代码

定义布尔值flag调用createFlagThread方法创建线程，run方法中通过flag来判断是否结束循环从而结束线程，当需要停止线程时，调用changeFlag方法将布尔值设置为false即可。

3.5 volatile关键字

在3.4的例子中，用来停止循环的布尔值变量上加了一个volatile关键字，volatile被称为轻量级的synchronized,但volatile只能修饰变量不能修饰方法。在遇到变量需要被多个线程访问时可以用volatile关键字修饰它。例如在经典的双重检查的单例模式下就会用到volatile修饰。

  1. public class Singleton {  
  2.     private volatile static Singleton singleton;  
  3.     private Singleton (){}  
  4.     public static Singleton getSingleton() {  
  5.     if (singleton == null) {  
  6.         synchronized (Singleton.class) {  
  7.         if (singleton == null) {  
  8.             singleton = new Singleton();  
  9.         }  
  10.         }  
  11.     }  
  12.     return singleton;  
  13.     }  
  14. }  
  15. 复制代码

那么volatile真的能替代synchronized吗？答案肯定是不能的。关于volatile的作用先要从并发编程的三个特性和Java的内存模型开始讲起。

3.5.1 原子性、可见性、有序性

  • 原子性： 原子性即满足不可拆分的操作，一个操作要么执行完成，要么没有执行。

    // 例如Java中的赋值操作

    1. int i = 1;//是原子行操作
    2. int j = i;//不是原子性操作，因为这个操作要先读取i的值，再将i的值赋给j

    复制代码

  • 可见性： 可见性是指多线程之间的可见性，一个线程修改了某个状态对另一个线程是可见的即另一个线程马上就能看得见修改。

  • 有序性： 有序性是指Java内存模型中是允许编译器和处理器对指令进行重排序的，重排序不会影响单线程执行的正确性，但是在多线程情况下就会形象多线程并发的正确行。
3.5.2 Java内存模型

Java运行时数据区域如下图。

从图中可以看出主要分为以下几个部分：

1. 程序计数器

程序计数器是一块较小的内存空间。可看做当前线程所执行的字节码的行号指示器，线程私有。

2. Java虚拟机栈

线程私有。生命周期与线程相同。Java虚拟机栈描述的是Java方法执行的内存模型。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。

3. 本地方法栈

与虚拟机栈作用相似，区别是虚拟机栈为虚拟机执行Java方法也就是字节码服务，而本地方法栈为虚拟机使用到的Native方法服务。

4. Java堆

所有线程共享的一块内存区域。在虚拟机启动时创建，存放对象实例。是垃圾收集器管理的主要区域。

5. 方法区

线程共享的一块内存区域。用于存储虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码的数据。

6. 运行时常量池

是方法区的一部分。用于存放编译期生成的各种字面量和符号引用。具有动态性。

7. 直接内存

并不是虚拟机运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域，但是这部分内存被频繁使用。

从以上可以看出Java堆内存是被所有线程共享的内存区域，于是就存在可见性的问题。Java内存模型定义了线程和主存之间的抽象关系：线程之间共享变量存储在主存中，每个线程有个私有的本地内存，本地内存中存储了共享变量的一个副本（本地内存是Java内存模型中一个抽象的概念，不真实存在）。抽象示意图如下。

如上图，线程A要与线程B通信要经过两个步骤：一是线程A把线程A本地内存中更新过的共享变量刷新到主内存中去；二是线程B要到主线程中读取线程A更新过去的共享变量。

回到之前讲的volatile关键字，volatile关键字修饰的变量只能保证并发三个特性中的两个：可见性和有序性。并不能保证原子性。所以在之前无论是单例还是中止线程的代码中都将多个线程访问的变量使用了volatile修饰，保证变量在一个线程修改了之后对所有线程可见且指令有序。又因为无法保证原子性，所以即使声明变量使用了volatile修饰，但是多个线程并发执行例如i++这种非原子性操作是还是会出现问题，这时就需要使用synchronized等方法来解决线程的同步问题。

4、线程同步

多线程访问同一个资源必然会产生线程同步问题，不解决线程同步问题就会造成资源数据的错误。关于线程同步问题还是通过那个经典的多窗口卖票问题来解释理解。

4.1 多窗口卖票

m个卖票窗口同时卖n张票，采用多线程实现。这里先看一下不做同步的错误示例。这里画了个简单的界面，两个输入框输入总票数和窗口数，按钮点击开始卖票，最后的结果由TextView展示。

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:tools="http://schemas.android.com/tools"
  4.     android:layout_width="match_parent"
  5.     android:layout_height="match_parent"
  6.     android:orientation="vertical"
  7.     tools:context=".TicketActivity">
  8.     <LinearLayout
  9.         android:layout_width="match_parent"
  10.         android:layout_height="wrap_content"
  11.         android:orientation="vertical">
  12.         <EditText
  13.             android:id="@+id/et_ticket_count"
  14.             android:layout_width="match_parent"
  15.             android:layout_height="wrap_content"
  16.             android:hint="输入总票数"
  17.             android:inputType="number"
  18.             android:text="100" />
  19.         <EditText
  20.             android:id="@+id/et_window_count"
  21.             android:layout_width="match_parent"
  22.             android:layout_height="wrap_content"
  23.             android:hint="输入卖票窗口数"
  24.             android:inputType="number"
  25.             android:text="3" />
  26.         <Button
  27.             android:id="@+id/btn_begin"
  28.             android:layout_width="match_parent"
  29.             android:layout_height="wrap_content"
  30.             android:text="开卖" />
  32.         <TextView
  33.             android:id="@+id/tv_result"
  34.             android:layout_width="match_parent"
  35.             android:layout_height="wrap_content"
  36.             android:textColor="@android:color/black"
  37.             android:textSize="16sp" />
  38.     </LinearLayout>
  39. </ScrollView>
  40. 复制代码

卖票方法代码：

  1. //结果字符串
  2.     private StringBuilder result = new StringBuilder();
  3.     //总票数
  4.     private  int  allTicketCount = 0;
  5.     //卖票窗口数
  6.     private int windowCount = 0;
  8.     private void begin() {
  9.         allTicketCount = Integer.parseInt(mEtTicketCount.getText().toString().trim());
  10.         windowCount = Integer.parseInt(mEtWindowCount.getText().toString().trim());
  11.         //每次调用清空之前结果
  12.         result.delete(0, result.length());
  13.         result.append("总票数：" + allTicketCount + "，共有" + windowCount + "个窗口卖票\n");
  14.         mTvResult.setText(result.toString());
  15.         //循环创建多个窗口线程并开启
  16.         for (int count = 1; count <= windowCount; count++) {
  17.             Thread window = new Thread(new TicketErrorRunnable(), "售票窗口" + count);
  18.             window.start();
  19.         }
  20.     }
  22.     /**
  23.      * 无同步
  24.      */
  25.     class TicketErrorRunnable implements Runnable {
  27.         @Override
  28.         public void run() {
  29.             while (allTicketCount > 0) {
  30.                     // 总票数大于0就将票数减一
  31.                     allTicketCount--;
  32.                     // 输出添加卖出一张票和剩余票数
  33.                     result.append(Thread.currentThread().getName() + "：卖出一张票，还剩" + allTicketCount + "张票。\n");
  34.                     //通知刷新UI
  35.                     runOnUiThread(new Runnable() {
  36.                         @Override
  37.                         public void run() {
  38.                             mTvResult.setText(result.toString());
  39.                         }
  40.                     });
  42.                 try {
  43.                     Thread.sleep(200);
  44.                 } catch (InterruptedException e) {
  45.                     e.printStackTrace();
  46.                 }
  48.             }
  49.             //循环结束说明票卖完了，刷新UI
  50.             result.append(Thread.currentThread().getName() + "：票卖完啦。\n");
  51.             runOnUiThread(new Runnable() {
  52.                 @Override
  53.                 public void run() {
  54.                     mTvResult.setText(result.toString());
  55.                 }
  56.             });
  58.         }
  59.     }
  60. 复制代码

运行结果：

未做同步 点击按钮执行 begin方法，根据运行结果可以看到不做线程同步，会出现这种两个窗口卖出同一张票的情况导致数据的错误。

4.2 同步代码块

将需要同步的代码放到同步代码块中可以保证线程同步，具体来看代码。

  1. /**
  2.      * 同步代码块
  3.      */
  4.     class TicketSyncRunnable implements Runnable {
  5.         @Override
  6.         public void run() {
  7.             while (allTicketCount > 0) {
  8.                 // ----------同步代码块----------------
  9.                 synchronized (TicketActivity.class) {
  10.                     allTicketCount--;
  11.                     result.append(Thread.currentThread().getName() + "：卖出一张票，还剩" + allTicketCount + "张票。\n");
  12.                     runOnUiThread(new Runnable() {
  13.                         @Override
  14.                         public void run() {
  15.                             mTvResult.setText(result.toString());
  16.                         }
  17.                     });
  18.                 }
  19.                // ----------同步代码块----------------
  20.                 try {
  21.                     Thread.sleep(200);
  22.                 } catch (InterruptedException e) {
  23.                     e.printStackTrace();
  24.                 }
  26.             }
  27.             result.append(Thread.currentThread().getName() + "：票卖完啦。\n");
  28.             runOnUiThread(new Runnable() {
  29.                 @Override
  30.                 public void run() {
  31.                     mTvResult.setText(result.toString());
  32.                 }
  33.             });
  34.         }
  35.     }
  36. 复制代码

这里其它的都没改变，只修改了Runnable中的内容，将对总票数的计算放到同步代码块中进行同步，保证同时只有一个线程能对总票数allTicketCount进行操作。

运行结果：

同步代码块

4.3 同步方法

将需要同步的代码抽出一个方法，再方法上加上synchronized关键字成为同步方法，也可以保证线程同步。

  1. /**
  2.      * 同步方法
  3.      */
  4.     class TicketSyncMethodRunnable implements Runnable {
  5.         @Override
  6.         public void run() {
  7.             ticket();
  8.             result.append(Thread.currentThread().getName() + "：票卖完啦。\n");
  9.             runOnUiThread(new Runnable() {
  10.                 @Override
  11.                 public void run() {
  12.                     mTvResult.setText(result.toString());
  13.                 }
  14.             });
  15.         }
  16.         // 同步方法
  17.         private synchronized void ticket() {
  18.             while (allTicketCount > 0) {
  19.                 allTicketCount--;
  20.                 result.append(Thread.currentThread().getName() + "：卖出一张票，还剩" + allTicketCount + "张票。\n");
  21.                 runOnUiThread(new Runnable() {
  22.                     @Override
  23.                     public void run() {
  24.                         mTvResult.setText(result.toString());
  25.                     }
  26.                 });
  27.                 try {
  28.                     Thread.sleep(200);
  29.                 } catch (InterruptedException e) {
  30.                     e.printStackTrace();
  31.                 }
  32.             }
  33.         }
  34.     }
  35. 复制代码

将对总票数的操作抽出到同步方法中，查看运行结果：

同步方法

4.4 重入锁ReentrantLock

自己给代码加锁当然也可以保证进程同步。

  1. private ReentrantLock reentrantLock = new ReentrantLock();
  3.     /**
  4.      * 重入锁
  5.      */
  6.     class TicketLockRunnable implements Runnable {
  7.         @Override
  8.         public void run() {
  9.             while (allTicketCount > 0) {
  10.                 //上锁
  11.                 reentrantLock.lock();
  12.                 try {
  13.                     allTicketCount--;
  14.                     result.append(Thread.currentThread().getName() + "：卖出一张票，还剩" + allTicketCount + "张票。\n");
  15.                     runOnUiThread(new Runnable() {
  16.                         @Override
  17.                         public void run() {
  18.                             mTvResult.setText(result.toString());
  19.                         }
  20.                     });
  21.                 } finally {
  22.                     //开锁
  23.                     reentrantLock.unlock();
  24.                 }
  25.                 try {
  26.                     Thread.sleep(200);
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.             }
  31.             result.append(Thread.currentThread().getName() + "：票卖完啦。\n");
  32.             runOnUiThread(new Runnable() {
  33.                 @Override
  34.                 public void run() {
  35.                     mTvResult.setText(result.toString());
  36.                 }
  37.             });
  39.         }
  40.     }
  41. 复制代码

运行结果：

加锁

5、Android中实现多线程的几种方式

Android中当然可以使用上面提到的三种创建线程的方法实现多线程，但是我这里要说的是Android里为我们提供的几种封装过的多线程执行异步任务的使用方法，毕竟我们手动new Thread().start()不仅不便于管理，而且还会有意想不到的收获（内存泄漏）。

5.1 AsyncTask

AsyncTask是Android提供的执行异步任务的类。
AsyncTask的使用：首先定义一个类继承AsyncTask：

  1. class MyAsyncTask extends AsyncTask<String, Integer, String> {
  2.         int count = 0;
  3.         @Override
  4.         protected void onPreExecute() {
  5.             //doInBackground执行之前
  6.             Log.d(TAG, Thread.currentThread().getName() + " 异步任务准备开始 " + System.currentTimeMillis());
  7.         }
  8.         @Override
  9.         protected void onProgressUpdate(Integer... values) {
  10.             //doInBackground执行中
  11.             Log.d(TAG, Thread.currentThread().getName() + " 任务进行中：" + values[0] + "% ");
  13.         }
  14.         @Override
  15.         protected void onPostExecute(String result) {
  16.             //doInBackground执行之后
  17.             Log.d(TAG, Thread.currentThread().getName() + " " + result + " " + System.currentTimeMillis());
  18.         }
  19.         @Override
  20.         protected String doInBackground(String... strings) {
  21.             Log.d(TAG, Thread.currentThread().getName() + " 异步任务执行中 " + System.currentTimeMillis());
  22.             while (count < 100) {
  23.                 try {
  24.                     Thread.sleep(100);
  25.                 } catch (InterruptedException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.                 count += 10;
  29.                 publishProgress(count);
  30.             }
  31.             Log.d(TAG, Thread.currentThread().getName() + " 异步任务完成！" + System.currentTimeMillis());
  32.             return Thread.currentThread().getName() + "：任务完成";
  33.         }
  34.     }
  35. 复制代码

AsyncTask三个泛型参数Params、Progress、Result分别对应传入的参数类型、中间进度的类型、返回结果的类型。AsyncTask主要有四个回调方法复写。

  • doInBackground：必须复写，异步执行后台线程，要完成的耗时任务在这里处理，运行在子线程。
  • onPreExecute：执行doInBackground前被调用,进行耗时操作前的初始化或者准备工作，运行在主线程。
  • onProgressUpdate：doInBackground执行完成后调用，返回处理结果，更新UI等，运行在主线程。
  • onProgressUpdate：在doInBackground方法中调用publishProgress方法后调用更新耗时任务进度，运行在主线程。

调用AsyncTask：

  1. MyAsyncTask myAsyncTask = new MyAsyncTask();
  2.    myAsyncTask.execute();
  3. 复制代码

运行结果日志：

关于想进一步了解AsyncTask的源码运行原理可以看Android进阶知识：AsyncTask相关

5.2 HandlerThread

HandlerThread是将Handler与Thread的封装，本质上还是一个Thread。
HandlerThread的使用如下：

  1. // 创建一个HandlerThread
  2.         HandlerThread handlerThread = new HandlerThread("myHandlerThread");
  3.         //调用start方法开启线程
  4.         handlerThread.start();
  5.         //创建一个Handler传入handlerThread的Looper
  6.         handler = new Handler(handlerThread.getLooper()) {
  7.             //复写handleMessage方法处理消息
  8.             @Override
  9.             public void handleMessage(Message msg) {
  10.                 switch (msg.what) {
  11.                     case 1:
  12.                         Log.d(TAG, Thread.currentThread().getName() + " receive one message");
  13.                         break;
  14.                 }
  15.             }
  16.         };
  18.         //在调用处使用handler发送消息
  19.         Message message = Message.obtain();
  20.         message.what = 1;
  21.         handler.sendMessage(message);
  23.         // 使用完退出HandlerThread
  24.         handlerThread.quit();
  25. 复制代码

运行结果日志：

关于想进一步了解 HandlerThread的源码运行原理可以看 Android进阶知识：HandlerThread相关

5.3 IntentService

IntentService是将Service与HandlerThread封装，与普通Service不同的是，普通Service运行在主线程，IntentService创建一个工作子线程执行任务，并且IntentService在执行完任务后自动关闭服务，而普通Service需要手动调用stopService方法。 IntentService使用如下：

  1. //继承实现IntentService
  2. public class MyIntentService  extends IntentService {
  4.     private static final String TAG = "MyIntentService";
  6.     public MyIntentService() {
  7.         super("MyIntentService");
  8.     }
  10.     @Override
  11.     protected void onHandleIntent(Intent intent) {
  12.         //复写onHandleIntent方法根据intent传递参数实现处理任务
  13.         String type = intent.getStringExtra("type");
  14.         switch (type){
  15.             case "type1":
  16.                 try {
  17.                     Thread.sleep(3000);
  18.                 } catch (InterruptedException e) {
  19.                     e.printStackTrace();
  20.                 }
  21.                 Log.d(TAG,Thread.currentThread().getName()+" type1 doing");
  22.                 break;
  23.         }
  24.     }
  25. }
  27. //因为是服务所以要在AndroidManifest中注册
  28. <?xml version="1.0" encoding="utf-8"?>
  29. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  30.     package="com.thread.threaddemo">
  32.     <application
  33.         android:allowBackup="true"
  34.         android:icon="@mipmap/ic_launcher"
  35.         android:label="@string/app_name"
  36.         android:roundIcon="@mipmap/ic_launcher_round"
  37.         android:supportsRtl="true"
  38.         android:theme="@style/AppTheme">
  39.         <activity android:name=".MainActivity">
  40.             <intent-filter>
  41.                 <action android:name="android.intent.action.MAIN" />
  43.                 <category android:name="android.intent.category.LAUNCHER" />
  44.             </intent-filter>
  45.         </activity>
  46.           ......
  47.         <service android:name=".MyIntentService"/>
  48.     </application>
  49. </manifest>
  51. //启动服务
  52. Intent intent = new Intent(this, MyIntentService.class);
  53. intent.putExtra("type", "type1");
  54. startService(intent);
  55. 复制代码

运行日志结果：

关于想进一步了解 IntentService的源码运行原理可以看 Android进阶知识：IntentService相关

5.4 Handler

对于Android开发者来说，Handler再熟悉不过了，Handler是Android提供的一种多线程间通信方式。Android关于多线程肯定避不开Handler。这里对Handler的使用就不举例了,想要了解使用及原理的可以看我写的这篇Android进阶知识：Handler相关。

6、线程池

线程池是用来管理线程的工具，在开发中如果每次进行异步任务都手动创建一个线程，不仅浪费资源而且不容易管理控制，线程池的使用就能很好的解决这些问题。

6.1 阻塞队列

在了解线程池之前先来了解一下阻塞队列，阻塞队列的理解有助于我们对线程池的工作原理的学习。阻塞队列是并发编程中“生产者-消费者”模式里用来存放元素的容器，生产者生产元素放入阻塞队列，消费者从阻塞队列中取出元素，当队列中没有元素或者队列中元素已满时会发生阻塞，直到队列中再次加入元素或者去除元素为止。阻塞队列实现了元素添加取出时的锁操作，所以使用时无需单独考虑线程同步问题。

Java中提供了七种阻塞队列：

  • ArrayBlockingQueue：由数组结构组成的有界阻塞队列。
  • LinkedBlockingQueue：由链表结构组成的有界阻塞队列。
  • PriorityBlockingQueue：支持优先级排序的无界阻塞队列。
  • DelayQueue：使用优先级队列实现的无界阻塞队列。
  • SynchronousQueue：不存储元素的阻塞队列。
  • LinkedTransferQueue：由链表结构足层的无界阻塞队列。
  • LinkedBlockingDeque：由链表结构组成的双向阻塞队列。

下面通过使用阻塞队列实现一个“生产者-消费者”模式的例子。

  1. package com.thread.threaddemo;
  3. import android.os.Bundle;
  4. import android.support.v7.app.AppCompatActivity;
  5. import android.util.Log;
  6. import android.view.View;
  7. import android.widget.Button;
  9. import java.util.concurrent.ArrayBlockingQueue;
  11. public class BlockingQueueActivity extends AppCompatActivity implements View.OnClickListener {
  13.     private static final String TAG = "BlockingQueueActivity";
  14.     private Button mBtnMain;
  15.     private Button mBtnProduce;
  16.     private Button mBtnConsumer;
  17.     // 阻塞队列
  18.     private ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(5);
  19.     @Override
  20.     protected void onCreate(Bundle savedInstanceState) {
  21.         super.onCreate(savedInstanceState);
  22.         setContentView(R.layout.activity_blocking_queue);
  23.         initView();
  24.     }
  25.     private void initView() {
  26.         mBtnMain = (Button) findViewById(R.id.btn_main);
  27.         mBtnProduce = (Button) findViewById(R.id.btn_produce);
  28.         mBtnConsumer = (Button) findViewById(R.id.btn_consumer);
  29.         mBtnMain.setOnClickListener(this);
  30.         mBtnProduce.setOnClickListener(this);
  31.         mBtnConsumer.setOnClickListener(this);
  32.     }
  33.     @Override
  34.     public void onClick(View v) {
  35.         switch (v.getId()) {
  36.             case R.id.btn_main:
  37.                 mainStart();
  38.                 break;
  39.             case R.id.btn_produce:
  40.                 addData();
  41.                 break;
  42.             case R.id.btn_consumer:
  43.                 removeData();
  44.                 break;
  45.         }
  46.     }
  47.     /*
  48.      * 手动从阻塞队列取出一个元素
  49.      */
  50.     private void removeData() {
  51.         Thread thread = new Thread(new Runnable() {
  52.             @Override
  53.             public void run() {
  54.                 try {
  55.                     queue.take();
  56.                     printData();
  57.                 } catch (InterruptedException e) {
  58.                     e.printStackTrace();
  59.                 }
  60.             }
  61.         }, "remove");
  62.         thread.start();
  63.     }
  64.     /*
  65.      * 手动从阻塞队列添加一个元素
  66.      */
  67.     private void addData() {
  68.         Thread thread = new Thread(new Runnable() {
  69.             @Override
  70.             public void run() {
  71.                 try {
  72.                     queue.put("data");
  73.                     printData();
  74.                 } catch (InterruptedException e) {
  75.                     e.printStackTrace();
  76.                 }
  77.             }
  78.         }, "add");
  79.         thread.start();
  80.     }
  81.      /*
  82.       * 打印日志
  83.       */
  84.     private void printData() {
  85.         Log.d(TAG, Thread.currentThread().getName() + ":" + queue.toString());
  86.     }
  87.      /*
  88.       * 开启生产者消费者线程
  89.       */
  90.     private void mainStart() {
  91.         ProducerThread producerThread = new ProducerThread("Producer");
  92.         producerThread.start();
  93.         ConsumerThread consumerThread = new ConsumerThread("Consumer");
  94.         consumerThread.start();
  95.     }
  96.      /*
  97.       * 消费者线程
  98.       */
  99.     class ConsumerThread extends Thread {
  100.         public ConsumerThread(String name) {
  101.             super(name);
  102.         }
  103.         @Override
  104.         public void run() {
  105.             while (true) {
  106.                 try {
  107.                     Thread.sleep(2000);
  108.                     queue.take();
  109.                     printData();
  110.                 } catch (InterruptedException e) {
  111.                     e.printStackTrace();
  112.                 }
  113.             }
  114.         }
  115.     }
  116.      /*
  117.       * 生产者线程
  118.       */
  119.     class ProducerThread extends Thread {
  120.         public ProducerThread(String name) {
  121.             super(name);
  122.         }
  123.         @Override
  124.         public void run() {
  125.             while (true) {
  126.                 try {
  127.                     Thread.sleep(1000);
  128.                     queue.put("data");
  129.                     printData();
  130.                 } catch (InterruptedException e) {
  131.                     e.printStackTrace();
  132.                 }
  133.             }
  134.         }
  135.     }
  136. }
  137. 复制代码

运行打印日志：

从这段代码可以看到首先创建阻塞队列queue容量为5,点击按钮调用mainStart方法，开启生产者线程和消费者线程，生产者线程每隔1秒生产一个元素加入队列，消费者每隔2秒消费一个元素取出队列。可以看到由于生产比消费快，所以容器逐渐被加满，最后保证队列中充满五个元素，再想添加只能等到消费者线程消费了元素才行。当然也可以通过手动调用addData或removeData方法来向队列里添加和取出元素，同样阻塞队列满了或者空了就会发生阻塞，直到队列中空出位置或者加入新元素为止。

6.2 线程池

6.2.1 构造函数

Java中线程池的核心实现类是ThreadPoolExecutor，无论是Runnable还是Callable都可以交给线程池来统一管理，要使用线程池就要先创建一个线程池对象。

  1. ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 20, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(100), threadFactory, new ThreadPoolExecutor.AbortPolicy());
  2. 复制代码

这样就创建了一个线程池对象，接着就可以调用execute或submit提交任务，线程池会分配线程处理任务。不过ThreadPoolExecutor的构造方法中这几个参数到底代表了什么，我们来看一下它的构造方法。

  1. public ThreadPoolExecutor(int corePoolSize,
  2.                               int maximumPoolSize,
  3.                               long keepAliveTime,
  4.                               TimeUnit unit,
  5.                               BlockingQueue<Runnable> workQueue,
  6.                               ThreadFactory threadFactory,
  7.                               RejectedExecutionHandler handler) {
  8.         if (corePoolSize < 0 ||
  9.             maximumPoolSize <= 0 ||
  10.             maximumPoolSize < corePoolSize ||
  11.             keepAliveTime < 0)
  12.             throw new IllegalArgumentException();
  13.         if (workQueue == null || threadFactory == null || handler == null)
  14.             throw new NullPointerException();
  15.         this.corePoolSize = corePoolSize;
  16.         this.maximumPoolSize = maximumPoolSize;
  17.         this.workQueue = workQueue;
  18.         this.keepAliveTime = unit.toNanos(keepAliveTime);
  19.         this.threadFactory = threadFactory;
  20.         this.handler = handler;
  21.     }
  22. 复制代码

构造函数中就是对这几个成员参数的一个初始化赋值，来看这几个参数代表的意思。

  • corePoolSize： 核心线程数。默认情况下线程池是空的，在有任务提交时，当前运行线程少于corePoolSize数，就会创建新线程来处理任务。
  • maximumPoolSize： 线程池允许创建的最大线程数。如果任务队列已满并且线程数小于maximumPoolSize时，线程池仍旧会创建新的线程来处理任务。
  • keepAliveTime： 非核心线程空闲的超时时间。超过这个时间则会被回收。
  • TimeUnit： ：keepAliveTime的时间单位。
  • workQueue： 任务队列。是一个阻塞队列，如果当前线程数大核心线程数，则将任务添加到此任务队列中。
  • ThreadFactory： 线程工厂。
  • RejectedExecutionHandler： 饱和策略。当任务队列和线程池都满了时所采取的策略。
6.2.2 执行流程

线程执行流程源码从ThreadPoolExecutor的execute方法开始来看。

  1. public void execute(Runnable command) {
  2.         if (command == null)
  3.             throw new NullPointerException();
  4.         int c = ctl.get();
  5.         //判断工作线程数是否小于核心线程数
  6.         if (workerCountOf(c) < corePoolSize) {
  7.             //小于就调用addWorker方法创建核心线程
  8.             //这里第二个参数true表示是核心线程
  9.             if (addWorker(command, true))
  10.                 return;
  11.             c = ctl.get();
  12.         }
  13.         //否则调用workQueue.offer方法将任务放入任务队列
  14.         if (isRunning(c) && workQueue.offer(command)) {
  15.             int recheck = ctl.get();
  16.             if (! isRunning(recheck) && remove(command))
  17.                 reject(command);
  18.             else if (workerCountOf(recheck) == 0)
  19.                 addWorker(null, false);
  20.         }
  21.         //放入任务队列失败则再调用addWorker方法创建非核心线程执行任务
  22.         //这里第二参数传入false表示非核心线程
  23.         else if (!addWorker(command, false))
  24.            //如果addWorker返回false
  25.            //说明线程数超过最大线程数maximumPoolSize
  26.            //调用reject方法执行饱和策略
  27.             reject(command);
  28.     }
  29. 复制代码

由上述代码和注释可以看出具体执行流程如下：

  1. 判断线程池中核心线程数量是否已到达设置的最大核心线程数corePoolSize,若没有到达核心线程数就创建核心线程处理任务。
  2. 若已到达核心线程数，再判断任务队列是否已满，若未满就将任务加入到任务队列中。
  3. 若任务队列已满，再判断是否已达到线程池最大线程数maxmumPoolSize,若未达到最大线程数，则创建非核心线程处理任务。
  4. 若到达最大线程数，就执行饱和策略。

这里再继续看一下reject方法：

  1. final void reject(Runnable command) {
  2.         handler.rejectedExecution(command, this);
  3.     }
  4. 复制代码

调用了饱和策略中的rejectedExecution方法。这里饱和策略有4种，分别是：

  • AbordPolicy： 默认是这种策略，表示无法处理新任务，并抛出RejectedExecutionException异常。
  • CallerRunsPolicy： 用调用者所在的线程来处理任务。
  • DiscardPolicy： 不能执行的任务，并将该任务删除。
  • DiscardOldestPolicy： 丢弃队列最近的任务，并执行当前的任务。

这里看下默认的AbordPolicy的实现。

  1. public static class AbortPolicy implements RejectedExecutionHandler {
  2.         /**
  3.          * Creates an {@code AbortPolicy}.
  4.          */
  5.         public AbortPolicy() { }
  7.         /**
  8.          * Always throws RejectedExecutionException.
  9.          *
  10.          * @param r the runnable task requested to be executed
  11.          * @param e the executor attempting to execute this task
  12.          * @throws RejectedExecutionException always
  13.          */
  14.         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
  15.             throw new RejectedExecutionException("Task " + r.toString() +
  16.                                                  " rejected from " +
  17.                                                  e.toString());
  18.         }
  19.     }
  20. 复制代码

可以看到实现很简单就是实现了RejectedExecutionHandler接口，复写rejectedExecution方法，抛出RejectedExecutionException异常。其它的饱和策略的实现也是类似。

线程池执行流程

6.2.3 常用线程池

Java中提供了几种默认常用线程池。

  • FixedThreadPool： 可重用固定线程数的线程池。

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

    1.     return new ThreadPoolExecutor(nThreads, nThreads,
    2.                                   0L, TimeUnit.MILLISECONDS,
    3.                                   new LinkedBlockingQueue<Runnable>(),
    4.                                   threadFactory);
    5. }

    复制代码

从创建方法中可以看出FixedThreadPool线程池的核心线程数和最大线程数是相同的，所以它是没有非核心线程的。并且它的线程空闲超时时长设置为0，所以一旦线程任务结束空闲下来就会被回收，因此不会有空闲线程存在。

  • CachedThreadPool： 可缓存线程池。

    public static ExecutorService newCachedThreadPool() {

    1.     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
    2.                                   60L, TimeUnit.SECONDS,
    3.                                   new SynchronousQueue<Runnable>());
    4. }

    复制代码

CachedThreadPool它的核心线程数为0，不会创建核心线程，而是直接将任务加入任务队列，而它的最大线程数为Integer.MAX_VALUE，也就是说可以无限创建非核心线程的来处理任务。并且它的线程空闲超时时间为60秒，空闲线程可以缓存60秒后才会被回收。

  • SingleThreadExecutor： 单线程工作的线程池。

    public static ExecutorService newSingleThreadExecutor() {

    1.     return new FinalizableDelegatedExecutorService
    2.         (new ThreadPoolExecutor(1, 1,
    3.                                 0L, TimeUnit.MILLISECONDS,
    4.                                 new LinkedBlockingQueue<Runnable>()));
    5. }

    复制代码

SingleThreadExecutor的核心线程数为1，最大线程数为1，所以SingleThreadExecutor线程池中只有一个核心线程在工作，空闲超时时间为0，任务结束立即回收，在唯一的核心线程在工作时，提交的任务会放入LinkedBlockingQueue任务队列中等待一个一个执行。

  • ScheduledThreadPool： 实现定时和周期性任务的线程池。

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {

    1.     return new ScheduledThreadPoolExecutor(corePoolSize);
    2. }
    4. public ScheduledThreadPoolExecutor(int corePoolSize) {
    5.     super(corePoolSize, Integer.MAX_VALUE,
    6.           DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
    7.           new DelayedWorkQueue());
    8. }

    复制代码

ScheduledThreadPool的核心线程数是固定传入的，而最大线程数是Integer.MAX_VALUE，任务队列为DelayedWorkQueue，本身是无界队列，所以线程池中不会创建非核心线程，当工作线程数到达核心线程数时，线程池只会一直往任务队列中添加任务，空闲线程的超时时间为10秒。

7、总结

以上就是Android中多线程相关的基础知识。关于多线程在使用的时候需要多加注意，不仅要注意保证线程同步在Android中还要注意内存泄漏的发生。需要频繁创建子线程操作最好使用线程池进行管理。

参考资料：

Android进阶之光
深入理解Java虚拟机

转载于:https://juejin.im/post/5d385466f265da1bbc701999

发表评论

表情：
评论列表 （有 0 条评论，148人围观）

还没有评论，来说两句吧...

相关阅读

    相关 java多线程基础知识点总结

    我们知道应用程序是以进程为单位运行，那应用程序内部如何多个子任务同时执行呢，这就引入了多线程，这里我们就可以得出，线程是进程的运行单位； java实现多线程的的方式主要有以下

    r囧r小猫r囧r小猫/ 0 赞/ 53 阅读

    相关 Java多线程基础知识总结

    一、前言 线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要原因有两点，一是存在共享数据，二是存在多条线程操作共享数据。当存在多个线程操作共享数据时

    桃扇骨桃扇骨/ 0 赞/ 580 阅读