Android--线程

本篇分别从线程的生命周期、线程间通信、线程安全3部分内容学习下线程的使用。

线程生命周期

  • 新建状态（New）
    线程刚被创建，但尚未启动。例如，通过Thread t = new Thread();创建了一个线程对象，但尚未调用start()方法。

  • 就绪状态（Runnable）
    当调用线程对象的start()方法后，线程进入就绪状态，等待CPU调度执行。

  • 运行状态（Running）
    当线程获得CPU时间片后，进入运行状态，执行run()方法中的代码。

  • 阻塞状态（Blocked）
    当线程在获取锁或其他资源时被阻塞，会进入阻塞状态。一旦资源可用，线程会重新进入就绪状态。

  • 等待状态（Waiting）
    通过调用wait()、join()或LockSupport.park()等方法进入等待状态，等待其他线程的操作来唤醒。

  • 终止状态（Terminated）
    当run()方法执行完毕或因异常退出时，线程进入终止状态。

线程阻塞

线程的阻塞根据不同的造成原因又分为等待阻塞、同步阻塞和其他阻塞。

  1. 等待阻塞：调用了wait()方法。当调用了wait()方法时，会释放持有对象的锁，只有等待调用notify()/notifyAll()唤醒，才会重新去获取持有对象的锁。
  2. 同步阻塞：等待同步监视器，而该同步监视器正被其他线程所持有。
  3. 其他阻塞：如调用了sleep()/join()方法，或调用了阻塞式的IO方法等。当调用了sleep()方法时，不会释放持有对象的锁，直至sleep()结束才被释放。

线程间通信

通常进程的主线程用来处理页面更新等UI相关的操作，如网络请求等耗时操作会开子线程去执行，防止主线程阻塞导致页面卡住，给用户带来不好的体验，子线程执行获得的数据需要显示在UI上，所以需要线程间进行通信。

1. 异步消息处理机制

Android 中的异步消息处理主要由4部分组成：Message、Handler、MessageQueue 和Looper 。

  • Message
    Message 是在线程之间传递的消息，它可以在内部携带少量的信息，用于在不同线程之间传递数据。

  • Handler
    Handler主要是用于发送和处理消息，发送消息一般使用Handler 的sendMessage()方法、post()方法等，发出的消息经过一系列辗转处理，最终会传递到Handler 的handleMessage()方法中。

  • MessageQueue
    MessageQueue消息队列主要用于存放所有通过Handler 发送的消息，消息会一直存在于消息队列中等待被处理，每个线程中只有一个MessageQueue对象。

  • Looper
    Looper 是每个线程中的MessageQueue的管家，调用Looper 的loop()方法后会进入一个无限循环，每当发现MessageQueue 中存在一条消息就会将它取出传递到Handler 的handleMessage()方法中，每个线程中只有一个Looper对象。

异步消息处理流程：
① 在主线程创建Handler对象，重写handleMessage()方法，该方法做更新UI操作；
② 定义子线程执行耗时操作获取到结果数据，创建Message对象，将结果数据携带在Message对象中，通过主线程Handler对象的sendMessage方法将携带子线程数据的Message对象发给主线程；
③ Message传递到主线程中，在handleMessage中接收并处理数据，实现UI更新。

1.png

2. Thread的使用方法

  • 常规用法

定义一个线程需要新建一个实现Runnable接口的类，重写父类Thread中的run()方法来实现耗时操作即可。

class MyThread: Runnable{
    override fun run() {
        // 耗时操作（此处用以100个数字相加为例）
        var num = 0
        while (num < 100){
            num += 1
        }
        Log.d("cyclicAdd", "num = $num ")
    }
}

启动线程是在需要执行耗时操作的地方创建MyThread实例，调用start()方法启动线程，线程中的耗时操作就会开始执行

        val myThread = MyThread()
        Thread(myThread).start()
  • 简单用法

可以不用专门创建类定义线程，可以直接使用Lambda方式定义一个子线程

        Thread{
            // 耗时操作（此处用以100个数字相加为例）
            var num = 100
            while (num < 200){
                num += 1
            }
            Log.d("cyclicAdd", "num = $num ")
        }.start()

or

        thread{
            // 耗时操作（此处用以100个数字相加为例）
            var num = 100
            while (num < 200){
                num += 1
            }
            Log.d("cyclicAdd", "num = $num ")
        }
    }
  • 子线程获取数据，主线程更新UI

做一个逻辑简单的练习，效果是点击按钮更新TextView的text内容，子线程获取到text内容，send至主线程更新UI。
注意：页面销毁时要释放handler资源。

class MainActivity : AppCompatActivity() {

    var handler : Handler? = null
    val update = 1

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        initView()
        initThread()
    }

    private fun initView(){

        btn.setOnClickListener{
            thread {
                // 执行耗时操作将获取的数据通过arg或obj携带给其他线程
                val msg = Message()
                msg.what = update
                msg.obj = "Nice to meet you!"
                handler?.sendMessage(msg)
            }
        }

    }

    private fun initThread(){

        handler = object : Handler(Looper.getMainLooper()){
            override fun handleMessage(msg: Message) {
                super.handleMessage(msg)
                when(msg.what){
                    update ->
                        textview.text = msg.obj.toString()
                }
            }
        }

    }

    override fun onDestroy() {
        super.onDestroy()
        // 释放handler资源
        handler?.removeCallbacksAndMessages(null)
        handler = null
    }

}

3. AsyncTask工具实现异步消息处理

AsyncTask是一个抽象类，必须创建子类继承并重写AsyncTask的4个方法执行task：

  • onPreExecute()
    这个方法会在后台任务开始执行之前调用，用于进行一些界面上的初始化操作。

  • doInBackground(Params...)
    这个方法中的所有代码都会在子线程中运行，在这里去处理所有的耗时任务，可以通过return语句将任务的执行结果返回。

  • onProgressUpdate(Progress...)
    当在后台任务中调用了publishProgress（Progress...）方法后，onProgressUpdate （Progress...）方法就会很快被调用，该方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行更新。

  • onPostExecute (Result)
    当后台任务执行完毕并通过return语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数传递到此方法中，可以利用返回的数据进行UI操作。

class DownloadTask(context: Context) : AsyncTask<Unit, Int, Boolean>() {

    private var num = 0

    @SuppressLint("StaticFieldLeak")
    val mContext = context

    override fun onPreExecute() {
        super.onPreExecute()
        Toast.makeText(mContext, "UI初始化操作", Toast.LENGTH_SHORT).show()
    }

    override fun doInBackground(vararg params: Unit?) = try{
        // 子线程执行耗时操作
        while(true){
            val downloadPercent = doDownload()
            publishProgress(downloadPercent)
            if (downloadPercent >= 10){
                break
            }
        }
        true
    }catch (e: Exception){
        false
    }

    override fun onProgressUpdate(vararg values: Int?) {
        super.onProgressUpdate(*values)
        Toast.makeText(mContext, "下载进度 = ${values[0].toString()}", Toast.LENGTH_SHORT).show()

    }

    override fun onPostExecute(result: Boolean?) {
        super.onPostExecute(result)
        Toast.makeText(mContext, "下载结果：${result.toString()}", Toast.LENGTH_SHORT).show()
        num = 0
    }

    private fun doDownload() : Int{
        return ++num
    }

}

MainActivity.kt使用：

    private fun initView(){
        btn.setOnClickListener{
            downloadTask = DownloadTask(this)
            downloadTask.execute()
        }
    }

4. HandlerThread线程的使用

<MainActivity.java>

public class MainActivity extends AppCompatActivity {

    private final String TAG = "MainActivity";
    private int num = 0;
    private Handler work;
    private Handler ui;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        initHandlerThread();
    }

    private void initHandlerThread(){
        // 创建Handler Thread对象
        HandlerThread thread = new HandlerThread("test");
        thread.start();
        Log.d(TAG, "test Thread id = " + thread.getThreadId());

        // 创建线程的handler，用于子线程和主线程进行通信
        Handler work = new Handler(thread.getLooper(), new Handler.Callback() {
            @Override
            public boolean handleMessage(@NonNull Message msg) {
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                num++;
                Log.d(TAG, "work Thread num = " + num);
                Message message = new Message();
                message.what = num;
                // 子线程数据传给主线程
                ui.sendMessage(message);
                return false;
            }
        });

        ui = new Handler(Looper.getMainLooper()){
            @Override
            public void handleMessage(@NonNull Message msg) {
                super.handleMessage(msg);
                Log.d(TAG, "ui Thread num = " + msg.what);
                if (msg.what < 10){
                    // 更新UI条件不满足，子线程继续工作
                    work.sendEmptyMessage(msg.what);
                }
            }
        };

        // 触发子线程开始工作
        work.sendEmptyMessage(num);
    }
}

线程安全

由于多线程之间是同时并发执行的，线程之间的调度又是无序的，会出现类似多个线程同时修改同一个变量的情况，这样线程就是不安全的。

  • 线程不安全示例

这里以倒计时为例，先写好线程要执行的操作，然后在主Activity中运行。

<MyRunnable.java>

public class MyRunnable implements Runnable{

    private final String TAG = "MyRunnable";
    private int num = 10;

    @Override
    public void run() {
        while (num > 0) {
            Log.d(TAG, "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                Log.d(TAG, "ERROR = " + e);
            }
            num--;
        }
    }

}

<MainActivity.java>

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        initThread();
    }

    private void initThread(){
        MyRunnable myRunnable = new MyRunnable();
        new Thread(myRunnable).start();
        new Thread(myRunnable).start();
    }
}

【图片】

根据结果可以看出，倒计时会出现重复的情况，此时线程是不安全的。

  • 线程安全

为了在多线程环境中对共享资源的访问时互斥的，可以通过加锁来确保线程安全。

  1. 内置锁 synchronized

synchronized关键字锁是隐式锁，在JVM层实现，线程执行了synchronized 的代码块就自动上了锁，只有线程执行完或线程发生异常时才会释放锁，如果线程中需要等待（IO操作或sleep()），synchronized 不能主动释放锁，会导致资源浪费。

下面代码中synchronized内置锁是对MyRunnable的实例对象起作用的，当一个线程正在执行该实例对象的方法时，另一个线程的执行会变成0，不进入循环内。

<MyRunnable.java>

    @Override
    public void run() {
        // 锁MyRunnable类的对象
        synchronized (this) {
            while (num > 0) {
                Log.d(TAG, "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    Log.d(TAG, "ERROR = " + e);
                }
                num--;
            }
        }
    }

or

    @Override
    public void run() {
        test();
    }

    // synchronized 修饰方法
    private synchronized void test(){
        while (num > 0) {
            Log.d(TAG, "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                Log.d(TAG, "ERROR = " + e);
            }
            num--;
        }
    }

【图片】

但是如果创建两个MyRunnable的实例，synchronized就不起作用了，该锁只针对单一的实例对象，无法作用与实例对象和实例对象之间。

    private void initThread(){
        new Thread(new MyRunnable()).start();
        new Thread(new MyRunnable()).start();
    }

【图片】

如果把synchronized (this)改为synchronized (MyRunnable.class)的话，就是给MyRunnable类加锁，而不是该类的实例，这样线程就是同步的，一个线程执行完之后另一个线程再执行，由于实例中有两个MyRunnables实例，所以会执行两次倒计时。

    @Override
    public void run() {
        // 增加锁
        synchronized (MyRunnable.class) {
            while (num > 0) {
                Log.d(TAG, "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    Log.d(TAG, "ERROR = " + e);
                }
                num--;
            }
        }
    }

【图片】

synchronized修饰静态方法不仅同一个MyRunnable实例对讲会线程同步，不同的实例也会线程同步，两个不同的实例最终只执行一次倒计时。

    @Override
    public void run() {
        test();
    }

    // synchronized 修饰静态方法
    private synchronized static void test(){
        while (num > 0) {
            Log.d(TAG, "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                Log.d(TAG, "ERROR = " + e);
            }
            num--;
        }
    }
  1. 重入锁 lock

重入锁lock可以通过ReentrantLock类来实现，ReentrantLock是一种可重入锁，比synchronized更灵活，提供了管理锁的方法，可以主动获取和释放锁。

当同一个MyRunnable对象在不同线程中执行时，加同步锁lock可以实现资源访问互斥。

<Main.java>

    private void initThread(){
        MyRunnable myRunnable = new MyRunnable();
        new Thread(myRunnable).start();
        new Thread(myRunnable).start();
    }

<MyRunnable.java>

public class MyRunnable implements Runnable{

    private int num = 10;
    // 创建锁对象
    private final Lock lock = new ReentrantLock();

    @Override
    public void run() {
        // 得到锁
        lock.lock();
        try{
            while (num > 0) {
                Log.d("====", "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    Log.d("===", "ERROR = " + e);
                }
                num--;
            }
        }finally {
            // 释放锁
            lock.unlock();
        }
    }

}

当两个线程中创建的是不同的两个实例时，每个MyRunnable实例都创建了自己独立的lock锁对象，每个线程使用的不同的锁对象，无法实现限制多线程同时执行的效果，因此需要将锁对象定义为共享的，让所有MyRunnable实例共享一个锁对象。

<Main.java>

    private void initThread(){
        new Thread(new MyRunnable()).start();
        new Thread(new MyRunnable()).start();
    }

<MyRunnable.java>

public class MyRunnable implements Runnable{

    private int num = 10;
    // 将锁对象定义为静态的，使其成为共享锁
    private static final Lock lock = new ReentrantLock();

    @Override
    public void run() {
        // 得到锁
        lock.lock();
        try{
            while (num > 0) {
                Log.d("====", "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    Log.d("===", "ERROR = " + e);
                }
                num--;
            }
        }finally {
            // 释放锁
            lock.unlock();
        }
    }
}
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容