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

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

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

[java] view plain copy

print ?

1. package zhangphil.thread;  
2.   
3. import android.support.v7.app.AppCompatActivity;  
4. import android.os.Bundle;  
5. import android.util.Log;  
6.   
7. public class MainActivity extends AppCompatActivity {  
8.     private String TAG = “输出”;  
9.     private int count = 0;  
10.     private boolean RUN = true;  
11.   
12.     private LongTimeWork mThread = new LongTimeWork();  
13.   
14.     @Override  
15.     protected void onCreate(Bundle savedInstanceState) {  
16.         super.onCreate(savedInstanceState);  
17.   
18.         mThread.start();  
19.     }  
20.   
21.     private class LongTimeWork extends Thread {  
22.         @Override  
23.         public void run() {  
24.             while (true) {  
25.                 try {  
26.                     if (!RUN) {  
27.                         Thread.sleep(Long.MAX_VALUE);  
28.                     }  
29.                 } catch (Exception e) {  
30.                     e.printStackTrace();  
31.                 }  
32.   
33.                 count++;  
34.                 Log.d(TAG, count + ”“);  
35.   
36.                 try {  
37.                     Thread.sleep(1000);  
38.                 } catch (InterruptedException e) {  
39.                     e.printStackTrace();  
40.                 }  
41.             }  
42.         }  
43.     }  
44.   
45.     @Override  
46.     protected void onResume() {  
47.         super.onResume();  
48.   
49.         RUN = true;  
50.         mThread.interrupt();  
51.     }  
52.   
53.     @Override  
54.     protected void onPause() {  
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;
    }
}

转自:http://blog.csdn.net/zhangphil/article/details/78584136