1. Thread 类与Runnable接口：
线程的起动并不是简单的调用了你的RUN方法,而是由一个线程调度器来分别调用你的所有线程的RUN方法,
我们普通的RUN方法如果没有执行完是不会返回的,也就是会一直执行下去,这样RUN方法下面的方法就不可能会执行了,可是线程里的RUN方法却不一样,它只有一定的CPU时间,执行过后就给别的线程了,这样反复的把CPU的时间切来切去,因为切换的速度很快,所以我们就感觉是很多线程在同时运行一样.
你简单的调用run方法是没有这样效果的,所以你必须调用Thread类的start方法来启动你的线程.所以你启动线程有两种方法
一是写一个类继承自Thread类,然后重写里面的run方法,用start方法启动线程
二是写一个类实现Runnable接口,实现里面的run方法,用new Thread(Runnable target).start()方法来启动
这两种方法都必须实现RUN方法,这样线程起动的时候,线程管理器好去调用你的RUN方法.
你的TestThread没有继承自Thread类,怎么可能会有start方法呢?
在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；
Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的
run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限，
下面看例子：
package org.thread.demo;
class MyThread extends Thread{
private String name;
public MyThread(String name) {
super();
this.name = name;
}
public void run(){
for(int i=0;i<10;i++){
System.out.println("线程开始："+this.name+",i="+i);
}
}
}
package org.thread.demo;
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread("线程a");
MyThread mt2=new MyThread("线程b");
// thread1，thread2，按顺序进行
mt1.run();
mt2.run();
}
}
但是，此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在JDK的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。下面启动
start()方法启动线程：
package org.thread.demo;
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread("线程a");
MyThread mt2=new MyThread("线程b");
//乱序进行
mt1.start();
mt2.start();
}
};
这样程序可以正常完成交互式运行。那么为啥非要使用start()方法启动多线程呢？
在JDK的安装路径下，src.zip是全部的java源程序，通过此代码找到Thread中的start()方法的定义，可以发现此方法中使用了private native void start0();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（java Native Interface）
·Runnable接口
在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。
public interface Runnable{
public void run();
}
例子：
package org.runnable.demo;
class MyThread implements Runnable{
private String name;
public MyThread(String name) {
this.name = name;
}
public void run(){
for(int i=0;i<100;i++){
System.out.println("线程开始："+this.name+",i="+i);
}
}
};
但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable target)
此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多
线程。（start()可以协调系统的资源）:
package org.runnable.demo;
import org.runnable.demo.MyThread;
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread("线程a");
MyThread mt2=new MyThread("线程b");
new Thread(mt1).start();
new Thread(mt2).start();
}
}
· 两种实现方式的区别和联系：
在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比
继承Thread类有如下好处：
->避免点继承的局限，一个类可以继承多个接口。
->适合于资源的共享
以卖票程序为例，通过Thread类完成：
package org.demo.dff;
class MyThread extends Thread{
private int ticket=10;
public void run(){
for(int i=0;i<20;i++){
if(this.ticket>0){
System.out.println("卖票：ticket"+this.ticket--);
}
}
}
};
下面通过三个线程对象，同时卖票：
package org.demo.dff;
public class ThreadTicket {
public static void main(String[] args) {
MyThread mt1=new MyThread();
MyThread mt2=new MyThread();
MyThread mt3=new MyThread();
mt1.start();//每个线程都各卖了10张，共卖了30张票
mt2.start();//但实际只有10张票，每个线程都卖自己的票
mt3.start();//没有达到资源共享
}
}
如果用Runnable就可以实现资源共享，下面看例子：
package org.demo.runnable;
class MyThread implements Runnable{
private int ticket=10;
public void run(){
for(int i=0;i<20;i++){
if(this.ticket>0){
System.out.println("卖票：ticket"+this.ticket--);
}
}
}
}
package org.demo.runnable;
public class RunnableTicket {
public static void main(String[] args) {
MyThread mt=new MyThread();
new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一
new Thread(mt).start();//个实例化对象mt，就会出现异常
new Thread(mt).start();
}
};
虽然现在程序中有三个线程，但是一共卖了10张票，也就是说使用Runnable实现多线程可以达到资源共享目的。
Runnable接口和Thread之间的联系：
public class Thread extends Object implements Runnable
发现Thread类也是Runnable接口的子类。
>>> (1)两种方法：继承Thread类 ：Class newThread extends Thread { private int xx; ... //定义属性
public void run(){...执行任务...}
}
new newThread().start();
实现Runnable接口：public class runnableThread implements Runnable{ private int xx;
public void run(){...}
}
runnableThread rThread =new runnableThread();
new Thread(rThread).start();
Runnable对象 为线程的target，多个线程可以共享一个线程类的实例属性。
Callable 实现类与创建Runnable差别不大，只是callable的call() 方法允许声明抛出异常，而且允许带返回值，返回值通 过FutureTask对象的get()方法获取。
2. 线程同步
java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），
将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，
从而保证了该变量的唯一性和准确性。
1.同步方法
即有synchronized关键字修饰的方法。
由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，
内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
代码如：
public synchronized void save(){}
注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类
2.同步代码块
即有synchronized关键字修饰的语句块。
被该关键字修饰的语句块会自动被加上内置锁，从而实现同步
代码如：
synchronized(object){
}
注：同步是一种高开销的操作，因此应该尽量减少同步的内容。
通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。
代码实例：
复制代码
package com.xhj.thread;
/**
* 线程同步的运用
*
* @author XIEHEJUN
*
*/
public class SynchronizedThread {
class Bank {
private int account = 100;
public int getAccount() {
return account;
}
/**
* 用同步方法实现
*
* @param money
*/
public synchronized void save(int money) {
account += money;
}
/**
* 用同步代码块实现
*
* @param money
*/
public void save1(int money) {
synchronized (this) {
account += money;
}
}
}
class NewThread implements Runnable {
private Bank bank;
public NewThread(Bank bank) {
this.bank = bank;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
// bank.save1(10);
bank.save(10);
System.out.println(i + "账户余额为：" + bank.getAccount());
}
}
}
/**
* 建立线程，调用内部类
*/
public void useThread() {
Bank bank = new Bank();
NewThread new_thread = new NewThread(bank);
System.out.println("线程1");
Thread thread1 = new Thread(new_thread);
thread1.start();
System.out.println("线程2");
Thread thread2 = new Thread(new_thread);
thread2.start();
}
public static void main(String[] args) {
SynchronizedThread st = new SynchronizedThread();
st.useThread();
}
}
复制代码
3.使用特殊域变量(volatile)实现线程同步
a.volatile关键字为域变量的访问提供了一种免锁机制，
b.使用volatile修饰域相当于告诉
虚拟机该域可能会被其他线程更新，
c.因此每次使用该域就要重新计算，而不是使用寄存器中的值
d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量
例如：
在上面的例子当中，只需在account前面加上volatile修饰，即可实现线程同步。
代码实例：
复制代码
//只给出要修改的代码，其余代码与上同
class Bank {
//需要同步的变量加上volatile
private volatile int account = 100;
public int getAccount() {
return account;
}
//这里不再需要synchronized
public void save(int money) {
account += money;
}
｝
复制代码
注：多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。
用final域，有锁保护的域和volatile域可以避免非同步的问题。
4.使用重入锁实现线程同步
在
JavaSE5.0中新增了一个java.util.concurrent包来支持同步。
ReentrantLock类是可重入、互斥、实现了Lock接口的锁，
它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力
ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁
注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用
例如：
在上面例子的基础上，改写后的代码为:
代码实例：
复制代码
//只给出要修改的代码，其余代码与上同
class Bank {
private int account = 100;
//需要声明这个锁
private Lock lock = new ReentrantLock();
public int getAccount() {
return account;
}
//这里不再需要synchronized
public void save(int money) {
lock.lock();
try{
account += money;
}finally{
lock.unlock();
}
}
｝
复制代码
注：关于Lock对象和synchronized关键字的选择：
a.最好两个都不用，使用一种java.util.concurrent包提供的机制，
能够帮助用户处理所有与锁相关的代码。
b.如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码
c.如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁
5.使用局部变量实现线程同步
如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，
副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。
ThreadLocal 类的常用方法
ThreadLocal() : 创建一个线程本地变量
get() : 返回此线程局部变量的当前线程副本中的值
initialValue() : 返回此线程局部变量的当前线程的"初始值"
set(T value) : 将此线程局部变量的当前线程副本中的值设置为value
例如：
在上面例子基础上，修改后的代码为：
代码实例：
复制代码
//只改Bank类，其余代码与上同
public class Bank{
//使用ThreadLocal类管理共享变量account
private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){
@Override
protected Integer initialValue(){
return 100;
}
};
public void save(int money){
account.set(account.get()+money);
}
public int getAccount(){
return account.get();
}
}
复制代码
注：ThreadLocal与同步机制
a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。
b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式
（2）①Synchronized() : 同步代码块Synchronized（obj） 以及同步 方法 public Synchronized void function(){ } |||But 不能修饰 构造器以及属性等。
使用Synchronized（），该对象也即成了同步监视器。
②ReentrantLock ： 声明这个锁private Lock lock = new ReentrantLock(); lock.lock() 在作用范围内锁定，结束时要显式解锁
lock.unlock();
. 3.线程通信
1.传统的线程通信 对于Synchronized 修饰的同步方法，因为该类的默认实例（this）即是同步监视器，可以在同步方法中调用
wait（）//导致当前线程等待，直到其他线程调用该同步监视器的notify或notifyAll方法来唤醒。
notify（） //唤醒在此同步监视器上等待的单个线程。
notifyAll（）//唤醒在此同步监视器上等待的所有线程。
public class Account{
....
....
public synchronized void function(){
if(Flag){
wait();
}else{
...
notifyAll();
}
}
}
2. Condition控制线程 如果使用Lock对象来保护同步，则系统中不存在隐式监视器，不能使用上述 wait（）等方法。此时Java提供
Condition类来保持协调，对应的方法：condition.await(),condition.singal()以及condition.signalAll():
public class Account{
private final Lock lock=new ReentrantLock();//显示定义Lock对象
private final Condition condition =lock.newCondition（); //获得指定对象的Condition
。。。。
public void function（xx）{
。。。
lock.lock();
if(flag){
condition.await();
}else{
。。。
condition.signalAll();
}
finally{
lock.unlock();
}
}
}
.4. 线程池
系统启动一个新线程的成本较高，当需要创建大量生存期很短的线程时，可以考虑使用线程池。
Android线程池使用
http://www.xuanyusong.com/archives/2439/
有一段时间没写博文了，今天抽空总结一下，也希望能通过自己写的这些文章，加深理解的同时能帮助在技术方面有疑点的朋友搞清楚个所以然来，由于经常会在网上或群里看到有朋友会问线程方面的东西，就像我一个朋友他们老师讲的，J2SE、J2EE里面使用的线程方面的东西可能不是太多 ，但是在Android开发里面，玩的就是线程（UI Thread）！ 好了，废话就说这么多吧，直入正题！今天要讲的东西就是线程池、线程的高效率使用，灵活控制！今天死马我就用最常用的几种方式来分别实现应用中使用的线程方面的知识，（共写了两个不同入口的Activity来分开不同的实现方式，大家可以自行注释AndroidManifest.xml中的Launch入口或打开注释）好了，先随便列几个吧，如：AsyncTask 、Runnable 、Thread、ThreadPool、 Executors等等的使用，看我文章的朋友应该都很清楚小马的方式啦，果断先上效果，再一步步分解代码，来吧，效果图如下：
一：无大小限制的线程池执行效果如下
二：限制按顺序来执行任务的线程池效果如下
三：一个一个任务的执行线程池效果如下（与按顺序执行效果是一样的，只是内部实现稍有不同）
四：按指定个数来执行任务的线程池效果如下
五：创建一个可在指定时间里执行任务的线程池，亦可重复执行,不常用，效果与四相同
六：按指定工厂模式来执行的线程池，效果与四、五一样，但用方式六创建的线程池都有在工厂中指定的线程属性，
比如：线程名字、是否为用户线程等等属性
七：线程池中任务执行时可暂停效果图如下
八：用Runnable、ConcurrentLinkedQueue、ConcurrentMap、Future、ExecutorService关联实现的效果图如下
哦的了，效果看完了，现在就请大家自行修改AndroidManifest.xml中主Activity的入口来看两种不同方式实现的代码效果吧，首先，先贴一下Main.java类的代码，希望大家详细看里面的注释，一定要详细看，你不会吃亏的，相信我！（备注：为了写文章加注释还有查找的时候方便，小马把所有的主类及辅助类以内部类的形式写到一个.java文件里面了，如果朋友们觉得看着乱，不爽的话，可以自行将里面的类抽取到单独的.java文件中，几分钟搞定的事！）
方式一（纯ExecutorService、AsyncTask、Runnable关联实现相关文件如下）：
1.1：主类文件(Main.java)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
|
/*
* FileName: Main.java
* CopyRight: Belong to <XiaoMaGuo Technologies > own
* Description: <description>
* Modify By : XiaoMaGuo ^_^
* Modify Date: 2013-10-15
* Follow Order No.: <Follow Order No.>
* Modify Order No.: <Modify Order No.>
* Modify Content: <modify content >
*/
package
com
.
xiaoma
.
threadpooltest
;
import
java
.
util
.
ArrayList
;
import
java
.
util
.
List
;
import
java
.
util
.
concurrent
.
ExecutorService
;
import
java
.
util
.
concurrent
.
Executors
;
import
java
.
util
.
concurrent
.
ThreadFactory
;
import
android
.
annotation
.
TargetApi
;
import
android
.
app
.
Activity
;
import
android
.
content
.
Context
;
import
android
.
os
.
AsyncTask
;
import
android
.
os
.
Build
;
import
android
.
os
.
Bundle
;
import
android
.
os
.
SystemClock
;
import
android
.
util
.
AttributeSet
;
import
android
.
util
.
Log
;
import
android
.
view
.
LayoutInflater
;
import
android
.
view
.
View
;
import
android
.
view
.
ViewGroup
;
import
android
.
widget
.
AdapterView
;
import
android
.
widget
.
AdapterView
.
OnItemClickListener
;
import
android
.
widget
.
BaseAdapter
;
import
android
.
widget
.
LinearLayout
;
import
android
.
widget
.
ListView
;
import
android
.
widget
.
ProgressBar
;
import
android
.
widget
.
TextView
;
import
android
.
widget
.
Toast
;
/**
* @TODO [The Class File Description]
* @author XiaoMaGuo ^_^
* @version [version-code, 2013-10-15]
* @since [Product/module]
*/
@
TargetApi
(
Build
.
VERSION_CODES
.
HONEYCOMB
)
public
class
Main
extends
Activity
{
private
static
int
order
=
0
;
/** 总共多少任务（根据CPU个数决定创建活动线程的个数,这样取的好处就是可以让手机承受得住） */
// private static final int count = Runtime.getRuntime().availableProcessors() * 3 + 2;
/** 总共多少任务（我是在模拟器里面跑的，为了效果明显，所以写死了为10个，如果在手机上的话，推荐使用上面的那个count） */
private
static
final
int
count
=
10
;
/** 每次只执行一个任务的线程池 */
private
static
ExecutorService
singleTaskExecutor
=
null
;
/** 每次执行限定个数个任务的线程池 */
private
static
ExecutorService
limitedTaskExecutor
=
null
;
/** 所有任务都一次性开始的线程池 */
private
static
ExecutorService
allTaskExecutor
=
null
;
/** 创建一个可在指定时间里执行任务的线程池，亦可重复执行 */
private
static
ExecutorService
scheduledTaskExecutor
=
null
;
/** 创建一个可在指定时间里执行任务的线程池，亦可重复执行（不同之处：使用工程模式） */
private
static
ExecutorService
scheduledTaskFactoryExecutor
=
null
;
private
List
<
AsyncTaskTest
>
mTaskList
=
null
;
/** 任务是否被取消 */
private
boolean
isCancled
=
false
;
/** 是否点击并取消任务标示符 */
private
boolean
isClick
=
false
;
/** 线程工厂初始化方式一 */
ThreadFactory
tf
=
Executors
.
defaultThreadFactory
(
)
;
/** 线程工厂初始化方式二 */
private
static
class
ThreadFactoryTest
implements
ThreadFactory
{
@
Override
public
Thread
newThread
(
Runnable
r
)
{
Thread
thread
=
new
Thread
(
r
)
;
thread
.
setName
(
"XiaoMaGuo_ThreadFactory"
)
;
thread
.
setDaemon
(
true
)
;
// 将用户线程变成守护线程,默认false
return
thread
;
}
}
static
{
singleTaskExecutor
=
Executors
.
newSingleThreadExecutor
(
)
;
// 每次只执行一个线程任务的线程池
limitedTaskExecutor
=
Executors
.
newFixedThreadPool
(
3
)
;
// 限制线程池大小为7的线程池
allTaskExecutor
=
Executors
.
newCachedThreadPool
(
)
;
// 一个没有限制最大线程数的线程池
scheduledTaskExecutor
=
Executors
.
newScheduledThreadPool
(
3
)
;
// 一个可以按指定时间可周期性的执行的线程池
scheduledTaskFactoryExecutor
=
Executors
.
newFixedThreadPool
(
3
,
new
ThreadFactoryTest
(
)
)
;
// 按指定工厂模式来执行的线程池
scheduledTaskFactoryExecutor
.
submit
(
new
Runnable
(
)
{
@
Override
public
void
run
(
)
{
Log
.
i
(
"KKK"
,
"This is the ThreadFactory Test submit Run! ! ! "
)
;
}
}
)
;
}
;
@
Override
public
void
onCreate
(
Bundle
icicle
)
{
super
.
onCreate
(
icicle
)
;
setContentView
(
R
.
layout
.
demo
)
;
final
ListView
taskList
=
(
ListView
)
findViewById
(
R
.
id
.
task_list
)
;
taskList
.
setAdapter
(
new
AsyncTaskAdapter
(
getApplication
(
)
,
count
)
)
;
taskList
.
setOnItemClickListener
(
new
OnItemClickListener
(
)
{
@
Override
public
void
onItemClick
(
AdapterView
<
?
>
parent
,
View
view
,
int
position
,
long
id
)
{
if
(
position
==
0
)
// 以第一项为例，来测试关闭线程池
{
/**
* 会关闭线程池方式一：但不接收新的Task,关闭后，正在等待 执行的任务不受任何影响，会正常执行,无返回值!
*/
// allTaskExecutor.shutdown();
/**
* 会关闭线程池方式二：也不接收新的Task，并停止正等待执行的Task（也就是说， 执行到一半的任务将正常执行下去），最终还会给你返回一个正在等待执行但线程池关闭却没有被执行的Task集合！
*/
List
<
Runnable
>
unExecRunn
=
allTaskExecutor
.
shutdownNow
(
)
;
for
(
Runnable
r
:
unExecRunn
)
{
Log
.
i
(
"KKK"
,
"未执行的任务信息：="
+
unExecRunn
.
toString
(
)
)
;
}
Log
.
i
(
"KKK"
,
"Is shutdown ? = "
+
String
.
valueOf
(
allTaskExecutor
.
isShutdown
(
)
)
)
;
allTaskExecutor
=
null
;
}
// 以第二项为例来测试是否取消执行的任务
AsyncTaskTest
sat
=
mTaskList
.
get
(
1
)
;
if
(
position
==
1
)
{
if
(
!
isClick
)
{
sat
.
cancel
(
true
)
;
isCancled
=
true
;
isClick
=
!
isClick
;
}
else
{
sat
.
cancel
(
false
)
;
isCancled
=
false
;
// isClick = false;
isClick
=
!
isClick
;
if
(
null
!=
sat
&&
sat
.
getStatus
(
)
==
AsyncTask
.
Status
.
RUNNING
)
{
if
(
sat
.
isCancelled
(
)
)
{
sat
=
new
AsyncTaskTest
(
sat
.
mTaskItem
)
;
}
else
{
Toast
.
makeText
(
Main
.
this
,
"A task is already running, try later"
,
Toast
.
LENGTH_SHORT
)
.
show
(
)
;
}
}
/**
* 由于上面测试关闭，在不重新生成allTaskExecutor的同时，会报异常（没有可以使用的线程池，故此处重新生成线程池对象）
*/
if
(
allTaskExecutor
==
null
)
{
allTaskExecutor
=
Executors
.
newCachedThreadPool
(
)
;
}
sat
.
executeOnExecutor
(
allTaskExecutor
)
;
// The task is already running(这也是个异常哦，小心使用！ )
}
}
else
{
sat
.
cancel
(
false
)
;
isCancled
=
false
;
// sat.execute(sat.mTaskItem);
// sat.executeOnExecutor(allTaskExecutor);
}
}
}
)
;
}
/**
* @TODO [ListView Item的条目适配器]
* @author XiaoMaGuo ^_^
* @version [version-code, 2013-10-22]
* @since [Product/module]
*/
private
class
AsyncTaskAdapter
extends
BaseAdapter
{
private
Context
mContext
;
private
LayoutInflater
mFactory
;
private
int
mTaskCount
;
public
AsyncTaskAdapter
(
Context
context
,
int
taskCount
)
{
mContext
=
context
;
mFactory
=
LayoutInflater
.
from
(
mContext
)
;
mTaskCount
=
taskCount
;
mTaskList
=
new
ArrayList
<
AsyncTaskTest
>
(
taskCount
)
;
}
@
Override
public
int
getCount
(
)
{
return
mTaskCount
;
}
@
Override
public
Object
getItem
(
int
position
)
{
return
mTaskList
.
get
(
position
)
;
}
@
Override
public
long
getItemId
(
int
position
)
{
return
position
;
}
@
Override
public
View
getView
(
int
position
,
View
convertView
,
ViewGroup
parent
)
{
if
(
convertView
==
null
)
{
convertView
=
mFactory
.
inflate
(
R
.
layout
.
list_view_item
,
null
)
;
AsyncTaskTest
task
=
new
AsyncTaskTest
(
(
MyListItem
)
convertView
)
;
/**
* 下面两种任务执行效果都一样,形变质不变
* */
// task.execute();
// task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);
/**
* 下面的方式在小于API 11级时效果是一样的，但在高版本中的稍微有点不同,可以看以下AsyncTask核心变量的定义就知道了使用如下
* 方式时，系统会默认的采用五个一组，五个一组的方式来执行我们的任务，定义在：AsyncTask.class中，private static final int CORE_POOL_SIZE = 5;
* */
// use AsyncTask#THREAD_POOL_EXECUTOR is the same to older version #execute() (less than API 11)
// but different from newer version of #execute()
// task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
/**
* 一个一个执行我们的任务,效果与按顺序执行是一样的(AsyncTask.SERIAL_EXECUTOR)
* */
// task.executeOnExecutor(singleTaskExecutor);
/**
* 按我们指定的个数来执行任务的线程池
* */
// task.executeOnExecutor(limitedTaskExecutor);
/**
* 不限定指定个数的线程池，也就是说：你往里面放了几个任务，他全部同一时间开始执行， 不管你手机受得了受不了
* */
task
.
executeOnExecutor
(
allTaskExecutor
)
;
/**
* 创建一个可在指定时间里执行任务的线程池，亦可重复执行
* */
// task.executeOnExecutor(scheduledTaskExecutor);
/**
* 创建一个按指定工厂模式来执行任务的线程池,可能比较正规,但也不常用
*/
// task.executeOnExecutor(scheduledTaskFactoryExecutor);
mTaskList
.
add
(
task
)
;
}
return
convertView
;
}
}
class
AsyncTaskTest
extends
AsyncTask
<
Void
,
Integer
,
Void
>
{
private
MyListItem
mTaskItem
;
private
String
id
;
private
AsyncTaskTest
(
MyListItem
item
)
{
mTaskItem
=
item
;
if
(
order
<
count
||
order
==
count
)
{
id
=
"执行:"
+
String
.
valueOf
(
++
order
)
;
}
else
{
order
=
0
;
id
=
"执行:"
+
String
.
valueOf
(
++
order
)
;
}
}
@
Override
protected
void
onPreExecute
(
)
{
mTaskItem
.
setTitle
(
id
)
;
}
/**
* Overriding methods
*/
@
Override
protected
void
onCancelled
(
)
{
super
.
onCancelled
(
)
;
}
@
Override
protected
Void
doInBackground
(
Void
.
.
.
params
)
{
if
(
!
isCancelled
(
)
&&
isCancled
==
false
)
// 这个地方很关键，如果不设置标志位的话，直接setCancel（true）是无效的
{
int
prog
=
0
;
/**
* 下面的while中，小马写了个分支用来做个假象（任务东西刚开始下载的时候，速度快，快下载完成的时候就突然间慢了下来的效果， 大家可以想象一下，类似
* ：PP手机助手、91手机助手中或其它手机应用中，几乎都有这个假象，开始快，结束时就下载变慢了，讲白了 就是开发的人不想让你在下载到大于一半的时候，也就是快下载完的时候去点取消，你那样得多浪费
* ！所以造个假象，让你不想去取消而已）
*/
while
(
prog
<
101
)
{
if
(
(
prog
>
0
||
prog
==
0
)
&&
prog
<
70
)
// 小于70%时，加快进度条更新
{
SystemClock
.
sleep
(
100
)
;
}
else
// 大于70%时，减慢进度条更新
{
SystemClock
.
sleep
(
300
)
;
}
publishProgress
(
prog
)
;
// 更新进度条
prog
++
;
}
}
return
null
;
}
@
Override
protected
void
onPostExecute
(
Void
result
)
{
}
@
Override
protected
void
onProgressUpdate
(
Integer
.
.
.
values
)
{
mTaskItem
.
setProgress
(
values
[
0
]
)
;
// 设置进度
}
}
}
/**
* @TODO [一个简单的自定义 ListView Item]
* @author XiaoMaGuo ^_^
* @version [version-code, 2013-10-22]
* @since [Product/module]
*/
class
MyListItem
extends
LinearLayout
{
private
TextView
mTitle
;
private
ProgressBar
mProgress
;
public
MyListItem
(
Context
context
,
AttributeSet
attrs
)
{
super
(
context
,
attrs
)
;
}
public
MyListItem
(
Context
context
)
{
super
(
context
)
;
}
public
void
setTitle
(
String
title
)
{
if
(
mTitle
==
null
)
{
mTitle
=
(
TextView
)
findViewById
(
R
.
id
.
task_name
)
;
}
mTitle
.
setText
(
title
)
;
}
public
void
setProgress
(
int
prog
)
{
if
(
mProgress
==
null
)
{
mProgress
=
(
ProgressBar
)
findViewById
(
R
.
id
.
task_progress
)
;
}
mProgress
.
setProgress
(
prog
)
;
}
}
|
1.2：布局文件
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
<?
xml
version
=
"1.0"
encoding
=
"utf-8"
?>
<
LinearLayout
xmlns
:
android
=
"http://schemas.android.com/apk/res/android"
android
:
layout_width
=
"match_parent"
android
:
layout_height
=
"match_parent"
android
:
paddingLeft
=
"10dip"
android
:
paddingRight
=
"10dip"
android
:
orientation
=
"vertical"
>
<
ListView
android
:
id
=
"@+id/task_list"
android
:
layout_width
=
"fill_parent"
android
:
layout_height
=
"wrap_content"
android
:
divider
=
"#cccccc"
android
:
dividerHeight
=
"0.6dip"
android
:
footerDividersEnabled
=
"true"
android
:
headerDividersEnabled
=
"true"
/
>
<
/
LinearLayout
>
|
方式二（Runnable、ConcurrentLinkedQueue、ConcurrentMap、Future、ExecutorService关联实现的相关文件如 下）：
2.1:主类文件(MyRunnableActivity.java)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
|
/*
* FileName: MyRunnableActivity.java
* CopyRight: Belong to <XiaoMaGuo Technologies > own
* Description: <description>
* Modify By : XiaoMaGuo ^_^
* Modify Date: 2013-10-21
* Follow Order No.: <Follow Order No.>
* Modify Order No.: <Modify Order No.>
* Modify Content: <modify content >
*/
package
com
.
xiaoma
.
threadpooltest
;
import
java
.
util
.
Iterator
;
import
java
.
util
.
Map
;
import
java
.
util
.
concurrent
.
ConcurrentHashMap
;
import
java
.
util
.
concurrent
.
ConcurrentLinkedQueue
;
import
java
.
util
.
concurrent
.
ConcurrentMap
;
import
java
.
util
.
concurrent
.
ExecutorService
;
import
java
.
util
.
concurrent
.
Executors
;
import
java
.
util
.
concurrent
.
Future
;
import
android
.
app
.
Activity
;
import
android
.
os
.
Bundle
;
import
android
.
os
.
Handler
;
import
android
.
os
.
Message
;
import
android
.
util
.
Log
;
import
android
.
view
.
View
;
import
android
.
view
.
View
.
OnClickListener
;
import
android
.
widget
.
ProgressBar
;
import
android
.
widget
.
Toast
;
/**
* @TODO [线程池控制 ]
* @author XiaoMaGuo ^_^
* @version [version-code, 2013-10-22]
* @since [Product/module]
*/
public
class
MyRunnableActivity
extends
Activity
implements
OnClickListener
{
/** 任务执行队列 */
private
ConcurrentLinkedQueue
<
MyRunnable
>
taskQueue
=
null
;
/**
* 正在等待执行或已经完成的任务队列
*
* 备注：Future类，一个用于存储异步任务执行的结果，比如：判断是否取消、是否可以取消、是否正在执行、是否已经完成等
*
* */
private
ConcurrentMap
<
Future
,
MyRunnable
>
taskMap
=
null
;
/**
* 创建一个不限制大小的线程池 此类主要有以下好处 1，以共享的无界队列方式来运行这些线程. 2，执行效率高。 3，在任意点，在大多数 nThreads 线程会处于处理任务的活动状态
* 4，如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。
*
* */
private
ExecutorService
mES
=
null
;
/** 在此类中使用同步锁时使用如下lock对象即可，官方推荐的，不推荐直接使用MyRunnableActivity.this类型的,可以详细读一下/framework/app下面的随便一个项目 */
private
Object
lock
=
new
Object
(
)
;
/** 唤醒标志，是否唤醒线程池工作 */
private
boolean
isNotify
=
true
;
/** 线程池是否处于运行状态(即:是否被释放!) */
private
boolean
isRuning
=
true
;
/** 任务进度 */
private
ProgressBar
pb
=
null
;
/** 用此Handler来更新我们的UI */
private
Handler
mHandler
=
null
;
/**
* Overriding methods
*
* @param savedInstanceState
*/
@
Override
protected
void
onCreate
(
Bundle
savedInstanceState
)
{
// TODO Auto-generated method stub
super
.
onCreate
(
savedInstanceState
)
;
setContentView
(
R
.
layout
.
my_runnable_main
)
;
init
(
)
;
}
public
void
init
(
)
{
pb
=
(
ProgressBar
)
findViewById
(
R
.
id
.
progressBar1
)
;
findViewById
(
R
.
id
.
button1
)
.
setOnClickListener
(
this
)
;
findViewById
(
R
.
id
.
button2
)
.
setOnClickListener
(
this
)
;
findViewById
(
R
.
id
.
button3
)
.
setOnClickListener
(
this
)
;
findViewById
(
R
.
id
.
button4
)
.
setOnClickListener
(
this
)
;
findViewById
(
R
.
id
.
button5
)
.
setOnClickListener
(
this
)
;
taskQueue
=
new
ConcurrentLinkedQueue
<
MyRunnable
>
(
)
;
taskMap
=
new
ConcurrentHashMap
<
Future
,
MyRunnable
>
(
)
;
if
(
mES
==
null
)
{
mES
=
Executors
.
newCachedThreadPool
(
)
;
}
// 用于更新ProgressBar进度条
mHandler
=
new
Handler
(
)
{
/**
* Overriding methods
*
* @param msg
*/
@
Override
public
void
handleMessage
(
Message
msg
)
{
super
.
handleMessage
(
msg
)
;
pb
.
setProgress
(
msg
.
what
)
;
}
}
;
}
/**
* Overriding methods
*
* @param v
*/
@
Override
public
void
onClick
(
View
v
)
{
switch
(
v
.
getId
(
)
)
{
case
R
.
id
.
button1
:
start
(
)
;
break
;
case
R
.
id
.
button2
:
stop
(
)
;
break
;
case
R
.
id
.
button3
:
reload
(
new
MyRunnable
(
mHandler
)
)
;
break
;
case
R
.
id
.
button4
:
release
(
)
;
break
;
case
R
.
id
.
button5
:
addTask
(
new
MyRunnable
(
mHandler
)
)
;
break
;
default
:
break
;
}
}
/**
* <Summary Description>
*/
private
void
addTask
(
final
MyRunnable
mr
)
{
mHandler
.
sendEmptyMessage
(
0
)
;
if
(
mES
==
null
)
{
mES
=
Executors
.
newCachedThreadPool
(
)
;
notifyWork
(
)
;
}
if
(
taskQueue
==
null
)
{
taskQueue
=
new
ConcurrentLinkedQueue
<
MyRunnable
>
(
)
;
}
if
(
taskMap
==
null
)
{
taskMap
=
new
ConcurrentHashMap
<
Future
,
MyRunnable
>
(
)
;
}
mES
.
execute
(
new
Runnable
(
)
{
@
Override
public
void
run
(
)
{
/**
* 插入一个Runnable到任务队列中 这个地方解释一下,offer跟add方法,试了下,效果都一样,没区别,官方的解释如下: 1 offer : Inserts the specified
* element at the tail of this queue. As the queue is unbounded, this method will never return
* {@code false}. 2 add: Inserts the specified element at the tail of this queue. As the queue is
* unbounded, this method will never throw {@link IllegalStateException} or return {@code false}.
*
*
* */
taskQueue
.
offer
(
mr
)
;
// taskQueue.add(mr);
notifyWork
(
)
;
}
}
)
;
Toast
.
makeText
(
MyRunnableActivity
.
this
,
"已添加一个新任务到线程池中 ！"
,
0
)
.
show
(
)
;
}
/**
* <Summary Description>
*/
private
void
release
(
)
{
Toast
.
makeText
(
MyRunnableActivity
.
this
,
"释放所有占用的资源！"
,
0
)
.
show
(
)
;
/** 将ProgressBar进度置为0 */
mHandler
.
sendEmptyMessage
(
0
)
;
isRuning
=
false
;
Iterator
iter
=
taskMap
.
entrySet
(
)
.
iterator
(
)
;
while
(
iter
.
hasNext
(
)
)
{
Map
.
Entry
<
Future
,
MyRunnable
>
entry
=
(
Map
.
Entry
<
Future
,
MyRunnable
>
)
iter
.
next
(
)
;
Future
result
=
entry
.
getKey
(
)
;
if
(
result
==
null
)
{
continue
;
}
result
.
cancel
(
true
)
;
taskMap
.
remove
(
result
)
;
}
if
(
null
!=
mES
)
{
mES
.
shutdown
(
)
;
}
mES
=
null
;
taskMap
=
null
;
taskQueue
=
null
;
}
/**
* <Summary Description>
*/
private
void
reload
(
final
MyRunnable
mr
)
{
mHandler
.
sendEmptyMessage
(
0
)
;
if
(
mES
==
null
)
{
mES
=
Executors
.
newCachedThreadPool
(
)
;
notifyWork
(
)
;
}
if
(
taskQueue
==
null
)
{
taskQueue
=
new
ConcurrentLinkedQueue
<
MyRunnable
>
(
)
;
}
if
(
taskMap
==
null
)
{
taskMap
=
new
ConcurrentHashMap
<
Future
,
MyRunnable
>
(
)
;
}
mES
.
execute
(
new
Runnable
(
)
{
@
Override
public
void
run
(
)
{
/** 插入一个Runnable到任务队列中 */
taskQueue
.
offer
(
mr
)
;
// taskQueue.add(mr);
notifyWork
(
)
;
}
}
)
;
mES
.
execute
(
new
Runnable
(
)
{
@
Override
public
void
run
(
)
{
if
(
isRuning
)
{
MyRunnable
myRunnable
=
null
;
synchronized
(
lock
)
{
myRunnable
=
taskQueue
.
poll
(
)
;
// 从线程队列中取出一个Runnable对象来执行，如果此队列为空，则调用poll()方法会返回null
if
(
myRunnable
==
null
)
{
isNotify
=
true
;
}
}
if
(
myRunnable
!=
null
)
{
taskMap
.
put
(
mES
.
submit
(
myRunnable
)
,
myRunnable
)
;
}
}
}
}
)
;
}
/**
* <Summary Description>
*/
private
void
stop
(
)
{
Toast
.
makeText
(
MyRunnableActivity
.
this
,
"任务已被取消！"
,
0
)
.
show
(
)
;
for
(
MyRunnable
runnable
:
taskMap
.
values
(
)
)
{
runnable
.
setCancleTaskUnit
(
true
)
;
}
}
/**
* <Summary Description>
*/
private
void
start
(
)
{
if
(
mES
==
null
||
taskQueue
==
null
||
taskMap
==
null
)
{
Log
.
i
(
"KKK"
,
"某资源是不是已经被释放了？"
)
;
return
;
}
mES
.
execute
(
new
Runnable
(
)
{
@
Override
public
void
run
(
)
{
if
(
isRuning
)
{
MyRunnable
myRunnable
=
null
;
synchronized
(
lock
)
{
myRunnable
=
taskQueue
.
poll
(
)
;
// 从线程队列中取出一个Runnable对象来执行，如果此队列为空，则调用poll()方法会返回null
if
(
myRunnable
==
null
)
{
isNotify
=
true
;
// try
// {
// myRunnable.wait(500);
// }
// catch (InterruptedException e)
// {
// e.printStackTrace();
// }
}
}
if
(
myRunnable
!=
null
)
{
taskMap
.
put
(
mES
.
submit
(
myRunnable
)
,
myRunnable
)
;
}
}
}
}
)
;
}
private
void
notifyWork
(
)
{
synchronized
(
lock
)
{
if
(
isNotify
)
{
lock
.
notifyAll
(
)
;
isNotify
=
!
isNotify
;
}
}
}
}
|
2.2:辅助类（MyRunnable.java）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
/*
* FileName: MyRunnable.java
* CopyRight: Belong to <XiaoMaGuo Technologies > own
* Description: <description>
* Modify By : XiaoMaGuo ^_^
* Modify Date: 2013-10-21
* Follow Order No.: <Follow Order No.>
* Modify Order No.: <Modify Order No.>
* Modify Content: <modify content >
*/
package
com
.
xiaoma
.
threadpooltest
;
import
android
.
os
.
Handler
;
import
android
.
os
.
SystemClock
;
import
android
.
util
.
Log
;
/**
* @TODO [The Class File Description]
* @author XiaoMaGuo ^_^
* @version [version-code, 2013-10-21]
* @since [Product/module]
*/
public
class
MyRunnable
implements
Runnable
{
private
boolean
cancleTask
=
false
;
private
boolean
cancleException
=
false
;
private
Handler
mHandler
=
null
;
public
MyRunnable
(
Handler
handler
)
{
mHandler
=
handler
;
}
/**
* Overriding methods
*/
@
Override
public
void
run
(
)
{
Log
.
i
(
"KKK"
,
"MyRunnable run() is executed!!! "
)
;
runBefore
(
)
;
if
(
cancleTask
==
false
)
{
running
(
)
;
Log
.
i
(
"KKK"
,
"调用MyRunnable run()方法"
)
;
}
runAfter
(
)
;
}
/**
* <Summary Description>
*/
private
void
runAfter
(
)
{
Log
.
i
(
"KKK"
,
"runAfter()"
)
;
}
/**
* <Summary Description>
*/
private
void
running
(
)
{
Log
.
i
(
"KKK"
,
"running()"
)
;
try
{
// 做点有可能会出异常的事情！！！
int
prog
=
0
;
if
(
cancleTask
==
false
&&
cancleException
==
false
)
{
while
(
prog
<
101
)
{
if
(
(
prog
>
0
||
prog
==
0
)
&&
prog
<
70
)
{
SystemClock
.
sleep
(
100
)
;
}
else
{
SystemClock
.
sleep
(
300
)
;
}
if
(
cancleTask
==
false
)
{
mHandler
.
sendEmptyMessage
(
prog
++
)
;
Log
.
i
(
"KKK"
,
"调用 prog++ = "
+
(
prog
)
)
;
}
}
}
}
catch
(
Exception
e
)
{
cancleException
=
true
;
}
}
/**
* <Summary Description>
*/
private
void
runBefore
(
)
{
// TODO Auto-generated method stub
Log
.
i
(
"KKK"
,
"runBefore()"
)
;
}
public
void
setCancleTaskUnit
(
boolean
cancleTask
)
{
this
.
cancleTask
=
cancleTask
;
Log
.
i
(
"KKK"
,
"点击了取消任务按钮 ！！！"
)
;
// mHandler.sendEmptyMessage(0);
}
}
|
2.3:布局文件
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
<?
xml
version
=
"1.0"
encoding
=
"utf-8"
?>
<
LinearLayout
xmlns
:
android
=
"http://schemas.android.com/apk/res/android"
android
:
layout_width
=
"match_parent"
android
:
layout_height
=
"match_parent"
android
:
orientation
=
"vertical"
>
<
LinearLayout
android
:
layout_width
=
"match_parent"
android
:
layout_height
=
"wrap_content"
android
:
orientation
=
"horizontal"
>
<
Button
android
:
id
=
"@+id/button5"
android
:
layout_width
=
"0dp"
android
:
layout_height
=
"wrap_content"
android
:
layout_weight
=
"1"
android
:
text
=
"添加任务"
/
>
<
Button
android
:
id
=
"@+id/button1"
android
:
layout_width
=
"0dp"
android
:
layout_height
=
"wrap_content"
android
:
layout_weight
=
"1"
android
:
text
=
"开始任务"
/
>
<
Button
android
:
id
=
"@+id/button2"
android
:
layout_width
=
"0dp"
android
:
layout_height
=
"wrap_content"
android
:
layout_weight
=
"1"
android
:
text
=
"取消任务"
/
>
<
Button
android
:
id
=
"@+id/button3"
android
:
layout_width
=
"0dp"
android
:
layout_height
=
"wrap_content"
android
:
layout_weight
=
"1"
android
:
text
=
"重新加载"
/
>
<
Button
android
:
id
=
"@+id/button4"
android
:
layout_width
=
"0dp"
android
:
layout_height
=
"wrap_content"
android
:
layout_weight
=
"1"
android
:
text
=
"释放资源"
/
>
<
/
LinearLayout
>
<
include
layout
=
"@layout/my_runnable_merge"
/
>
<
/
LinearLayout
>
|
方式一、方式二的全局配置文件AndroidManifest.xml文件的配置如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
<?
xml
version
=
"1.0"
encoding
=
"utf-8"
?>
<
manifest
xmlns
:
android
=
"http://schemas.android.com/apk/res/android"
package
=
"com.xiaoma.threadpooltest"
android
:
versionCode
=
"1"
android
:
versionName
=
"1.0"
>
<
uses
-
sdk
android
:
minSdkVersion
=
"8"
android
:
targetSdkVersion
=
"15"
/
>
<
application
android
:
allowBackup
=
"true"
android
:
icon
=
"@drawable/ic_launcher"
android
:
label
=
"@string/app_name"
android
:
theme
=
"@style/AppTheme"
>
<
activity
android
:
name
=
"Main"
android
:
label
=
"@string/app_name"
>
<
!
--
<
intent
-
filter
>
--
>
<
!
--
<
action
android
:
name
=
"android.intent.action.MAIN"
/
>
--
>
<
!
--
<
category
android
:
name
=
"android.intent.category.LAUNCHER"
/
>
--
>
<
!
--
<
/
intent
-
filter
>
--
>
<
/
activity
>
<
activity
android
:
name
=
"MyRunnableActivity"
android
:
label
=
"@string/app_name"
>
<
intent
-
filter
>
<
action
android
:
name
=
"android.intent.action.MAIN"
/
>
<
category
android
:
name
=
"android.intent.category.LAUNCHER"
/
>
<
/
intent
-
filter
>
<
/
activity
>
<
/
application
>
<
/
manifest
>
|
扫一扫
1019
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
