Android多线程：继承Thread类 & 实现Runnable接口 使用解析（含实例教程）
前言
- 在
Android开发中，多线程的使用十分常见 - 今天，我将全面解析多线程中最常见的2种用法：继承
Thread类 & 实现Runnable接口
含丰富的实例讲解，切记不能错过。
Part 1：继承Thread类
目录
1. 简介
2. 使用讲解
2.1 使用步骤
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种方法本质相同，但是各有优劣势 & 不同的应用场景：
大家可根据自己的需求场景来选择具体的使用方法
为了让大家理解更加深刻，下面例子我都会采用方法1 = 常规方式 来演示
3. 实例应用
实例1
- 应用场景：创建两个线程-实现两个相同的耗时任务
- 实例说明：实现2个窗口同时卖火车票；每个窗口卖100张，卖票速度都是1s/张
建议先下载Demo再看分析：Carson_Ho的Github地址：多线程之继承Thread类
- 具体实现
main_activity.xml
//设置一个按钮用以启动卖票
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();
}
});
}
}
- 测试结果
- Demo源码地址
Demo for Thread example1
实例2
- 应用场景：创建两个线程-实现两个不同的耗时任务
- 实例说明：实现2个窗口同时卖火车票；每个窗口卖100张，但卖票速度不同：窗口1是1s/张，窗口2是3s/张
建议先下载Demo再看分析：Carson_Ho的Github地址：多线程之继承Thread类
- 具体实现
main_activity.xml
//设置一个按钮以启动卖票
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张。
-
Demo源码地址
Carson_Ho的Github地址：多线程之继承Thread类
至此，关于继承Thread类的多线程使用讲解完毕。
Part 2：实现Runnable接口
目录
1. 简介
2. 使用讲解
2.1 使用步骤
特别注意：
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种方法本质相同，但是各有优劣势 & 不同的应用场景：
大家可根据自己的需求场景来选择具体的使用方法
为了让大家理解更加深刻，下面例子我都会采用方法1 = 常规方式 来演示
3. 实例应用
实例1
- 应用场景：创建两个线程-实现两个相同的耗时任务
- 实例说明：实现2个窗口同时卖火车票；每个窗口卖100张，卖票速度都是1s/张
建议先下载Demo再看分析：Carson_Ho的Github地址：多线程之继承Thread类
- 具体实现
main_activity.xml
//设置一个按钮用以启动线程
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();
}
});
}
}
- 测试结果
- Demo源码地址
Carson_Ho的Github地址：多线程之继承Thread类
实例2
- 应用场景：创建两个线程-实现两个不同的耗时任务
- 实例说明：实现2个窗口同时卖火车票；每个窗口卖100张，但卖票速度不同：窗口1是1s/张，窗口2是3s/张
建议先下载Demo再看分析：Carson_Ho的Github地址：多线程之继承Thread类
- 具体实现
main_activity.xml
//设置按钮用以启动线程
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张。
-
Demo源码地址
Carson_Ho的Github地址：多线程之继承Thread类
实例3
- 应用场景：创建两个线程-实现一个耗时任务
- 实例说明：实现2个窗口同时卖火车票；两个窗口一共卖100张，卖票速度均为1s/张
建议先下载Demo再看分析：Carson_Ho的Github地址：多线程之继承Thread类
- 具体实现
main_activity.xml
//设置按钮用以启动线程
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张票的目的
-
Demo源码地址
Carson_Ho的Github地址：多线程之继承Thread类
至此，关于实现Runnable接口的多线程使用讲解完毕。
Part 3：对比
- 继承
Thread类和实现Runnable接口是实现多线程最常用的2种方法 - 二者对比如下：
总结
- 本文主要对多线程中的基础用法：实现
Runnable& 继承Thread的用法进行了全面介绍 - 接下来，我会继续讲解
Android开发中关于多线程的知识，具体包括Runnable、Handler、HandlerThread等等，感兴趣的同学可以继续关注carson_ho的微信公众号
