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

Question

I am trying to solve an exercise while studying for my next exam. This is the question

Use Java to implement a MsgBatcher class that holds a (finite) set of messages and sends them, on request, in batch. Suppose we have a Message class with a method void send(). MsgBatcher provides a method void enqueue(Message) to add a new message to the batch. It suspends the caller if the MsgBatcher is full (the maximum number of messages that can be enqueued is provided in the MsgBatcher constructor). A method void sendAll() is also provided to send all messages enqueued up to that moment (it empties the MsgBatcher). Organize synchronization that will take care of the fact that sending a message may take a long time. Optional: implement the sendAll method so that the sending is performed asynchronously wrt the caller (ie, in a separate thread, which should be started at MsgBatcher creation time and reused for each sending).

So far i have written this

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();
    }
}   

and since the Message class is not really important i have written just a few lines to emulate the asked behaviour

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");
 }
}

what i do not understand is how to deal with

Organize synchronization that will take care of the fact that sending a message may take a long time.

and especially with

Optional: implement the sendAll method so that the sending is performed asynchronously wrt the caller (ie, in a separate thread, which should be started at MsgBatcher creation time and reused for each sending).

as per title of this question

I know i should ask the Professor, and i have already sent him an email, but he did not answer. Thanks for your help!

Answer 1

I think you were preparing the exam Middleware technologies for dist sys at PoliMi.

I'm doing as well and I found your question because I'm doing the same exercise. This is my solution and it seems to work well.

I posted it, even if you don't probably need it anymore, in case someone else will need while preparing this exam.

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);
}
}