Обмен данными между потоками

 
 
 
Сообщения:1
Нет опыта в многопоточности. Подскажите как реализовать таку задачку?

Реализовать класс Player, который умеет отправлять и получать сообщения
Player1 должен отправить сообщение Player2 с текстом “test”
Player2 дополняет полученное сообщение счетчиком полученных сообщение
и отправляет обратно, Player1 отвечает аналогично
Программа должна корректно завершиться, если Player1 получит 15
сообщений

Попытки не увенчались успехом. Результаты разные при запусках, например
recieve message test0000000000000000000000000000000000001
recieve message test0000000000000000000000000000000000001
recieve message test000000000000000000000000000000000000002

import java.util.concurrent.atomic.AtomicInteger;

public class Player {

    String message;
    public AtomicInteger count = new AtomicInteger();

    public synchronized void recieveMessage() throws InterruptedException {
        while (this.message == null)
            this.wait();


        //this.message = message;
        count.incrementAndGet();
        System.out.println("recieve message " + this.message + count.get());

        this.message = null;
        this.notifyAll();
    }

    public synchronized String sendMessage(Player p, String message) throws InterruptedException {
        while (message == null)
            this.wait();

        this.message = message;
        p.message = message;
        this.notifyAll();

        return message + p.count.get();
    }
}

public class PlayerHandler  implements Runnable {
    private Player player;

    public PlayerHandler(Player player) {
        this.player = player;
    }

    @Override
    public void run() {
        try{

            while(true) {
                player.recieveMessage();

                Thread.sleep(1000);
            }
        }
        catch(Exception ex){
            System.out.println(ex.getMessage());
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Player player1 = new Player();
        new Thread(new PlayerHandler(player1)).start();

        Player player2 = new Player();
        new Thread(new PlayerHandler(player2)).start();

        String msg = "test";
        for (int i = 0; i < 10; i++)
        {
            msg = player1.sendMessage(player2, msg) + player2.count.get();
            msg = player2.sendMessage(player1, msg) + player1.count.get();
        }
    }
}
Изменен:27 июн 2018 16:54
 
 
Сообщения:721
для начала коммуникация между потоками делается через глобальный почтовый сервис.

public interface GMS
{
    static void sendMessage( ID id, Message message ); // в твоём случае это String id, String message
    static Message popMessage( ID id ); // return null if there is no message.
}



типичная fifo очередь, только для каждого ID своя. внутри Map<ID, List<Message>>. синхронизацию сделаешь вокруг добавления и удаления сообщений в списке.

дальше:

while (true)
{
    Message message = GMS.popMessage( this.myId );
    if( message == null )
        continue;
    count++;
    message.addCount(count);
    GMS.sendMessage( this.otherPlayerId, message );
}



у Player1 добавится еще отправка первого сообщения до цикла и проверка на 15 сообщений и выход в цикле.
 
 
Сообщения:1
https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Exchanger.html
 
Модераторы:Нет
Сейчас эту тему просматривают:Нет