Java：生产者-消费者两个线程停止工作，冻结

我有一段代码，它从第一个数组中获取数据并将其放入第二个数组，然后将其从第一个数组中删除。它可以正常工作一段时间，但在第一个数组中仍有要粘贴的值时停止：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main  {
    private static String buffer;
    private static String lock = "lock";

    public static void main(String[] args) throws  Exception  {
        Usb usb1 = new Usb(getListFromValues("1", "2", "3", "4", "5"));
        Usb usb2 = new Usb(getListFromValues("10", "20", "30", "40", "50"));

        Thread usbCutThread = new Thread(new UsbCutThread(usb1));
        Thread usbPasteThread = new Thread(new UsbPasteThread(usb2));

        usbCutThread.start();
        usbPasteThread.start();

        usbCutThread.join();
        usbPasteThread.join();

    }

    static class UsbCutThread implements Runnable  {
      private Usb usb;
      public UsbCutThread(Usb usb)  {this.usb = usb;}

      @Override
      public void run() {
          try {
              System.out.println("inside cut");
              for (int i = 0; i < usb.getData().size(); i++) {
                  buffer = usb.getValue();
                  System.out.println("cutting value " + buffer);

                  synchronized (lock) {
                      System.out.println("copied to buffer, waiting for paste");
                      lock.notify();
                      try {
                          lock.wait();
                      } catch (Exception e) {
                          e.printStackTrace();
                      }
                      System.out.println("erasing");
                      usb.eraseValue();
                  }
              }
          }
        catch (Exception e)  {
              e.printStackTrace();
        }
      }
    }

    static class UsbPasteThread implements Runnable  {
        private Usb usb;
        public UsbPasteThread(Usb usb)  {this.usb = usb;}

        @Override
        public void run() {
            try {
                while (true) {
                    System.out.println("inside paste");
                    //while it copies, cut thread can't erase - what if copy fails
                    synchronized (lock) {
                        usb.addValue("stuff");
                        System.out.println("pasted");
                        lock.notify();
                        try {
                            lock.wait();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }

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

    }

    static class Usb  {
      List<String> data = new ArrayList<>();

      public Usb(List<String> data)  {this.data = data;}

        public String getValue()  {return data.get(data.size() - 1);}

        public void addValue(String value)  {
          data.add(value);
        }

        public void eraseValue()  {
          data.remove(data.size() - 1);
        }

        public List<String> getData()  {return data;}
    }

    public static ArrayList<String> getListFromValues(String... values)  {
        ArrayList<String> result = new ArrayList<>();
        for (String v: values)  {
            result.add(v);
        }
        return result;
    }
}

UsbCutThread从0迭代到usb.getData.size：

对于int i=0；i 另一个线程进入lock.wait，因为您已经将整个过程设置为true。这里是您的程序不会终止的地方

要解决第一个问题，只需迭代到一个固定的限制：

int n=usb.getData.size； 对于int i=0；i

inside cut
inside paste
pasted
cutting value 5
copied to buffer, waiting for paste
inside paste
pasted
erasing
cutting value 4
copied to buffer, waiting for paste
inside paste
pasted
erasing
cutting value 3
copied to buffer, waiting for paste
inside paste
pasted
erasing