Android多线程：继承Thread类、实现Runnable接口使用教程(含实例讲解)

末蓝、 2022-05-23 00:50 265阅读 0赞

![a26aedafc2ac45510787091b1d02f019.png][]

# 前言 #

*  在`Android`开发中，多线程的使用十分常见
 *  今天，我将全面解析多线程中最常见的2种用法：继承`Thread`类 & 实现`Runnable`接口

> **Carson带你学多线程系列**  
> 基础汇总  
> [Android多线程：基础知识汇总][Android]  
> 基础使用  
> [Android多线程：继承Thread类使用(含实例教程)][Android_Thread]  
> [Android多线程：实现Runnable接口使用(含实例教程)][Android_Thread]  
> 复合使用  
> [Android多线程：AsyncTask使用教程(含实例讲解)][Android_AsyncTask]  
> [Android多线程：AsyncTask的原理及源码分析][Android_AsyncTask 1]  
> [Android多线程：HandlerThread使用教程(含实例讲解)][Android_HandlerThread]  
> [Android多线程：HandlerThread的原理及源码分析][Android_HandlerThread 1]  
> [Android多线程：IntentService使用教程(含实例讲解)][Android_IntentService]  
> [Android多线程：IntentService的原理及源码分析][Android_IntentService 1]  
> [Android多线程：线程池ThreadPool全方位教学][Android_ThreadPool]  
> 相关使用  
> [Android异步通信：这是一份全面&详细的Handler机制学习攻略][Android_Handler]  
> [Android多线程：手把手教你全面学习神秘的Synchronized关键字][Android_Synchronized]  
> [Android多线程：带你了解神秘的线程变量 ThreadLocal][Android_ ThreadLocal]

--------------------

# Part 1：继承Thread类 #

# 目录 #

![示意图][880206460cf6d6bcbaf536cad9b24032.png]

--------------------

# 1. 简介 #

![示意图][0d6178edc4f37f4bd7b590c3879ea572.png]

--------------------

# 2. 使用讲解 #

### 2.1 使用步骤 ###

![示意图][322e3c75d95b15baa0c875245f8e5765.png]

### 2.2 具体使用 ###

// 步骤1：创建线程类 （继承自Thread类）
       class MyThread extends Thread{
    
    // 步骤2：复写run（），内容 = 定义线程行为
        @Override
        public void run(){
        ... // 定义的线程行为
        }
    }
    
    // 步骤3：创建线程对象，即 实例化线程类
      MyThread mt=new MyThread(“线程名称”);
    
    // 步骤4：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起  / 停止
    // 此处采用 start（）开启线程
      mt.start();

### 2.3 简便使用：匿名类 ###

很多情况下，开发者会选择一种更加方便的方法去创建线程：**匿名类**

// 步骤1：采用匿名类，直接 创建 线程类的实例
     new Thread("线程名称") {
                     // 步骤2：复写run（），内容 = 定义线程行为
                        @Override
                        public void run() {       
                      // 步骤3：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起  / 停止   
                          }.start();

### 2.3 区别 ###

2种方法本质相同，但是各有优劣势 & 不同的应用场景：

> 大家可根据自己的需求场景来选择具体的使用方法

![示意图][b1966898ef02c44679ac7e968bdbb452.png]

> 为了让大家理解更加深刻，下面例子我都会采用**方法1 = 常规方式** 来演示

--------------------

# 3. 实例应用 #

### 实例1 ###

*  应用场景：创建两个线程-实现两个相同的耗时任务
 *  实例说明：实现2个窗口同时卖火车票；每个窗口卖100张，卖票速度都是1s/张

> 建议先下载Demo再看分析：[Carson\_Ho的Github地址：多线程之继承Thread类][Carson_Ho_Github_Thread]

*  具体实现

*main\_activity.xml*

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context="com.example.carson_ho.demoforthread.MainActivity">
    
    //设置一个按钮用以启动卖票
        <Button
            android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="点击开始卖票"
            android:layout_centerInParent="true"
            />
    </RelativeLayout>

*MainActivity.java*

package com.example.carson_ho.demoforthread;
    
    import android.os.Bundle;
    import android.support.v7.app.AppCompatActivity;
    import android.view.View;
    import android.widget.Button;
    
    public class MainActivity extends AppCompatActivity {
    
        //主布局中定义了一个按钮用以启动线程
        Button button;
    
        //步骤1:创建线程类,继承自Thread类
        private class MyThread extends Thread{
    
            private int ticket = 100;//一个窗口有100张票
            private String name; //窗口名, 也即是线程的名字
    
            public MyThread(String name){
                this.name=name;
            }
    
            //在run方法里复写需要进行的操作
            @Override
            public void run(){
                while (ticket>0){
                    ticket--;
                    System.out.println(name + "卖掉了1张票，剩余票数为:"+ticket);
    
                    try {
                        Thread.sleep(1000);//卖票速度是1s一张
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
            @Override
            protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);
    
                //Button按下时会开启一个新线程执行卖票
                button = (Button) findViewById(R.id.button);
                button.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
    
                        //步骤2:创建线程类的实例
                        //创建二个线程，模拟二个窗口卖票
                        MyThread mt1 = new MyThread("窗口1");
                        MyThread mt2 = new MyThread("窗口2");
    
                        //步骤3：调用start()方法开启线程
                        //启动二个线程，也即是窗口，开始卖票
                        mt1.start();
                        mt2.start();
    
                    }
                });
    
            }
        }

*  测试结果

![结果展示][d6b449f790971b0470f0885f5bbc19a4.png]

*  Demo源码地址  
    [Demo for Thread example1][]

--------------------

### 实例2 ###

*  应用场景：创建两个线程-实现两个不同的耗时任务
 *  实例说明：实现2个窗口同时卖火车票；每个窗口卖100张，但卖票速度不同：窗口1是1s/张，窗口2是3s/张

> 建议先下载Demo再看分析：[Carson\_Ho的Github地址：多线程之继承Thread类][Carson_Ho_Github_Thread]

*  具体实现

*main\_activity.xml*

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context="com.example.carson_ho.demoforthread_2.MainActivity">
    
        //设置一个按钮以启动卖票
        <Button
            android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="点击开始卖票" />
    </RelativeLayout>

*MainActivity.java*

package com.example.carson_ho.demoforthread_2;
    
    import android.os.Bundle;
    import android.support.v7.app.AppCompatActivity;
    import android.view.View;
    import android.widget.Button;
    
    public class MainActivity extends AppCompatActivity {
        //主布局中定义了一个按钮用以启动线程
        Button button;
    
        //步骤1:创建线程类,继承自Thread类
        //因为这里需要有两个操作:一个窗口卖票速度是1s/张,一个窗口是3s/张
        //所以需要创建两个Thread的子类
    
        //第一个Thread子类实现一个窗口卖票速度是1s/张
        private class MyThread1 extends Thread{
    
            private int ticket = 100;//一个窗口有100张票
            private String name; //窗口名, 也即是线程的名字
    
            public MyThread1(String name){
                this.name=name;
            }
    
            //在run方法里复写需要进行的操作:卖票速度是1s/张
            @Override
            public void run(){
                while (ticket>0){
                    ticket--;
                    System.out.println(name + "卖掉了1张票，剩余票数为:"+ticket);
    
                    try {
                        Thread.sleep(1000);//卖票速度是1s一张
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
        //第二个Thread子类实现一个窗口卖票速度是3s/张
        private class MyThread2 extends Thread{
    
            private int ticket = 100;//一个窗口有100张票
            private String name; //窗口名, 也即是线程的名字
    
            public MyThread2(String name){
                this.name=name;
            }
    
            //在run方法里复写需要进行的操作:卖票速度是3s/张
            @Override
            public void run(){
                while (ticket>0){
                    ticket--;
                    System.out.println(name + "卖掉了1张票，剩余票数为:"+ticket);
    
                    try {
                        Thread.sleep(3000);//卖票速度是1s一张
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            //Button按下时会开启一个新线程执行卖票
            button = (Button) findViewById(R.id.button);
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
    
                    //步骤2:创建线程类的实例
                    //创建二个线程，模拟二个窗口卖票
                    MyThread1 mt1 = new MyThread1("窗口1");
                    MyThread2 mt2 = new MyThread2("窗口2");
    
                    //步骤3：调用start()方法开启线程
                    //启动二个线程，也即是窗口，开始卖票
                    mt1.start();
                    mt2.start();
    
                }
            });
    
        }
    }

*  测试结果  
    由于卖票速度不同，所以窗口1卖3张时，窗口2才卖1张。  
    ![Thread2.png][]
 *  Demo源码地址  
    [Carson\_Ho的Github地址：多线程之继承Thread类][Carson_Ho_Github_Thread]

至此，关于继承`Thread`类的多线程使用讲解完毕。

--------------------

# Part 2：实现Runnable接口 #

# 目录 #

![示意图][20e5d5351772fd61ad7b652930f16754.png]

--------------------

# 1. 简介 #

![示意图][b91d328d697ac346f86bf174b3e23009.png]

--------------------

# 2. 使用讲解 #

### 2.1 使用步骤 ###

![示意图][2fa9ac3be710fb25c479d4cabdf85af0.png]

特别注意：

*  `Java`中真正能创建新线程的只有`Thread`类对象
 *  通过实现`Runnable`的方式，**最终还是通过`Thread`类对象来创建线程**

> 所以对于 实现了`Runnable`接口的类，称为 **线程辅助类**；`Thread`类才是真正的线程类

### 2.2 具体使用 ###

// 步骤1：创建线程辅助类，实现Runnable接口
     class MyThread implements Runnable{
        ....
        @Override
    // 步骤2：复写run（），定义线程行为
        public void run(){
    
        }
    }
    
    // 步骤3：创建线程辅助对象，即 实例化 线程辅助类
      MyThread mt=new MyThread();
    
    // 步骤4：创建线程对象，即 实例化线程类；线程类 = Thread类；
    // 创建时通过Thread类的构造函数传入线程辅助类对象
    // 原因：Runnable接口并没有任何对线程的支持，我们必须创建线程类（Thread类）的实例，从Thread类的一个实例内部运行
      Thread td=new Thread(mt);
    
    // 步骤5：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起  / 停止
    // 当调用start（）方法时，线程对象会自动回调线程辅助类对象的run（），从而实现线程操作
      td.start();

### 2.3 简便使用：匿名类 ###

很多情况下，开发者会选择一种更加方便的方法去创建线程：**匿名类**

// 步骤1：通过匿名类 直接 创建线程辅助对象，即 实例化 线程辅助类
        Runnable mt = new Runnable() {
                        // 步骤2：复写run（），定义线程行为
                        @Override
                        public void run() {
                        }
                    };
    
                    // 步骤3：创建线程对象，即 实例化线程类；线程类 = Thread类；
                    Thread mt1 = new Thread(mt, "窗口1");
               
                    // 步骤4：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起  / 停止
                    mt1.start();

### 2.3 区别 ###

2种方法本质相同，但是各有优劣势 & 不同的应用场景：

> 大家可根据自己的需求场景来选择具体的使用方法

![示意图][d36d2236ba3fdb62745275fd88faf24c.png]

> 为了让大家理解更加深刻，下面例子我都会采用**方法1 = 常规方式** 来演示

--------------------

# 3. 实例应用 #

### 实例1 ###

*  应用场景：创建两个线程-实现两个相同的耗时任务
 *  实例说明：实现2个窗口同时卖火车票；每个窗口卖100张，卖票速度都是1s/张

> 建议先下载Demo再看分析：[Carson\_Ho的Github地址：多线程之继承Thread类][Carson_Ho_Github_Thread]

*  具体实现

*main\_activity.xml*

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context="com.example.carson_ho.demoforrunnable.MainActivity">
    
        //设置一个按钮用以启动线程
        <Button
            android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="点击开始卖票" />
    </RelativeLayout>

*MainActivity.java*

package com.example.carson_ho.demoforrunnable;
    
    import android.os.Bundle;
    import android.support.v7.app.AppCompatActivity;
    import android.view.View;
    import android.widget.Button;
    
    public class MainActivity extends AppCompatActivity {
    
    
        //主布局中定义了一个按钮用以启动线程
        Button button;
    
        //步骤1:创建线程类，实现Runnable接口
        private class MyThread1 implements Runnable{
    
            private int ticket = 100;//一个窗口有100张票
    
            //在run方法里复写需要进行的操作:卖票速度1s/张
            @Override
            public void run(){
                while (ticket>0){
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "卖掉了1张票，剩余票数为:"+ticket);
    
                    try {
                        Thread.sleep(1000);//卖票速度是1s一张
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            //Button按下时会开启一个新线程执行卖票
            button = (Button) findViewById(R.id.button);
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
    
                    //步骤2:创建线程类的实例
                    //创建二个线程，模拟二个窗口卖票
                    MyThread1 mt1 = new MyThread1();
                    MyThread1 mt2 = new MyThread1();
    
                    Thread mt11 = new Thread(mt1, "窗口1");
                    Thread mt22 = new Thread(mt2, "窗口2");
    
                    //步骤3：调用start()方法开启线程
                    //启动二个线程，也即是窗口，开始卖票
                    mt11.start();
                    mt22.start();
                }
            });
        }
    }

*  测试结果

![示意图][8c5e203a13fe2ada3344742f120afbfc.png]

*  Demo源码地址  
    [Carson\_Ho的Github地址：多线程之继承Thread类][Carson_Ho_Github_Thread]

--------------------

### 实例2 ###

> 建议先下载Demo再看分析：[Carson\_Ho的Github地址：多线程之继承Thread类][Carson_Ho_Github_Thread]

*  具体实现  
    *main\_activity.xml*

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context="com.example.carson_ho.demoforrunnable2.MainActivity">
    
    //设置按钮用以启动线程
        <Button
            android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="点击开始卖票" />
    </RelativeLayout>

*MainActivity.java*

package com.example.carson_ho.demoforrunnable2;
    
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    
    public class MainActivity extends AppCompatActivity {
    
        //主布局中定义了一个按钮用以启动线程
        Button button;
    
        //步骤1:创建线程类，实现Runnable接口
        //由于需要实现两个不同的操作:卖票速度1s/张和3s/张
        //所以需要创建两个线程类并实现Runnable接口
    
        //第一个线程类:实现卖票速度1s/张操作
        private class MyThread1 implements Runnable{
    
            private int ticket = 100;//一个窗口有100张票
    
            //在run方法里复写需要进行的操作:卖票速度1s/张
            @Override
            public void run(){
                while (ticket>0){
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "卖掉了1张票，剩余票数为:"+ticket);
    
                    try {
                        Thread.sleep(1000);//卖票速度是1s一张
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        //第二个线程类:实现卖票速度3s/张操作
        private class MyThread2 implements Runnable{
    
            private int ticket = 100;//一个窗口有100张票
    
            //在run方法里复写需要进行的操作:卖票速度3s/张
            @Override
            public void run(){
                while (ticket>0){
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "卖掉了1张票，剩余票数为:"+ticket);
    
                    try {
                        Thread.sleep(3000);//卖票速度是3s一张
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            //Button按下时会开启一个新线程执行卖票
            button = (Button) findViewById(R.id.button);
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
    
                    //步骤2:创建线程类的实例
                    //分别实例化两个线程子类
                    MyThread1 mt1 = new MyThread1();
                    MyThread2 mt2 = new MyThread2();
    
                    //创建二个线程，模拟二个窗口卖票
                    Thread mt11 = new Thread(mt1, "窗口1");//卖票速度1s/张
                    Thread mt22 = new Thread(mt2, "窗口2");//卖票速度3s/张
    
                    //步骤3：调用start()方法开启线程
                    //启动二个线程，也即是窗口，开始卖票
                    mt11.start();
                    mt22.start();
    
                }
            });
        }
    }

*  测试结果  
    由于卖票速度不同，所以窗口1卖3张时，窗口2才卖1张。  
    ![示意图][6ac9d31d5ea25ab1e91e4012c7b219d0.png]
 *  Demo源码地址  
    [Carson\_Ho的Github地址：多线程之继承Thread类][Carson_Ho_Github_Thread]

--------------------

### 实例3 ###

*  应用场景：创建两个线程-实现一个耗时任务
 *  实例说明：实现2个窗口同时卖火车票；两个窗口一共卖100张，卖票速度均为1s/张

> 建议先下载Demo再看分析：[Carson\_Ho的Github地址：多线程之继承Thread类][Carson_Ho_Github_Thread]

*  具体实现  
    *main\_activity.xml*

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context="com.example.carson_ho.demoforrunnable3.MainActivity">
    //设置按钮用以启动线程
        <Button
            android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="点击开始卖票" />
    </RelativeLayout>

*MainActivity.java*

package com.example.carson_ho.demoforrunnable3;
    
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    
    public class MainActivity extends AppCompatActivity {
    
        //主布局中定义了一个按钮用以启动线程
        Button button;
    
        //步骤1:创建线程类，实现Runnable接口
        private class MyThread1 implements Runnable{
    
            private int ticket = 100;//两个窗口一共要卖100张票
    
            //在run方法里复写需要进行的操作:卖票速度1s/张
            @Override
            public void run(){
                while (ticket>0){
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "卖掉了1张票，剩余票数为:"+ticket);
    
                    try {
                        Thread.sleep(1000);//卖票速度是1s一张
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            //Button按下时会开启一个新线程执行卖票
            button = (Button) findViewById(R.id.button);
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
    
                    //步骤2:创建线程类的实例
                    //因为是两个窗口共卖100张票,即共用资源
                    //所以只实例化一个实现了Runnable接口的类
                    MyThread1 mt = new MyThread1();
    
                    //因为要创建二个线程，模拟二个窗口卖票
                    Thread mt11 = new Thread(mt, "窗口1");
                    Thread mt12 = new Thread(mt, "窗口2");
    
                    //步骤3：调用start()方法开启线程
                    //启动二个线程，也即是窗口，开始卖票
                    mt11.start();
                    mt12.start();
    
                }
            });
        }
    }

*  测试结果  
    实现了两个窗口一起卖100张票的目的  
    ![结果][5f4a523e7afe6aa7983e6b16baa06e54.png]
 *  Demo源码地址  
    [Carson\_Ho的Github地址：多线程之继承Thread类][Carson_Ho_Github_Thread]

至此，关于实现`Runnable`接口的多线程使用讲解完毕。

--------------------

# Part 3：对比 #

*  继承 `Thread`类和实现`Runnable`接口是实现多线程最常用的2种方法
 *  二者对比如下：

![示意图][3f95707074ca0fc3bf552cceaefacb21.png]

--------------------

# 总结 #

*  本文主要对多线程中的基础用法：实现 `Runnable` & 继承`Thread`的用法进行了全面介绍
 *  **Carson带你学多线程系列**

> 基础汇总  
> [Android多线程：多线程基础知识汇总][Android]  
> 基础使用  
> [Android多线程：继承Thread类使用(含实例教程)][Android_Thread]  
> [Android多线程：实现Runnable接口使用(含实例教程)][Android_Thread]  
> 复合使用  
> [Android多线程：AsyncTask使用教程(含实例讲解)][Android_AsyncTask]  
> [Android多线程：AsyncTask的原理及源码分析][Android_AsyncTask 1]  
> [Android多线程：HandlerThread使用教程(含实例讲解)][Android_HandlerThread]  
> [Android多线程：HandlerThread的原理及源码分析][Android_HandlerThread 1]  
> [Android多线程：IntentService使用教程(含实例讲解)][Android_IntentService]  
> [Android多线程：IntentService的原理及源码分析][Android_IntentService 1]  
> [Android多线程：线程池ThreadPool全方位教学][Android_ThreadPool]  
> 相关使用  
> [Android异步通信：这是一份全面&详细的Handler机制学习攻略][Android_Handler]  
> [Android多线程：手把手教你全面学习神秘的Synchronized关键字][Android_Synchronized]  
> [Android多线程：带你了解神秘的线程变量 ThreadLocal][Android_ ThreadLocal]

--------------------

# 欢迎关注Carson\_Ho的[CSDN博客][CSDN] 与 公众号！ #

博客链接：https://carsonho.blog.csdn.net/  
![06b2ed0fbb8979f0aba34c14ede04b59.png][]

--------------------

# 请帮顶 / 评论点赞！因为你的鼓励是我写作的最大动力！ #

[a26aedafc2ac45510787091b1d02f019.png]: /images/20220523/cee8a56a7d604c98a14acf1e49a30425.png
[Android]: https://carsonho.blog.csdn.net/article/details/90166487
[Android_Thread]: https://carsonho.blog.csdn.net/article/details/80506008
[Android_AsyncTask]: https://carsonho.blog.csdn.net/article/details/79314325
[Android_AsyncTask 1]: https://carsonho.blog.csdn.net/article/details/79314326
[Android_HandlerThread]: https://carsonho.blog.csdn.net/article/details/79285760
[Android_HandlerThread 1]: https://carsonho.blog.csdn.net/article/details/52693418
[Android_IntentService]: https://carsonho.blog.csdn.net/article/details/90437126
[Android_IntentService 1]: https://carsonho.blog.csdn.net/article/details/53407806
[Android_ThreadPool]: https://carsonho.blog.csdn.net/article/details/80060201
[Android_Handler]: https://carsonho.blog.csdn.net/article/details/51290360
[Android_Synchronized]: https://blog.csdn.net/carson_ho/article/details/82992269?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163210663616780271522004%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=163210663616780271522004&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_v29-1-82992269.pc_v2_rank_blog_default&utm_term=Synchronized&spm=1018.2226.3001.4450
[Android_ ThreadLocal]: https://blog.csdn.net/carson_ho/article/details/82344011?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163210666516780261991412%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=163210666516780261991412&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_v29-1-82344011.pc_v2_rank_blog_default&utm_term=%E7%BA%BF%E7%A8%8B%E5%8F%98%E9%87%8F&spm=1018.2226.3001.4450
[880206460cf6d6bcbaf536cad9b24032.png]: /images/20220523/43abee2f5aa84f229e7fd1d2de765170.png
[0d6178edc4f37f4bd7b590c3879ea572.png]: /images/20220523/0870af9c000f488b95acbb52db7a0ab4.png
[322e3c75d95b15baa0c875245f8e5765.png]: /images/20220523/b8ce66738279483bb3eeac246d2c7895.png
[b1966898ef02c44679ac7e968bdbb452.png]: /images/20220523/6e226946b7a44f35893bd92910de9190.png
[Carson_Ho_Github_Thread]: https://github.com/Carson-Ho/MultiThread_learning
[d6b449f790971b0470f0885f5bbc19a4.png]: /images/20220523/82bc16dd9d824eb898ca5de5c18a7f95.png
[Demo for Thread example1]: https://github.com/Carson-Ho/DemoforThread
[Thread2.png]: /images/20220523/c001123f24d44dc0b2a446765e22f690.png
[20e5d5351772fd61ad7b652930f16754.png]: /images/20220523/b8877980cfc24725b4baaf58e5c922ae.png
[b91d328d697ac346f86bf174b3e23009.png]: /images/20220523/02c30b1de51a409c8efc714d98ff9036.png
[2fa9ac3be710fb25c479d4cabdf85af0.png]: /images/20220523/17bab3e98daf4d4eb49646d043011a84.png
[d36d2236ba3fdb62745275fd88faf24c.png]: /images/20220523/c28042878f434893a993546d373a541f.png
[8c5e203a13fe2ada3344742f120afbfc.png]: /images/20220523/2830270e16ae460ea5c59ad89bb4f39a.png
[6ac9d31d5ea25ab1e91e4012c7b219d0.png]: /images/20220523/fe61e938dd39481c98bc746fbf1cd696.png
[5f4a523e7afe6aa7983e6b16baa06e54.png]: /images/20220523/67eaaf60554f4da99c4fd06b94af4ca9.png
[3f95707074ca0fc3bf552cceaefacb21.png]: /images/20220523/1d8a38dfabaa47c1a54428e2b14543c6.png
[CSDN]: https://carsonho.blog.csdn.net/
[06b2ed0fbb8979f0aba34c14ede04b59.png]: /images/20220523/8621b60956f24c94892d0e21c451b5a4.png