用java写一个懒汉单例模式线程安全

代码示例如下：

public class LazySingleton {

    private static LazySingleton instance;

    private LazySingleton() {}

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

在这个懒汉模式的单例中，构造函数被声明为私有，确保只能通过getInstance()方法获取单例实例。在第一次调用getInstance()时，instance对象将被实例化。由于该方法使用了synchronized关键字，保证了线程安全。

相关问题

懒汉单例模式 java_Java懒汉式单例模式详解

懒汉式单例模式是指在需要使用对象的时候才进行创建，而不是一开始就创建。这种方式的好处是可以节省系统资源，但是需要注意线程安全问题。

在Java中实现懒汉式单例模式可以采用以下方式：

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

在上述代码中，使用了synchronized关键字来保证线程安全。但是这种方式在高并发环境下会导致性能问题。为了解决这个问题，可以采用双重检查锁定的方式。

public class Singleton {
    private static volatile Singleton instance = null;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

在上述代码中，使用了volatile关键字来保证instance对所有线程的可见性，同时采用双重检查锁定来保证线程安全和性能。

单例模式 线程安全 demo java

下面是一个线程安全的懒汉式单例模式的 Java 示例代码：

public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

在上面的代码中，我们使用了双重检查锁定来确保线程安全。当 instance 为 null 时，多个线程可能同时进入第一个 if 语句块中，但是只有一个线程能够获得 Singleton.class 的锁，进入第二个 if 语句块中创建实例。当第一个线程创建完实例并释放锁时，后续的线程就可以直接返回已经创建好的实例了。

注意，我们使用了 volatile 关键字来修饰 instance，保证多线程环境下的可见性。此外，双重检查锁定在 JDK1.5 之前可能会存在问题，因为 Java 的内存模型在 JDK1.5 之前没有明确规定，因此可能会出现指令重排序的问题。但是在 JDK1.5 及之后的版本中，双重检查锁定是可以正常工作的。