java - 尝试通知线程已使用 Exchanger 创建对象会导致两个线程都被锁定

Question

最初的想法是在创建对象时通知另一个线程，以便它可以使用它，我决定使用 Exchanger 通过直接发送对象来实现此目的。一个线程传递该对象，接收者发送 null ，但两个线程最终都被锁定。

这是我的代码的简化版本:

import java.util.concurrent.Exchanger;

public class Intercambiador {
    private Exchanger<Carta> ex = new Exchanger<>();

    public void intercambiar1(){
        while(true){
            Carta c = new Carta((int)(Math.random()*10));
            System.out.println("intercambiador 1 creates the object " + c.getNum());
            try {
               ex.exchange(c);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("intercambiador 1 sleeps");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void intercambiar2(){
        while(true) {
            Carta c = new Carta(-1);
            System.out.println("intercambiador 2 wants to receive an object");
            try {
                c = ex.exchange(null);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("intercambiador 2 receives the object " + c.getNum());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

其中一个线程执行方法 intercambiar1()另一个执行 intercambiar2() 。类(class)Carta只包含一个数字(随机生成，因为它并不重要)、构造函数、getter 和 setter。

创建线程的主类如下所示:

public class Main {
    public static void main(String[] args) {
        Intercambiador i1 = new Intercambiador();
        Intercambiador i2 = new Intercambiador();

        new Thread(()->i1.intercambiar1()).start();
        new Thread(()->i2.intercambiar2()).start();
    }
}

此代码生成的输出如下:

intercambiador 2 wants to receive an object
intercambiador 1 creates the object 2

程序仍在运行，因此我假设两个线程都已锁定。我处理这个问题的方式有什么问题吗？

我也尝试过使用 wait()和notify() ，像这样:

public class Intercambiador {
    private final Object lock = new Object();


    private void send(Carta c){
        synchronized (lock){
            Main.queue.offer(c);
            lock.notify();
        }
    }

    private Carta receive(){
        synchronized (lock){
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return Main.queue.peek();
    }

    public void intercambiar1(){
        while(true){
            Carta c = new Carta((int)(Math.random()*10));
            System.out.println("intercambiador 1 creates the object " + c.getNum());
            send(c);
            System.out.println("intercambiador 1 has sent an object");

            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void intercambiar2(){
        while(true) {
            Carta c = new Carta(-1);
            System.out.println("intercambiador 2 wants to receive an object");
            c = receive();
            System.out.println("intercambiador 2 recibe la carta " + c.getNum());

            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Main类(class)现在有一个 public static BlockingQueue<Carta> queue ，这是对象在创建时添加的位置，以便其他线程可以访问它。

输出如下所示:

intercambiador 2 wants to receive an object
intercambiador 1 creates the object 4
intercambiador 1 has sent an object
intercambiador 1 creates the object 0
intercambiador 1 has sent an object
intercambiador 1 creates the object 5
intercambiador 1 has sent an object
intercambiador 1 creates the object 7
intercambiador 1 has sent an object

执行不会停止，所以我假设 notify()函数未正确通知，因为执行 wait() 的线程仍然被阻止。我用notify()而不是notifyAll()因为这个想法是它只唤醒一个线程，而不是所有已执行 wait() 的线程。在同一个对象上(这是强制性的)。

另外，我必须指出，我已经显式创建了对象 lock因为，正如我所说，这是更大问题的简化，我必须这样做 3 次，并且每次都在不同的线程之间进行。还会有多个线程执行 intercambiar1()和intercambiar2() future 。

这个问题的要点是，一个线程在创建对象时必须通知另一个线程。这看起来像是经典的生产者-消费者问题，但我似乎无法弄清楚。任何帮助将不胜感激。

Answer 1

不，您有两个 Intercambiador 对象，它们与自己的 Exchanger 一起工作，因此它们永远不会相遇。

测试的简短修复是

将单个静态:

static private Exchanger<Carta> ex = new Exchanger<>();

或者创建单个对象:

Intercambiador i = new Intercambiador();
//Intercambiador i2 = new Intercambiador();

new Thread(()->i.intercambiar1()).start();
new Thread(()->i.intercambiar2()).start();

长修复将在外部创建一个Exchanger，并将其作为参数传递，例如

Exchanger<Carta> exchanger = new Exchanger<>();
Intercambiador i1 = new Intercambiador(exchanger);
Intercambiador i2 = new Intercambiador(exchanger);

new Thread(()->i1.intercambiar1()).start();
new Thread(()->i2.intercambiar2()).start();

(当然还要为 Intercambiador 创建必要的构造函数)