android基础 [Thread，handler，handler Thread，intent service]

目录

1.Thread

2.handler

3.intent service

4.handler Thread

---

1.Thread

android有3中开启子线程的方式：继承Thread，实现Runnable接口以及两者结合。

1.1创建内部类继承Thread

注：此时进行了模拟耗时操作，程序未报错，但是“tv_hello.setText("你好世界")”未执行成功，因为子线程无法修改ui。

        class MyThread extends Thread{
            @Override
            public void run() {
                super.run();
                try {
                    sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                tv_hello.setText("你好世界");
            }
        }
        MyThread myThread=new MyThread();
        myThread.start();

1.2 创建内部类实现Runnable接口

注：大家可以发现使用这种方式没有start()方法来启动线程，需要创建一个Thread对象。故推荐第三种方式来创建线程。

        class MyRunnable implements Runnable{
            @Override
            public void run() {

            }
        }

        Thread thread=new Thread(new MyRunnable());
        thread.start();

 1.3两者结合

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

            }
        }).start();

2.handler

在使用子线程时我们发现在子线程中无法修改ui，此时就要用到handler（句柄）来连接主线程和子线程将子线程的消息发送给主线程，在主线程内修改ui。

private TextView tv_hello;

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

        tv_hello=findViewById(R.id.tv_hello);

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

                    Thread.sleep(3000);
                    String result="你好啊";

                    Message message=new Message();
                    message.what=1;
                    message.obj=result;
                    handler.sendMessage(message);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }

    private Handler handler=new Handler(Looper.getMainLooper()){
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            if (msg.what==1) {
                String r = (String) msg.obj;
                tv_hello.setText(r);
            }
        }
    };

3.intent service

IntentService是Service的一个子类，在使用service创建线程时我们发现Service 不会自动开启线程，也不会自动关闭线程，但是IntentService 会自动开启线程，自动关闭线程

3.1创建方式

①使用Android studio的方式创建

②创建一个普通的Java文件然后继承IntentService。注：此方式需要在androidmanifest.xml清单文件中注册。

3.2代码示例

模拟耗时操作，通过获取系统当前时间设置时间节点

public class MyIntentService extends IntentService {

    public MyIntentService() {
        super("MyIntentService");
    }

    /**
     * @param name
     * @deprecated
     */
    public MyIntentService(String name) {
        super(name);
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        Log.i("MyIntentService","服务开启");

        long endTime=System.currentTimeMillis()+5*1000;
        while (System.currentTimeMillis()<endTime){
            synchronized (this){
                try {
                    wait(endTime-System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i("MyIntentService","服务销毁");
    }

}

4.handler Thread

本质还是一个线程，带了Looper的线程，这样就不用使用系统自带的消息队列。

public class MainActivity extends AppCompatActivity {

    private TextView tv_show;
    private HandlerThread handlerThread;
    private Handler threadHandler;
    private Handler mHandler=new Handler();
    private boolean type;

    private String result="hopu:";

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

        tv_show=findViewById(R.id.tv_show);

        handlerThread=new HandlerThread("update_text");
        handlerThread.start();

        threadHandler=new Handler(handlerThread.getLooper()){
            @Override
            public void handleMessage(@NonNull Message msg) {
                super.handleMessage(msg);
                try {
                    Thread.sleep(2000);
                    result+=1;
                    Log.i("threadHandler","正在运行");
                    if (type)
                        threadHandler.sendEmptyMessage(0x111);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        tv_show.setText(result);
                    }
                });
            }
        };

    }

    @Override
    protected void onResume() {
        super.onResume();
        type=true;
        threadHandler.sendEmptyMessage(0x111);
    }

    @Override
    protected void onPause() {
        super.onPause();
        type=false;
        threadHandler.sendEmptyMessage(0x111);
        Log.i("threadHandler","已停止");
    }

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