Singelton模式与多线程

Question

我阅读了具有多线程的Sigelton模式，发现已实现的使用同步。

我的问题是我可以使用wait（） + notify（）或notifyall（）而不是同步？ 如果是，哪个更好地同步或witch（）+ notifyall（）???

Answer 1

方法等待和通知仅在同步方法/块中有意义。

尝试以下操作：

public static void main(String[] args) {

    Object monitor = new Object();

    try {
        monitor.wait();
    }
    catch (InterruptedException e) {
        e.printStackTrace();
    }
}

这将导致：

Exception in thread "main" java.lang.IllegalMonitorStateException
    at java.base/java.lang.Object.wait(Native Method)
    at java.base/java.lang.Object.wait(Object.java:328)

这是因为当前线程不拥有监视器。

现在尝试一下，您正在经营（尽管还不是一个非常有用的业务）：

public static void main(String[] args) {

    Object monitor = new Object();

    synchronized (monitor) {
        try {
            monitor.wait();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

该线程现在无限期地等待永远不会出现的通知。

现在尝试以下操作：

public static void main(String[] args) {

    Object monitor = new Object();

    Thread a = new Thread(() -> {
        try {
            System.out.printf("Thread %s Waiting for notification%n", Thread.currentThread().getId());
            synchronized (monitor) {
                monitor.wait();
            }
            System.out.printf("Thread %s Received notification%n", Thread.currentThread().getId());
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    Thread b = new Thread(() -> {
        try {
            System.out.printf("Thread %s Sleeping three seconds%n", Thread.currentThread().getId());
            Thread.sleep(3000);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf("Thread %s Sending notification%n", Thread.currentThread().getId());
        synchronized (monitor) {
            monitor.notify();
        }
    });

    a.start();
    b.start();
}

将A线程在监视器上同步并等待通知。
线B入睡三秒钟，然后在显示器上同步并通知。

示例输出：

Thread 14 Waiting for notification
Thread 15 Sleeping three seconds
Thread 15 Sending notification
Thread 14 Received notification

数字是我记录的线程ID，以清晰。

现在，您对单身人士的疑问。有几种方法可以执行一个类的实例。最常见的是，像Spring这样的框架在应用程序上下文中强制执行其Bean的单个实例。这是一种接受务实的方法。为了在类加载程序中执行单例，最好的方法是使用枚举，因为它避免了序列化问题，但通常是使用私有构造函数和静态实例字段来完成的。请注意，这种自我管理的单例被大多数人视为反塔。

单身人士通常仅在类加载程序中唯一。如果您在应用程序服务器上运行，可能会有多个类加载程序，因此您必须小心要在此上下文中要使用此Singleton的上下文。在这种情况下，最好避免单身人士，而是创建一个单独的可部署服务或存储库来保留数据。

如果您确实有单身人士并希望能够以线程安全的方式访问它，您将必须同步所有访问它。您不一定需要等待/通知此。例如：

static long start = System.currentTimeMillis();

public static void main(String[] args) {

    Object monitor = new Object();

    Thread a = new Thread(() -> {
        sleep(1000);
        log("before synchronized block");
        synchronized (monitor) {
            log("entered synchronized block");
            log("done");
        }
    });

    Thread b = new Thread(() -> {
        log("before synchronized block");
        synchronized (monitor) {
            log("entered synchronized block");
            sleep(3000);
            log("done");
        }
    });

    a.start();
    b.start();
}

private static void sleep(int millis) {
    try {
        log("sleeping for " + millis);
        Thread.sleep(millis);
    }
    catch (InterruptedException e) {
        e.printStackTrace();
    }
}

private static void log(String message) {
    System.out.printf("At %s thread %s %s%n", (System.currentTimeMillis() - start), Thread.currentThread().getId(), message);
}

示例输出：

At 2 thread 15 before synchronized block
At 14 thread 15 entered synchronized block
At 25 thread 14 sleeping for 1000
At 25 thread 15 sleeping for 3000
At 1038 thread 14 before synchronized block
At 3038 thread 15 done
At 3039 thread 14 entered synchronized block
At 3040 thread 14 done

仅通过使用同步，就可以将访问权限成为独家。只有当线程需要另一个线程的结果时，才能等待/通知才能发挥作用。

Answer 2

我可以使用wait（） + notify（）或notifyall（）而不是同步？

答案都是相同的，无论您是要实施单例还是实施其他任何东西。

否

同步是Java程序中的线程可以安全共享变量的机制。它提供了两件事：

1. 它在访问共享变量时会阻止线程从中互相干扰。

2. 它可以确保以可预测且及时的方式对其他线程的共享变量进行更新。

wait（），notify（）和notifyall（）是一种机制，一个线程可以通知其他线程已更改共享变量以某种特殊的方式。

wait（）或notify（）或 notifyall（）不要技术需要使用同步，但是Java语言设计师任意地添加了要求，以提醒您，如果您要通知其他有关共享变量的事物，或者即使您只能去 在另一个线程对它们所做的事情上，您将需要同步才能安全访问变量。