Android Thread线程的简单使用

简述

在Android开发中，我们大多数在编写的都是顺序编程，然而对于某些问题由于机制或者优化，能够并行的执行程序中的某个部分则是更有效率甚至更方便。体现在Android 上的操作：网络请求，或者倒计等 在主线程做耗费时间长可能会导致主线程阻塞，当然后台服务功能或多或少也离不开它，比如建立心跳机制，直播APP当在看主播时切换到后台超过一定时间自动断开，而不是保持一直连接。由此引出了本次的主角多线程编程-Thread.

基本使用

1. 继承来自java.lang 包的 Thread ,重写其run 方法，调用start 开启线程

    class ThreadSimple1 extends Thread{
        @Override
        public void run() {
            super.run();
            //在此处编辑执行的逻辑代码
        }
    }

启动方式

new ThreadSimple1().start();

2.实现Thread 的其中一个构造函数，接收Runnable 参数

 class ThreadSimple2 implements Runnable{

        @Override
        public void run() {
            //在此处编辑执行的逻辑代码
        }
    }

2.1启动方式：

 ThreadSimple2 threadSimple2=new ThreadSimple2();
 new Thread(threadSimple2).start();

2.2启动方式 ：（匿名类的方式启动与2.1是同种思想，只是写法更加简便）

    new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();

简单案例（文末附上完整代码）

我们来简单实现一下计时器，每隔一秒计时一次，并显示到文本上，同时设置三个按钮，分别用来启动计时，停止计时，销毁线程
先来自定义一个TimeThread继承Thread，在线程上睡眠一秒后调用计时方法

     class TimeThread extends Thread {
       @Override
       public void run() {
           super.run();
           while (ifRunTime) {
               try {
                   sleep(1000);
                   if (isStart) timeCount();
                   Log.e("TimeThread", "线程存活：" + timeThread.isAlive());
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
   }

其中ifRunTime 是用来设置当我们不需要再使用该方法时退出的循环开关，isStart 是用来控制是否计时的标志。
接着看看我们的计时方法timeCount（）

    private synchronized void timeCount() {
        mSecond++;
        Log.e("timeCount", "调用次数：" + mSecond);
        Message message = Message.obtain();
        message.what = TIME_MESSAGE;
        timeHandler.sendMessage(message);

    }

synchronized用来实现同步，可以保证被修饰的函数在被其它函数调用时，如果其处于被调用中，那么其它所有要调用到该函数的线程都会被阻塞，直到其从调用的线程中返回，防止资源冲突（虽然在上诉的代码中没有很好体现，但是还是粗略讲解下作用）

mSecond是一个用来累计时间的常量，每隔一秒自增。

由于Android不允许子线程更新UI， 所以需要异步消息处理，这里的timeHandler，是继承了android.os包中的 Handler ,相关代码如下

    private  Handler timeHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case TIME_MESSAGE:
                    tv_time.setText("累计秒数：" + mSecond);
                    break;
            }
        }
    };

TIME_MESSAGE 是我定义的整型常量，在主线程创建的timeHandler 接收到来自其它线程的消息分发，此时可UI更新，将秒数设置到我们的控件上。

在初始化的时候我们就开启线程，虽然线程一直在运行，但是由于我默认暂停计时（isStart=false），所以计时器并未开始，直到我点击启动计时才开始计时，运行效果如下：

开启与暂停计时录屏.gif

计时功能看似成功了，但是却埋下了一个隐患，即当你销毁计时界面（可以理解为出栈）时，启动的子线程不会因此而销毁，由于其还持有显示时间的控件tv_time，导致GC不会回收，一直持有该引用，轻则卡顿，重则占满内存导致OOM，直接奔溃。
内存泄露的操作：来到计时界面后直接回退到上个界面（点击计时然后退出则多了一个持有tv_time的泄露）， 我们可以leakcanary看看
感兴趣的小伙伴可以接入依赖：

 debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.0'

这边直接给截图效果：

溢出截图.png

由于这边一直持有MainActivity（我这边计时器界面的类名称）中的线程无法回收，最终内存泄露了。

解决方法就是在界面的生命周期onDestroy中退出循环，即将ifRunTime赋值为false ,我这边则是为了出现内存泄露的情况没有设置，而是设置一个销毁按钮，在退出时点击销毁，此时则没有出现泄露情况，由此可知线程任务在退出其run()并死亡之前，垃圾回收器无法清除它。

这边我附上计时器界面的完整代码 MainActivity类

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private boolean ifRunTime = true;//是否启动线程--进来就默认启动
    private boolean isStart;//是否开始计时
    private TimeThread timeThread;
    private  TextView tv_time;
    private Button btn_start, btn_stop, btn_destroy;
    private static final int TIME_MESSAGE = 1001;
    private  long mSecond = 0;

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

        timeThread = new TimeThread();
        timeThread.start();
        initView();
    }


    private void initView() {
        tv_time = findViewById(R.id.tv_time);
        btn_start = findViewById(R.id.btn_start);
        btn_stop = findViewById(R.id.btn_stop);
        btn_destroy = findViewById(R.id.btn_destroy);
        btn_start.setOnClickListener(this);
        btn_stop.setOnClickListener(this);
        btn_destroy.setOnClickListener(this);
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.btn_start://开启计时
                isStart = true;

                break;

            case R.id.btn_stop://暂停
                isStart = false;
                break;

            case R.id.btn_destroy://销毁线程
                ifRunTime = false;
                break;

        }

    }


    class TimeThread extends Thread {
        @Override
        public void run() {
            super.run();
            while (ifRunTime) {
                try {
                    sleep(1000);
                    if (isStart) timeCount();
                    Log.e("TimeThread", "线程存活：" + timeThread.isAlive());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private synchronized void timeCount() {
        mSecond++;
        Log.e("timeCount", "调用次数：" + mSecond);
        Message message = Message.obtain();
        message.what = TIME_MESSAGE;
        timeHandler.sendMessage(message);

    }


    private  Handler timeHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case TIME_MESSAGE:
                    tv_time.setText("累计秒数：" + mSecond);
                    break;
            }
        }
    };


    @Override
    protected void onDestroy() {
        super.onDestroy();
    }
}

布局截图：

activity_main.png

至此，线程的简单使用到此结束，有不对的地方请各位小伙伴不吝指出。
在写此篇博客时查阅参考引用了大神Bruce Eckel 的《Java编程思想》，郭霖大佬著作《第一行代码》，想熟悉掌握并发编程的理论与基础，强力推荐《Java编程思想》