编写一多线程程序，实现如下功能： (1)一个线程随机产生 100-5000 之间的整数，并计算所有已产生整数的 累加和，每次产生随机整数的时间随机间隔 100- 1000 毫秒； (2)另一个线程每隔 1 秒时间读取上个线程的计算等式和运算结果，并 在图形界面中实时显示。使用java编写，把完整代码发给我

好的，以下是一个简单的实现：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingUtilities;

public class RandomNumberDisplay extends JFrame {

    private static final long serialVersionUID = 1L;

    private List<Integer> data = new ArrayList<>();
    private int sum = 0;
    private Lock lock = new ReentrantLock();

    private JLabel label = new JLabel("Waiting for data...");

    public RandomNumberDisplay() {
        setTitle("Random Number Display");
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        add(label);
        pack();
        setLocationRelativeTo(null);
        setVisible(true);

        Thread randomThread = new Thread(new RandomNumberThread());
        Thread displayThread = new Thread(new DisplayThread());
        randomThread.start();
        displayThread.start();
    }

    private class RandomNumberThread implements Runnable {

        private Random random = new Random();
        private volatile boolean stopped = false;

        @Override
        public void run() {
            while (!stopped) {
                int number = random.nextInt(4901) + 100;
                lock.lock();
                sum += number;
                data.add(number);
                lock.unlock();
                try {
                    Thread.sleep(random.nextInt(901) + 100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public void stopThread() {
            stopped = true;
        }
    }

    private class DisplayThread implements Runnable {

        private volatile boolean stopped = false;

        @Override
        public void run() {
            while (!stopped) {
                lock.lock();
                if (!data.isEmpty()) {
                    int number = data.remove(0);
                    SwingUtilities.invokeLater(() -> label.setText(number + " + " + sum + " = " + (number + sum)));
                }
                lock.unlock();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public void stopThread() {
            stopped = true;
        }
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(RandomNumberDisplay::new);
    }

    @Override
    public void dispose() {
        super.dispose();
        for (Thread t : Thread.getAllStackTraces().keySet()) {
            if (t instanceof RandomNumberThread || t instanceof DisplayThread) {
                ((Runnable) t).stopThread();
            }
        }
    }
}

这个程序有两个线程，一个是随机数产生线程 `RandomNumberThread`，一个是显示线程 `DisplayThread`。`RandomNumberThread` 会在随机的时间间隔内产生一个随机整数，并将它加入累加和中，然后将这个整数和当前累加和作为一组数据加入一个列表中。`DisplayThread` 则每秒钟从这个列表中取出一组数据，并显示在图形界面中。

注意到这个程序中，我们使用了 `java.util.concurrent.locks.Lock` 来保护共享数据的访问。这是必要的，因为两个线程会同时访问 `data` 和 `sum`。我们还使用了 `volatile` 关键字来确保线程的可见性。我们还重写了 `dispose` 方法，在关闭窗口时停止两个线程。

最后，我们在 `main` 方法中使用 `SwingUtilities.invokeLater` 来启动程序。这是因为在 Java 中，图形界面应该在事件分发线程中更新，而不是在主线程中更新。