Java 使用 .wait(millis) 同步

Question

我有一个关于同步的"little problem"，这是我的场景（我对同步还不够了解，我还在学习）：（编辑）

        Thread work, progress;
        final Object myObject;
        work = new Thread(() -> {
            try {
                myObject.doSomething();
            } catch (IOException e) {e.printStackTrace();}
        });

        progress = new Thread(() -> {
            while (true) {
                System.out.println(myObject.progress());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    break;
                }
            }
        });

        work.setDaemon(true);
        progress.setDaemon(true);

        work.start();
        progress.start();

        work.join();
        progress.interrupt();
        progress.join();

        /*Other code*/

（编辑：可能已解决）

主要作业在WORK线程中完成，作业进度在PROGRESS线程中打印；

效果不错，但我想要更好的..."synchronization"：唯一的 'little' 问题是，如果我在 sleep 方法中放置 1 小时，也许工作已经完成并且必须等待 PROGRESS 线程终止的那 55 分钟...... 如何处理这种情况？我希望我的 PROGRESS 线程在作业完成时终止，而不是等待睡眠方法完成。我想我将不得不使用一些同步块，以及 .wait(millis) 调用而不是 .sleep(millis)... 有人可以帮我理解吗？谢谢！

Answer 1

也许您可能想要查看 Observer/Listener 模式。简而言之，您的 Observer 在收到订阅的 class 通知之前不会执行任何操作。

http://www.javaworld.com/article/2077258/learn-java/observer-and-observable.html

// Your observable class
import java.util.Observable;
public class ObservableValue extends Observable
{
    private int n = 0;
    public ObservableValue(int n)
    {
        this.n = n;
    }
    public void setValue(int n)
    {
        this.n = n;
        setChanged();
        notifyObservers();
    }
    public int getValue()
    {
        return n;
    }
}


// Your observer
import java.util.Observer;
import java.util.Observable;
public class TextObserver implements Observer {
    private ObservableValue ov = null;
    public TextObserver(ObservableValue ov) {
        this.ov = ov;
    }
    public void update(Observable obs, Object obj) {
        if (obs == ov) {
            System.out.println(ov.getValue());
        }
    }
}


public class Main {
    public Main() {
        ObservableValue ov = new ObservableValue(0);
        TextObserver to = new TextObserver(ov);
        ov.addObserver(to);
    }
    public static void main(String [] args) {
        Main m = new Main();
    }
}

可以在此处找到将观察者模式与多线程一起使用的示例： https://dzone.com/articles/the-observer-pattern-using-modern-java

解决这个问题的一个有趣的方法是使用 Reactive 原则。在此视频中可以看到快速演示和解释： https://www.youtube.com/watch?v=weWSYIUdX6c

Java 使用 .wait(millis) 同步

Java synchronization using .wait(millis)

java

multithreading

synchronization

wait