Android多线程:继承Thread类 & 实现Runnable接口 使用解析(含实例教程)

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://carsonho.blog.csdn.net/article/details/80506008

前言

  • 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

<?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();

                }
            });

        }
    }


  • 测试结果

结果展示


实例2

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

建议先下载Demo再看分析: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();

            }
        });

    }
}


至此,关于继承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

<?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();
            }
        });
    }
}
  • 测试结果

示意图


实例2

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

建议先下载Demo再看分析: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();

            }
        });
    }
}

实例3

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

建议先下载Demo再看分析: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();

            }
        });
    }
}

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


Part 3:对比

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

示意图


总结

  • 本文主要对多线程中的基础用法:实现 Runnable & 继承Thread的用法进行了全面介绍
  • 接下来,我会继续讲解Android开发中关于多线程的知识,具体包括RunnableHandlerHandlerThread等等,感兴趣的同学可以继续关注carson_ho的微信公众号
    示意图
    示意图

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

展开阅读全文

没有更多推荐了,返回首页