如何用JAVA实现异步信息处理

Question

要求，有多个模块会给一个专门接受消息的模块发消息
这个模块有一个list接受这些个消息，
然后有一个进程专门循环这个list处理这个消息。（比如打印出来）应该怎么实现比较好，
我关键不会起进程。
另外，比如说好长时间没有接受消息，
等来新的消息的时候怎么唤醒处理消息的进程。
求高手指点12.。。

Answer 1

我在想，addtolist这个函数如果能唤醒处理消息的进程，岂不是甚好！？？

Answer 2

重新启动一个java程序就启动了一个进程
可以用操作系统命令行启动 Runtime.getRuntime().exec("java -classpath . XXX");进程间通信的东西没弄过

Answer 3

    可不可以在接收消息的模块中的addtolist函数中添加一个专门的处理函数，函数执行时先向list中添加消息，然后探测当前有没有处理线程，如果没有，则启动线程。

Answer 4

一个进程专门循环这个list处理这个消息。是进程还是线程？进程间共享数据，你的list不是直接就能访问的，所以估计LZ说的是线程如果LZ想省点工作，可以用BlockingQueue来代替你的list，这样线程等待和唤醒不用你自己写代码实现了，如果非要用list，那么就自己做好同步list的小例子，LZ自己参考发挥吧
class MessageConsumer extends Thead {
    private List<YourMessageType> list;
    private boolean running = true;
    public MessageConsumer(List<YourMessageType> list) {this.list = list;}    public void run() {
        while (running) {
            YourMessageType msg = null; 
            try {
                synchronized(list) {
                    while (list.size() == 0) {
                        list.wait();
                    }
                    msg = list.remove(0);
                    list.notiryAll();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }            if (msg == null) continue;            //System.out.println(msg); //print message
        }
    }
}//调用sample
class ShareModule {
    List<YourMessageType> list = new ArrayList<YourMessageType>();
    ...
}public class Main {
    public static void main(String[] args) {
        ShareMudule sm; //so on        ...        Thread t = new MessageConsumer(sm.list);
        t.start();        ...
    }
}

Answer 5

为什么不用xian程，而用进程呢?

Answer 6

既然是 web 程序 用quartz 轮询不是挺好么。

Answer 7

昨晚太累了，没弄出来一会儿继续。。
谁还有想法，show一下么·········

Answer 8

如果要用专门的模块接收消息，这个模块应该是阻塞式地等待消息，这样就没有唤醒不唤醒的问题
对所接收到的消息可以考虑先进行队列化处理，便于管理，集中写入列表，当然要同步好，否则可能会产生数据安全问题（比如同时往列表中一个位置写数据，先写的数据可能就会丢失，不过还没证实过）。
List list = Collections.synchronizedList(new ArrayList(...));

Answer 9

quartz没用过吗， 定时器轮询处理。还有一种方式， 利用spring aop 。在发送消息的 service上创建一个切入点， 处理发送消息后时间。 也可以到达类似“唤醒线程”的功能。

Answer 10

我说的太不清楚了吧，楼上的可能都没懂我的意思。
Class Message---->我定义的messageClass MessageReceive---->我定义的接受Message的类，里面有一个方法
addMessage(Message message)
    list.add(message);Class MessageHanndle---->我定义的处理Message的类，
while（list is not NULL）
{
    handle message;
    list.remove(message);
}大概意思就是上面这个意思，
要求如下：
addMessag为public void形式的
这样，只要这个message进入我的list就OK了，
不会阻塞后面message进入。MessageHanndle的main（）函数一直在循环MessageList，
list里有东西就处理，肯定是没问题的，
一旦某个空闲时间段没处理，
停下来之后，
那边addMessage怎么唤醒MessageHanndle是我的问题。
不知道这样描述各位大侠能看懂了不？

Answer 11

addMessage里也要做同步处理
addMessage(Message message) {
    synchronized(list) {
        list.add(message);
        list.notifyAll(); //在这里唤醒其他线程
    }
}之前我也说过了，用BlockingQueue来做的话，可以省去线程的等待和唤醒的控制，内部都帮你实现了
如果非要用list，那么就像我给你的例子一样，在add消息和remove消息的时候，都要同步，分别唤醒对方另，LZ可以把list封装，这样，MessageReceive和MessageHanndle只需要调用封装好的方法，不需要管list的等待或唤醒
如class MessagePool<T> {
    List<T> pool = new ArrayList<T>();    public void addMessage(T msg) {
        synchronized(pool) {
            pool.add(msg);
            pool.notifyAll();
        }
    }    public T takeMessage() {
        T msg = null;
        synchronized (pool) {
            while (pool.size() == 0) {
                pool.wait();
            }
            msg = pool.remove(0);
            pool.notifyAll();
        }        return msg;
    }
}//这样，你创建一个消息池对象，
//MessageReceive只需要调用addMessage方法，
//MessageHanndle只需调用takeMessage方法就可以，不比管wait和notify的细节
MessagePool<Message> pool = new MessagePool<Message>();
...
class MessageReceive {
    ...
    addMessage(Message msg) {
        pool.addMessage(msg);
    }
}class MessageHanndle {
    ...
    while（pool != null）{
        Message messge = pool.takeMessage();
        handle message;
    }
}

Answer 12

BlockingQueue我看了下，实在是不熟悉，我怕后面难维护，所以放弃了。
这个项目不是我一个人在做，呵呵。
你说的我都明白了，正在弄，
你能再给我说说MessageHanndle怎么处理吗？以前没做过线程之类的东西，连起个线程怎么弄都不知道，
见笑了

Answer 13

有很多方法，比如下面循环，也可以通过重新启动线程的方式，即List中空了，结束线程，又有消息了，重启线程让其工作。
while(true){
    if(list.containsMessage()){
        doHandle();
    }
    Thread.sleep();
}

Answer 14

ArrayBlockingQueue 的put,take确实挺方便，容器空了，满了，子线程都会等。
还带唤醒功能。