【发布时间】：2009-07-27 21:06:45
【问题描述】：
当你想让某个任务被另一个线程执行时，你可以扩展 Thread 或者实现 Runnable。
我尝试创建一个完全在第二个线程中运行一个类的类。
这意味着你可以调用anyMethod()，它立即返回并由第二个线程执行。
这是我的尝试：
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
/**
* Extend this class to run method calls asynchronously in the second thread implemented by this class.
* Create method(type1 param1, type2 param2, ...) and let it call this.enqueueVoidCall("method", param1, param2, ...)
*
* The thread executing the run-method will automatically call methodAsync with the specified parameters.
* To obtain the return-value, pass an implementation of AsyncCallback to this.enqueueCall().
* AsyncCallback.returnValue() will automatically be called upon completion of the methodAsync.
*
*/
public class ThreadedClass extends Thread {
private static Object test;
private Queue<String> queue_methods = new ConcurrentLinkedQueue<String>();
private Queue<Object[]> queue_params = new ConcurrentLinkedQueue<Object[]>();
private Queue<AsyncCallback<? extends Object>> queue_callback = new ConcurrentLinkedQueue<AsyncCallback<? extends Object>>();
private volatile boolean shutdown = false;
/**
* The run method required by Runnable. It manages the asynchronous calls placed to this class.
*/
@Override
public final void run() {
test = new Object();
while (!shutdown) {
if (!this.queue_methods.isEmpty()) {
String crtMethod = queue_methods.poll();
Object[] crtParamArr = queue_params.poll();
String methodName = crtMethod + "Async";
Method method;
try {
method = this.getClass().getMethod(methodName);
try {
Object retVal = method.invoke(this, crtParamArr);
AsyncCallback<? extends Object> crtCallback = queue_callback.poll();
crtCallback.returnValue(retVal);
} catch (Exception ex) {}
} catch (SecurityException ex) {
} catch (NoSuchMethodException ex) {}
} else {
try {
synchronized(test ) {
test.wait();
}
} catch (InterruptedException ex) {
System.out.println("READY");
} catch (Exception ex) {
System.out.println("READY, but " + ex.getMessage());
}
}
}
}
/**
* Asynchronously adds a method-call to the scheduler, specified by methodName with passed parameters
* @param methodName The name of the currently called method. methodName + "Async" is being called
* @param parameters Parameters you may want to pass to the method
*/
protected final void enqueueVoidCall(String methodName, Object... parameters) {
List<Object> tmpParam = new ArrayList<Object>();
for (Object crt : parameters) {
tmpParam.add(crt);
}
queue_methods.add(methodName);
queue_params.add(parameters);
queue_callback.add(null);
test.notifyAll();
}
/**
* Asynchronously adds a method-call to the scheduler, specified by methodName with passed parameters
* @param methodName The name of the currently called method. methodName + "Async" is being called
* @param callBack An instance of AsyncCallback whose returnValue-method is called upon completion of the task.
* @param parameters Parameters you may want to pass to the method
*/
protected final void enqueueCall(String methodName, AsyncCallback<? extends Object> callBack, Object... parameters) {
List<Object> tmpParam = new ArrayList<Object>();
for (Object crt : parameters) {
tmpParam.add(crt);
}
queue_methods.add(methodName);
queue_params.add(parameters);
queue_callback.add(callBack);
test.notifyAll();
}
/**
* Complete the currently running task, optionally return values and eventually shut down. The instance of this object becomes unusable after this call.
*/
public void shutdown() {
shutdown=true;
}
}
现在我有两个类来测试：
public class MySecondTask extends ThreadedClass {
public void test1() {
this.enqueueVoidCall("test1", null);
}
public void test1Async() {
System.out.println("Start");
try {
// do big job here
} catch (Exception ex) { }
System.out.println("Done");
}
}
以及启动这些东西的主要方法：
public class TestingClass {
public static void main(String[] args) {
MySecondTask test = new MySecondTask();
test.start();
System.out.println("1. Thread [1]");
// CORRECTION, SHOULD BE:
test.test1();
// INSTEAD OF:
// test.test1Async();
for(int q=0; q<=100000; q++) {
System.out.println("1:"+ new Date().getTime()+":"+ q);
if ((q % 1000) == 0) {
System.out.flush();
}
}
System.err.println("1. Thread [2]");
}
}
不知何故，第二个线程的输出总是首先出现（完全），然后其余的输出到控制台上。如果线程同时运行（这是预期的结果），控制台输出应该是混合的？！
感谢任何想法以及 cmets 以改进我的编码风格。
编辑：
引用的问题已经解决了。
现在我在调用的行上收到 IllegalMonitorStateException：ThreadedClass.notifyAll()。
也许我弄错了那个锁。
但是 a) 为什么需要在 wait() 周围使用 synchronized() 以及如何使 notifyAll() 调用解除阻塞 wait()？
提前致谢并致以最诚挚的问候
ps：你们都在堆栈溢出方面做得很好。你已经在不知不觉中帮助了我很多次，谢谢。继续加油！
【问题讨论】：
-
TestingClass.main() 中是否有错误？我没有看到它调用 test1() 的任何地方。
-
等一下，你从哪里得到这个：AsyncCallback 对象，它不是 Java 的一部分
标签： java multithreading concurrency