异步AsyncTask，怎样停止AsyncTask和Thread

我们要知道在java的线程中，没有办法停止一个正在运行中的线程。在Android的AsyncTask中也是一样的。如果必须要停止一个线程，我们可以采用这个线程中设置一个标志位，然后在线程run方法或AsyncTask的doInBackground方法中的关键步骤判断这个标志位以决定是否继续执行。然后在需要终止此线程的地方改变这个标志位以达到停止线程的目的。

              从外部调用AsyncTask的cancel方法并不能停止一个已经启动的AsyncTask。这个cancel方法的作用与线程的interrupt方法相似，调用了一个线程的interrupt方法之后线程仍然运行，但是如果该线程的run方法里面调用过sleep的或者wait方法后，处于sleep或wait状态，则sleep和wait立即结束并且抛出InterruptedException异常。AsyncTask的cancel方法也一样，如果在这个Task的doInBackground方法中调用了sleep或wait方法，当在UI线程中调用了这个Task实例的cancel方法之后，sleep或wait立即结束并且抛出InterruptedException异常，但是如果捕获该异常的代码后面还有其他代码，则这些代码还会继续执行。测试代码如下：

Java代码：

1. package eoe.task;
   
2. 
   
3. import android.app.Activity;
   
4. import android.os.AsyncTask;
   
5. import android.os.Bundle;
   
6. import android.util.Log;
   
7. import android.view.View;
   
8. import android.view.View.OnClickListener;
   
9. import android.widget.Button;
   
10. 
    
11. public class AsyncTaskTest extends Activity {
    
12. /** Called when the activity is first created. */
    
13. 
    
14. 
    
15. @Override
    
16. public void onCreate(Bundle savedInstanceState) {
    
17. super.onCreate(savedInstanceState);
    
18. setContentView(R.layout.main);
    
19. //set the six buttons listener
    
20. Button startButton=(Button) this.findViewById(R.id.StartTask);
    
21. final TestAsyncTask task=new TestAsyncTask(0);
    
22. startButton.setOnClickListener(new OnClickListener() {
    
23. public void onClick(View v) {
    
24. task.execute("str1","str2");
    
25. }
    
26. });
    
27. Button endButton=(Button) this.findViewById(R.id.StopTask);
    
28. endButton.setOnClickListener(new OnClickListener() {
    
29. public void onClick(View v) {
    
30. task.cancel(false);
    
31. }
    
32. });
    
33. 
    
34. 
    
35. Button startSleepButton=(Button) this.findViewById(R.id.StartThread_sleep);
    
36. final ThreadForTestSleep threadForTestSleep=new ThreadForTestSleep();
    
37. startSleepButton.setOnClickListener(new OnClickListener() {
    
38. public void onClick(View v) {
    
39. threadForTestSleep.start();
    
40. }
    
41. });
    
42. 
    
43. 
    
44. Button endSleepButton=(Button) this.findViewById(R.id.StopThread_sleep);
    
45. endSleepButton.setOnClickListener(new OnClickListener() {
    
46. public void onClick(View v) {
    
47. threadForTestSleep.interrupt();
    
48. }
    
49. });
    
50. 
    
51. 
    
52. Button startWaitButton=(Button) this.findViewById(R.id.StartThread_wait);
    
53. final ThreadForTestWait threadForTestWait=new ThreadForTestWait();
    
54. startWaitButton.setOnClickListener(new OnClickListener() {
    
55. public void onClick(View v) {
    
56. threadForTestWait.start();
    
57. }
    
58. });
    
59. 
    
60. 
    
61. Button endWaitButton=(Button) this.findViewById(R.id.StopThread_wait);
    
62. endWaitButton.setOnClickListener(new OnClickListener() {
    
63. public void onClick(View v) {
    
64. threadForTestWait.interrupt();
    
65. }
    
66. });
    
67. }
    
68. /**
    
69. * AsyncTask
    
70. * @author alex
    
71. *
    
72. */
    
73. private class TestAsyncTask extends AsyncTask<String, Integer, Double>{
    
74. double a;
    
75. 
    
76. public TestAsyncTask(double a){
    
77. this.a=a;
    
78. }
    
79. 
    
80. 
    
81. @Override
    
82. protected Double doInBackground(String... params) {
    
83. for(String param:params){
    
84. Log.i("TestAsyncTask","param:"+param );
    
85. }
    
86. Log.i("TestAsyncTask", "doInBackground is start");
    
87. for(int i=0;i<10000000;i++){
    
88. a=i*i+i;
    
89. Log.d("-----", "a:"+a);
    
90. }
    
91. Log.i("TestAsyncTask", "sleep 1 is end");
    
92. try {
    
93. Thread.sleep(30000);
    
94. } catch (InterruptedException e) {
    
95. // TODO Auto-generated catch block
    
96. e.printStackTrace();
    
97. }
    
98. Log.i("TestAsyncTask", "sleep 2 is end and continue execute");
    
99. return a;
    
100. }
     
101. 
     
102. 
     
103. protected void onPostExecute(Double result){
     
104. Log.i("last a value is", ""+result);
     
105. }
     
106. }
     
107. 
     
108. /**
     
109. * test sleep
     
110. * @author Administrator
     
111. *
     
112. */
     
113. private class ThreadForTestSleep extends Thread{
     
114. public void run(){
     
115. Log.i("ThreadForTestWait", "sleep start");
     
116. try {
     
117. sleep(30000);
     
118. } catch (InterruptedException e) {
     
119. // TODO Auto-generated catch block
     
120. e.printStackTrace();
     
121. }
     
122. double a;
     
123. for(int i=0;i<10000000;i++){
     
124. a=i*i+i;
     
125. Log.d("-----", "a:"+a);
     
126. }
     
127. Log.i("ThreadForTestWait", "sleep end");
     
128. }
     
129. }
     
130. 
     
131. 
     
132. /**
     
133. * test wait
     
134. * @author Administrator
     
135. *
     
136. */
     
137. private class ThreadForTestWait extends Thread{
     
138. public void run(){
     
139. Log.i("ThreadForTestWait", "wait start");
     
140. try {
     
141. synchronized(this){
     
142. wait();
     
143. }
     
144. } catch (InterruptedException e) {
     
145. // TODO Auto-generated catch block
     
146. e.printStackTrace();
     
147. }
     
148. Log.i("ThreadForTestWait", "wait end");
     
149. }
     
150. }
     
151. }

复制代码

                 我们来看看这个例子怎么样，这里主要用到了view.View.OnClickListener;监听，android.widget.Button按钮，我们定义一个Button是开始，一个Button定义为停止。这样我们就可以给按钮加上一个监听，在监听里定义当点击按钮时，就可以停止AsyncTask和Thread，这个方法我个人感觉非常的好。这个主要是加了一个sleep(30000);这样的话，我们就有时间来判断一下是否应该怎么样做