Question

我正在努力为下一次考试而学习练习。这是问题

使用Java实现一个包含（有限）集合的MsgBatcher类消息并根据请求批量发送。假设我们有一个带有方法void send（）的消息类。 MsgBatcher提供了一种方法 void enqueue（Message）向批处理添加新消息。它暂停了如果MsgBatcher已满（最大消息数），则调用者可以入队的是在MsgBatcher构造函数中提供的。一个方法void sendAll（）也用于发送排队的所有消息直到那一刻（它清空了MsgBatcher）。组织同步将处理发送消息的事实可能需要很长时间。可选：实现sendAll方法发送是异步执行的w.r.t.呼叫者（即，在单独的线程，应该在MsgBatcher创建时启动并重复用于每次发送。）

到目前为止，我写过这篇文章

import java.util.ArrayList;

public class MsgBatcher {

    public ArrayList<Message> batch = new ArrayList<Message>();
    int maxSpaces;

    public void MsgBatcher(int max){
        this.maxSpaces= max;
    }
    public synchronized void enqueue(Message m) throws InterruptedException{
        while(batch.size() == maxSpaces) wait();
        this.batch.add(m);
    }
    public void sendAll(){
        ArrayList<Message> toSend = new ArrayList<Message>();
        toSend.addAll(batch);
        batch.clear(); //in this way i can accept other messages while sending the others

        for (Message m : toSend){
            m.send();
        }
        batch.clear();
    }
}

由于Message类不是很重要，我只写了几行来模拟问题行为

public class Message {

 public void send(){
     System.out.println("Sending");
     try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
     System.out.println("Sent");
 }
}

我不明白的是如何处理

组织同步，以处理发送事实消息可能需要很长时间。

，特别是

可选：实现sendAll方法以便发送 w.r.t.异步执行呼叫者（即，在一个单独的线程，应该在MsgBatcher创建时启动并重用每次发送）。

根据这个问题的标题

我知道我应该问教授，我已经给他发了一封电子邮件，但他没有回答。谢谢你的帮助！

Answer 1

我认为您正在为PoliMi的dist sys准备考试中间件技术。

我也在做，我找到了你的问题，因为我正在做同样的练习。这是我的解决方案，似乎运作良好。

我发布了它，即使您不再需要它，以防其他人在准备此考试时需要。

import java.util.ArrayList;

public class TestThread extends Thread{

private String name;
private MsgBatcher msgBatcher;

public TestThread(String name, MsgBatcher msgBatcher){
    this.name = name;
    this.msgBatcher = msgBatcher;
}

/**
 * Each thread tries to add 10 messages.
 */
public void run(){
    for(int i = 0; i < 10; i++){
        Message msg = new Message("Thread " + this.name + " | i: " + i);
        try{
            System.out.println("[T] Thread " + this.name + " Adding " + i);
            this.msgBatcher.enqueue(msg);
            System.out.println("[T] Thread " + this.name + " Added " + i);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

public static void main(String[] args){
    MsgBatcher msgBatcher = new MsgBatcher(10);
    TestThread t1 = new TestThread("1", msgBatcher);
    TestThread t2 = new TestThread("2", msgBatcher);

    t1.start();
    t2.start();

    try{
        //After 3 seconds we try to send the first batch
        Thread.sleep(3000);
        msgBatcher.sendAll();
    }catch (Exception e){
        e.printStackTrace();
    }

}
}

class MsgSender extends Thread{

private ArrayList<Message> toSend;

public MsgSender(){
    this.toSend = new ArrayList<Message>();
}

public void run(){
    while(true){
        synchronized (this){
            try{
                System.out.println("[MS] Starting run.");
                while (this.toSend.size() == 0){
                    System.out.println("[MS] Waiting for messages." + this.toSend.size());
                    wait();
                }

                System.out.println("[MS] Messages ready to be sent.");

                for(Message msg: this.toSend){
                    msg.send();
                }

                this.toSend.clear();

                System.out.println("[MS] Messages sent.");

                notifyAll();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

public synchronized void addMsgs(ArrayList<Message> toSend){
    synchronized (this){
        try{
            System.out.println("[MS] Adding messages.");
            while (this.toSend.size() != 0){
                System.out.println("[MS] Adding messages. Waiting toSend to become empty");
                wait();
            }

            this.toSend = toSend;

            System.out.println("[MS] Messages added. Notifying the run."  + this.toSend.size());

            notifyAll();
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    this.toSend = toSend;

    notify();
}
}

class MsgBatcher{

private int size;
private ArrayList<Message> queue;
private MsgSender msgSender;

public MsgBatcher(int size){
    this.size = size;
    this.queue = new ArrayList<Message>(this.size);
    this.msgSender = new MsgSender();
    this.msgSender.start();
    try{
        //wait enough time to be sure the msgSender thread is ready
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
}

public synchronized void enqueue(Message msg) throws InterruptedException{
    System.out.println("[MB] size: " + this.queue.size());
    while(this.queue.size() == this.size){
        wait();
    }

    this.queue.add(msg);

    notifyAll();
}

public synchronized void sendAll(){
    System.out.println("Sending all messages");

    ArrayList<Message> toSend = new ArrayList<Message>();
    toSend.addAll(this.queue);

    this.msgSender.addMsgs(toSend);

    this.queue.clear();

    notifyAll();
}
}

class Message {

private String text;

public Message(String text){
    this.text = text;
}

public void send(){
    System.out.println("[M] Sending: " + this.text);
    try{
        Thread.sleep(1000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("[M] Sent: " + this.text);
}
}

如何在类的创建时启动线程并（重新）使用它多次执行方法

1 个答案: