一、线程池相关
线程超级详解：http://blog.csdn.net/cuigx1991/article/details/48219741
线程池：http://www.importnew.com/19011.html
ExecutorService
http://blog.csdn.net/yuzhiboyi/article/details/7775266
Callable与Runnable
http://blog.csdn.net/lu123535884/article/details/49495833
Callable可以返回结果，但是runnable不行。
上代码：
|
1
2
3
4
5
6
7
8
|
public
class
TestCallable
implements
Callable<String>{
@Override
public
String call()
throws
Exception {
Thread.sleep(
3000
);
return
"Hello World"
;
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
@Override
protected
void
onCreate(Bundle savedInstanceState) {
super
.onCreate(savedInstanceState);
TestCallable testCallable =
new
TestCallable();
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(testCallable);
try
{
System.out.println(future.get());
}
catch
(InterruptedException e) {
e.printStackTrace();
}
catch
(ExecutionException e) {
e.printStackTrace();
}
System.out.println(
"11111111111111"
);
}
|
可以发现我在TestCallable里加了个sleep，程序还是会后打印"111111111111"那一个串，说明TestCallable的线程会阻塞主线程，真正原因是future.get()会阻塞当前线程，直到callable的call方法结束 。
CountDownLatch
可以阻塞当前线程，等待另外一个线程执行完结果后将结果同步返回，异步转同步。
异步转同步需要注意
1）异步的数据一定要是在子线程里，否则会造成当前线程卡顿。
2）如果需要在主线程里同步返回数据，但是取数据走的是子线程，子线程不要使用new Handler(Looper.getMainLooper()) 来做延时操作，否则会造成子线程回调无法countDownLatch减小，最终主线程一直在等待。
在子线程中使用Handler的方法：
|
1
2
3
|
HandlerThread handlerThread =
new
HandlerThread(
"纯24协议对接收到的数据进行分析"
){};
handlerThread.start();
mHandler =
new
Handler(handlerThread.getLooper());
|
二、线程交互
1.唤醒与等待（wait与notify）
相关博客：http://blog.csdn.net/qq_26504875/article/details/50703961
常见异常：http://blog.csdn.net/zhouxiaoyun0228/article/details/7757313
注意事项：1)唤醒与等待是有严格的使用条件的，对象监听器只能在所监听的线程内调用。
2)wait与notify只能在同步代码块里调用
3）一般一个任务同步方法执行完，调用监听器wait当前线程。
4）wait与notify虽然是object的方法，但是作用是作为锁来控制线程。
5）wait与notify更适用于两个或多个协同工作的线程
代码实例：
2个交互的线程类：
|
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
|
public
class
MyThread1
extends
Thread{
private
Object lock;
private
int
index =
0
;
public
MyThread1(Object lock){
this
.lock = lock;
}
@Override
public
void
run(){
synchronized
(lock) {
while
(
true
){
System.out.println(
"MyThread1 "
+System.currentTimeMillis());
index++;
if
(index ==
10
){
lock.notify();
break
;
}
if
(index %
5
==
0
){
try
{
lock.notify();
System.out.println(
"MyThread1 wait"
);
lock.wait();
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
|
|
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
|
public
class
MyThread2
extends
Thread{
private
Object lock;
private
int
index =
0
;
public
MyThread2(Object lock){
this
.lock = lock;
}
@Override
public
void
run(){
synchronized
(lock) {
while
(
true
){
System.out.println(
"MyThread2 "
+System.currentTimeMillis());
index++;
if
(index ==
10
){
lock.notify();
break
;
}
if
(index %
5
==
0
){
try
{
lock.notify();
System.out.println(
"MyThread2 wait"
);
lock.wait();
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
|
2个交互线程的任务调用类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public
class
Thread1Tasker
implements
ITask{
private
Object lock;
private
final
static
Thread1Tasker instance =
new
Thread1Tasker();
public
final
static
Thread1Tasker getInstance(){
return
instance;
}
public
Thread1Tasker setLock(Object lock) {
this
.lock = lock;
return
this
;
}
@Override
public
void
start() {
MyThread1 t1 =
new
MyThread1(lock);
t1.start();
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public
class
Thread2Tasker
implements
ITask{
private
Object lock;
private
final
static
Thread2Tasker instance =
new
Thread2Tasker();
public
final
static
Thread2Tasker getInstance(){
return
instance;
}
public
Thread2Tasker setLock(Object lock) {
this
.lock = lock;
return
this
;
}
@Override
public
void
start() {
MyThread2 t2 =
new
MyThread2(lock);
t2.start();
}
}
|
main方法里调用任务：
|
1
2
3
4
5
6
7
8
9
|
public
class
Test3 {
public
static
void
main(String[] args)
throws
InterruptedException {
Object lock =
new
Object();
Thread1Tasker.getInstance().setLock(lock)
.start();
Thread2Tasker.getInstance().setLock(lock)
.start();
}
}
|
结果打印输出：
MyThread1 1516939281372
MyThread1 1516939281372
MyThread1 1516939281372
MyThread1 1516939281372
MyThread1 1516939281372
MyThread1 wait
MyThread2 1516939281374
MyThread2 1516939281374
MyThread2 1516939281374
MyThread2 1516939281374
MyThread2 1516939281374
MyThread2 wait
MyThread1 1516939281374
MyThread1 1516939281374
MyThread1 1516939281374
MyThread1 1516939281374
MyThread1 1516939281374
MyThread2 1516939281374
MyThread2 1516939281374
MyThread2 1516939281374
MyThread2 1516939281374
MyThread2 1516939281374
可以发现2个线程任务是交替执行的
本文转自屠夫章哥 51CTO博客，原文链接：http://blog.51cto.com/4259297/1965192，如需转载请自行联系原作者
