Android使用Thread的interrupt与sleep，重启或暂停线程任务

android使用thread的interrupt与sleep，重启或暂停线程任务

本文给出一个例子，简单说明如何在android诸如activity中，重启或者暂停一个正在无限运作的线程。
需求描述：假设在android的activity中，有一个线程，永不停息的运作，若当前activity处于用户可见状态时候，每隔一秒输出一个自增长的计数器值，但是当activity处于用户不可见时候，暂停线程输出，即中断线程执行。
实现这一机制的关键点简言之，借助thread的sleep，让sleep在一定条件下（比如一个状态机布尔值）休眠一个极大值long.max_value。然后在android的activity生命周期回调中，重新赋值状态机布尔值，同时使用thread的interrupt方法，打断当前处于休眠状态的线程，使之重新恢复正常运转。
代码如下：

1. packagezhangphil.thread;
2.  
3. importandroid.support.v7.app.appcompatactivity;
4. importandroid.os.bundle;
5. importandroid.util.log;
6.  
7. publicclassmainactivityextendsappcompatactivity{
8. privatestringtag=“输出”;
9. privateintcount=0;
10. privatebooleanrun=true;
11.  
12. privatelongtimeworkmthread=newlongtimework();
13.  
14. @override
15. protectedvoidoncreate(bundlesavedinstancestate){
16. super.oncreate(savedinstancestate);
17.  
18. mthread.start();
19. }
20.  
21. privateclasslongtimeworkextendsthread{
22. @override
23. publicvoidrun(){
24. while(true){
25. try{
26. if(!run){
27. thread.sleep(long.max_value);
28. }
29. }catch(exceptione){
30. e.printstacktrace();
31. }
32.  
33. count++;
34. log.d(tag,count+”“);
35.  
36. try{
37. thread.sleep(1000);
38. }catch(interruptedexceptione){
39. e.printstacktrace();
40. }
41. }
42. }
43. }
44.  
45. @override
46. protectedvoidonresume(){
47. super.onresume();
48.  
49. run=true;
50. mthread.interrupt();
51. }
52.  
53. @override
54. protectedvoidonpause(){
55. super.onpause();
56.  
57. run=false;
58. }
59. }

    package zhangphil.thread;
    
    import android.support.v7.app.appcompatactivity;
    import android.os.bundle;
    import android.util.log;
    
    public class mainactivity extends appcompatactivity {
        private string tag = "输出";
        private int count = 0;
        private boolean run = true;
    
        private longtimework mthread = new longtimework();
    
        @override
        protected void oncreate(bundle savedinstancestate) {
            super.oncreate(savedinstancestate);
    
            mthread.start();
        }
    
        private class longtimework extends thread {
            @override
            public void run() {
                while (true) {
                    try {
                        if (!run) {
                            thread.sleep(long.max_value);
                        }
                    } catch (exception e) {
                        e.printstacktrace();
                    }
    
                    count++;
                    log.d(tag, count + "");
    
                    try {
                        thread.sleep(1000);
                    } catch (interruptedexception e) {
                        e.printstacktrace();
                    }
                }
            }
        }
    
        @override
        protected void onresume() {
            super.onresume();
    
            run = true;
            mthread.interrupt();
        }
    
        @override
        protected void onpause() {
            super.onpause();
    
            run = false;
        }
    }