Java:类完全在第二个线程/ IllegalMonitorStateException中运行

Question

当您希望某个任务由另一个线程执行时,您可以扩展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]");
}

}

不知何故,第二个线程的输出总是首先(完全)出现,然后其余部分出现在控制台上.如果线程同时运行(这是预期的结果),控制台输出应该混合？!

任何想法以及评论,以改善我的编码风格.

---

编辑:

引用的问题已经完全解决了.

现在我在我调用的行上收到一个IllegalMonitorStateException:ThreadedClass.notifyAll().

也许我把那个锁错了.

但是a)为什么需要在wait()周围使用synchronized()以及如何调用notifyAll() - 调用unblock wait()？

---

在此先感谢和最诚挚的问候

ps:你们都在堆栈溢出方面做得很好.你已经多次帮助了我,不知道它,谢谢你.保持!

Answer 1

这意味着你可以调用anyMethod(),它立即返回,由第二个线程执行.

这听起来像是在使用callables,期货和执行者:

• http://java.sun.com/docs/books/tutorial/essential/concurrency/pools.html
• http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/Callable.html
• http://java.sun.com/javase/6/docs/api/java/util/concurrent/ExecutorService.html
• http://java.sun.com/javase/6/docs/api/java/util/concurrent/Future.html

讨厌打破它,但你可能真的想看看这些东西..

编辑以解决以下评论

只需在对象中创建方法如下所示:

private ExecutorService executorService = Executors.newCachedThreadPool();

public Future<SomeObject> yourMethodName(String anyArguments) {
    return executorService.submit(
        new Callable<SomeObject>() {
            public SomeObject call() {
                SomeObject obj = new SomeObject();
                /* Your Code Here*/;
                return obj;
            }
        }
    );
}