Thread handler句柄 IntentServvice handlerThread

Thread

• 进程是系统分配资源的最小单位，线程是系统调度的最小单位。一个进程内的线程之间是可以共享资源的。每个进程至少有一个线程存在，即主线程。

android三种方式开启子线程

继承Thread

        class MyThead extends Thread{
            @Override
            public void run() {
                super.run();
                Log.i("接收", "收到: ");
            }
        }
        MyThead myThead = new MyThead();
        myThead.start();

实现Runnable接口

        //实现接口创建子线程
        class MyRunnable implements Runnable{

            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                    Log.i("MyRunnable","子线程二");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }}
        }
        MyRunnable myRunnable=new MyRunnable();
        Thread thread=new Thread(myRunnable);
        thread.start();

Thread和Runnable结合

        //结合使用线程三
        new Thread(new Runnable() {
            @Override
            public void run() {
                //耗时任务
                try {
                    Thread.sleep(3000);
                    Log.i("结合线程","子线程三");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

子线程是用来进行 耗时操作的

Handler

handler概念

• handler是一套 Android 消息传递机制,主要用于线程间通信。
• 用最简单的话描述： handler其实就是主线程在起了一个子线程，子线程运行并生成Message，Looper获取message并传递给Handler，Handler逐个获取子线程中的Message.
• Binder/Socket用于进程间通信，而Handler消息机制用于同进程的线程间通信
• 可以说只要有异步线程与主线程通信的地方就一定会有 Handler。
• 使用Handler消息传递机制主要是为了多个线程并发更新UI的同时，保证线程安全

 

 handler基本使用

     new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                    String resule="999";
                    Message message=new Message();
                    message.what=1;
                    message.obj=resule;
                    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 obj = (String) msg.obj;
                    tv_1.setText(obj);
                }
            }
        };

在子线程中发送消息到handler，然后在handler接收消息，并获取what为1的值并把他set给文本框

    private ProgressBar pb_1;
    int state;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main3);
        pb_1=findViewById(R.id.pb_1);
         new Thread(new Runnable() {
             @Override
             public void run() {
                while (state<100){
                    try {
                        Thread.sleep(1000);
                        state+=1;
                        handler.sendEmptyMessage(0x111);
                    } 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==0x111){
                  pb_1.setProgress(state);
              }
          }
      };

这个是把state值变成全局变量，然后通过不断增加的state控制进度条的增长，上面不断增加，一直循环到100;

IntentServvice

IntentService是Service的一个子类

创建IntentService的两种方式

第一种

创建Service继承IntentService接口

• 实现两个抽象方法 
• 创建无参构造方法
• 在AndroidManifest.xml开入口

        <service
            android:name=".MyIntentService"
            android:exported="true" />

第二种

直接创建IntentService

• 删除所有内容
• 实现两个接口
• 创建无参构造函数

Service开启线程

    Button btn_open_service;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //通过id获取控件
        btn_open_service = findViewById(R.id.btn_open_service);
        //给按钮设置监听
        btn_open_service.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent=new Intent(MainActivity.this,MyIntentService.class);
                startService(intent);
            }
        });
    }

public class MyService extends Service {
    public MyService() {
    }

    @Override
    public void onCreate() {
        Log.i("服务已创建", "创建了: ");
        super.onCreate();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("服务已创建", "开启了: ");
        new Thread(new Runnable() {
            @Override
            public void run() {
                //当前时间加上20秒
                long endtime = System.currentTimeMillis() + 20 * 1000;
                while (System.currentTimeMillis()<endtime){
                    synchronized (this){
                        try {
                            wait(endtime-System.currentTimeMillis());

                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                stopSelf();
            }
        }).start();
        return super.onStartCommand(intent, flags, startId);
    }

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

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }
}

IntentServvice开启线程

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("IntentService","IntentService开启");
        long endtime = System.currentTimeMillis() + 20 * 1000;
        while (System.currentTimeMillis()<endtime){
            synchronized (this){
                try {
                    wait(endtime-System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

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

Service和IntentServvice的区别

Service 不会自动开启线程，也不会自动关闭线程

IntentService 自动开启线程，自动关闭线程

HandlerThread

handlerThread还是一个线程，带了Looper的线程

public class MainActivity3 extends AppCompatActivity {
    TextView tv_show2;
    //线程
    private HandlerThread handlerThread;
    //子线程的句柄
    private  Handler handler=new Handler();
    //主线程的句柄
    private Handler mHandler=new Handler();
    boolean isRun =true;
    private String result="777";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main3);
        //根据id获取控件
        tv_show2  = findViewById(R.id.tv_show2);
        //创建handlerThread并给他起名字
        handlerThread=new HandlerThread("check_massage");
        handlerThread.start();

        handler=new Handler(handlerThread.getLooper()){
            @Override
            public void handleMessage(@NonNull Message msg) {
                super.handleMessage(msg);

                try {
                    Thread.sleep(2000);
                    result=result+1;
                    if (isRun)
                    handler.sendEmptyMessage(0x111);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        tv_show2.setText(result);
                    }
                });
            }
        };
    }

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

    @Override
    protected void onPause() {
        super.onPause();
        isRun=false;
    }

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