无法获取Java中线程之间的更新列表

我正在学习一些关于Java多线程的课程。我尝试（跟随讲师）将两个用户从ArrayList中读取的内容与一个制作人用一些基本输入填充的内容同步。但生产者给出第一个数字，消费者进入无限循环，因为它得到的是空列表。不知道如何强迫它得到正确的值

制作人：

    class MyProducer implements Runnable {
      private List<String> buffer;
      private String color;

    public MyProducer(List<String> buffer, String color) {
        this.buffer = buffer;
        this.color = color;
    }

    public void run() {
        Random random = new Random();
        String[] nums = {"1", "2", "3", "4", "5"};

        for(String num: nums) {
            try {
                System.out.println(color + "Adding..." + num);
                synchronized (buffer) {
                    buffer.add(num);
                    System.out.println(buffer);
                }

                Thread.sleep(random.nextInt(1000));
            } catch (InterruptedException e) {
                System.out.println("Producer was interrupted");
            }
        }
        System.out.println(color + "Adding EOF and exiting...");
        synchronized (buffer) {
            buffer.add(EOF);
        }
    }
}

类MyProducer实现可运行{
私有列表缓冲区；
私有字符串颜色；
公共MyProducer（列表缓冲区、字符串颜色）{
this.buffer=缓冲区；
这个颜色=颜色；
}
公开募捐{
随机=新随机（）；
字符串[]nums={“1”、“2”、“3”、“4”、“5”}；
用于（字符串编号：nums）{
试一试{
System.out.println（颜色+“添加…”+num）；
已同步（缓冲区）{
buffer.add（num）；
系统输出打印项次（缓冲区）；
}
Thread.sleep（random.nextInt（1000））；
}捕捉（中断异常e）{
System.out.println（“生产商被中断”）；
}
}
System.out.println（颜色+“添加EOF并退出…”）；
已同步（缓冲区）{
缓冲区添加（EOF）；
}
}
}

消费者：

    class MyConsumer implements Runnable {
      private List<String> buffer;
      private String color;

    public MyConsumer(List<String> buffer, String color) {
        this.buffer = buffer;
        this.color = color;
    }

    public void run() {
        synchronized (buffer) {
            while(true) {
                if (buffer.isEmpty()) {
                    continue;
                }
                System.out.println("Przejście między warunkami działa");
                if (buffer.get(0).equals(EOF)) {
                    System.out.println(color + "Exiting");
                    break;
                } else {
                    System.out.println(color + "Removed" + buffer.remove(0));
                }
            }
        }
    }
 }

类MyConsumer实现可运行{
私有列表缓冲区；
私有字符串颜色；
公共用户（列表缓冲区，字符串颜色）{
this.buffer=缓冲区；
这个颜色=颜色；
}
公开募捐{
已同步（缓冲区）{
while（true）{
if（buffer.isEmpty（））{
继续；
}
系统输出打印（“Przejście między warunkami działa”）；
if（buffer.get（0）.equals（EOF））{
系统输出打印项次（颜色+退出）；
打破
}否则{
System.out.println（颜色+“已删除”+缓冲区.remove（0））；
}
}
}
}
}

主要内容：

import java.util.ArrayList；
导入java.util.List；
导入java.util.Random；
导入静态com.siecz-k-.Main.EOF；
公共班机{
公共静态最终字符串EOF=“EOF”；
公共静态void main（字符串[]args）{
列表缓冲区=新的ArrayList（）；
MyProducer=新的MyProducer（缓冲区，ThreadColor.ANSI_-CYAN）；
MyConsumer consumer1=新的MyConsumer（缓冲区，ThreadColor.ANSI_PURPLE）；
MyConsumer consumer2=新的MyConsumer（缓冲区，ThreadColor.ANSI_RED）；
新线程（producer.start（）；
新线程（consumer1.start（）；
新线程（consumer2.start（）；
}
}

当缓冲区为空时，您需要休眠使用者线程。现在，如果缓冲区为空，您的使用者方法将进入无限循环。当缓冲区为空时，您需要休眠使用者线程。现在，如果缓冲区为空，您的使用者方法将进入无限循环。

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import static com.siecz-k-.Main.EOF;

public class Main {
    public static final String EOF = "EOF";

    public static void main(String[] args) {

        List<String> buffer = new ArrayList<>();
        MyProducer producer = new MyProducer(buffer, ThreadColor.ANSI_CYAN);
        MyConsumer consumer1 = new MyConsumer(buffer, ThreadColor.ANSI_PURPLE);
        MyConsumer consumer2 = new MyConsumer(buffer, ThreadColor.ANSI_RED);

        new Thread(producer).start();
        new Thread(consumer1).start();
        new Thread(consumer2).start();

    }
}