从java线程中得到运算功效
副标题#e#
假如有任何的意见、品评或表彰:)，请给我来信[email protected]
java的线程是由Thread来实现的，一般我们建设线程举办一个巨大的运算，然后在主线程中对运算功效举办处理惩罚，可是Thread的run函数并没有返回值，那么我们运算出功效后，怎么通知其它线程呢，本文报告了几种返复书息的要领。
一。java线程的建设
要建设线程有两种步伐，一是担任Thread类，二是实现Runnable，然后将其通报给一个Thread的结构函数，实譬喻下（假设我们要在一个线程中计较1到10000的和）：
1。担任Thread：
public class AddThread extends Thread {
public void run() {
int result = 0;
for(int i = 1; i <= 10000; i++) {
result += i;
}
}
}
运行AddThread：
AddThread thread = new AddThread();
thread.start();
2。实现接口Runnable：
public class Add implements Runnable {
public void run() {
int result = 0;
for(int i = 1; i <= 10000; i++) {
result += i;
}
}
}
运行该线程： Thread thread = new Thread(new Add());
thread.start();
#p#副标题#e#
二、返回运算功效的要领
此刻我们启动这个加法线程后，需要从这个线程中获得运算的功效，譬喻我们要在主线程中对运算功效举办显示。那么我们怎么实现呢？下面就报告几种常见的要领，留意个中有一些是错误的要领
1。利用get要领（错误的）
我们可以在AddThread中插手一个getResult函数获得运算功效：
public class AddThread extends Thread {
private int result = 0;
public void run() {
for(int i = 0; i <= 10000; i++)
result += i;
}
public int getResult() {
return result;
}
}
/** 获得运算功效并显示在屏幕上
*/
public class Test {
public static void main(String[] args) {
AddThread thread = new AddThread();
thread.start();
System.out.println("result is " + thread.getResult());
}
}
获得的功效是: result is 0
因为这里主线程和addThread线程是同时运行，AddThread的运算还没有完成（甚至大概还没有开始），主线程就开始输出运算功效了，所以这种方法是错误的。
2。查询法（可行，但效率极低）
第二种要领是利用一个变量hasDone来暗示运算是否完成，假如hasDone为false的时候暗示运算尚未完成，不然暗示运算已经完成。主线程不绝查询这个变量，假如发明运算尚未完成，则进入轮回期待，不然输出运算功效。
public class AddThread extends Thread {
private int result = 0;
private boolean hasDone = false;
public void run() {
for(int i = 0; i <= 10000; i++)
result += i;
hasDone = true;
}
public boolean hasDone() {
return hasDone;
}
public int getResult() {
return result;
}
}
public class Test {
public static void main(String[] args) {
AddThread thread = new AddThread();
thread.start();
//假如运算没有完成，则轮回期待
while (!thread.hasDone()) {
try {
Thread.sleep(100);
}
catch (InterruptedException ex) {
}
}
if (thread.hasDone())
System.out.println("result is " + thread.getResult());
}
}
功效显示： result is 50005000
主线程中轮回查询运算的状态，假如运算没有完成，则主线程sleep100毫秒，然后继承查询，这种方法固然可行，但由于主线程轮回查询，耗损了大量的CPU时间，因此效率很低。
3。wait/notify方法（较好）
第三种要领利用wait/notify的形式，当运算没有竣事的时候，主线程进入睡眠状态，这时它不占用CPU，因此效率较高。
public class AddThread
extends Thread {
//在这个object上wait
private Object lock;
private int result = 0;
private boolean hasDone = false;
public AddThread(Object lock) {
this.lock = lock;
}
public void run() {
for (int i = 0; i <= 10000; i++)
result += i;
//运算竣事，通知期待的线程
synchronized(lock) {
hasDone = true;
lock.notifyAll();
}
}
public boolean hasDone() {
return hasDone;
}
public int getResult() {
return result;
}
}
//主线程
public class Test {
public static void main(String[] args) {
Object lock = new Object();
AddThread thread = new AddThread(lock);
thread.start();
synchronized(lock) {
while (!thread.hasDone()) {
try {
//当运算没有竣事，主线程进入睡眠状态，当addThread执行notifyAll时，会叫醒主线程
lock.wait();
}
catch (InterruptedException ex) {
}
}
}
if (thread.hasDone())
System.out.println("result is " + thread.getResult());
}
}
4。利用callback（较好）
#p#分页标题#e#
我以为这是最好的一种方法，当运算完成后，AddThread自动挪用功效处理惩罚类。将其扩展可以成为使多个listener对功效举办处理惩罚，这里用到了Observer模式，这种要领很简朴，不需要思量同步机制，详细实现如下：
//对功效举办处理惩罚的接口
public interface ResultProcessor {
public void process(int result);
}
public class AddThread extends Thread {
private ResultProcessor processor;
public AddThread(ResultProcessor processor) {
this.processor = processor;
}
public void run() {
int result = 0;
for(int i = 0; i <= 10000; i++) {
result += i;
}
//对功效举办处理惩罚
processor.process(result);
}
}
public class Test implements ResultProcessor {
public void process(int result) {
System.out.println("result is " + result);
}
public static void main(String[] args) {
Test test = new Test();
AddThread thread = new AddThread(test);
thread.start();
}
}
功效显示： result is 50005000
代码如上面，AddThread的结构函数传进一个功效处理惩罚类,当运算完成时，自动挪用这个类的处理惩罚函数对功效举办处理惩罚。较量起来，我以为这种要领最好。
