手写代码singleton的单例模式,要求线程安全

好的，下面是线程安全的单例模式的手写代码：

public class Singleton {

    private static Singleton instance;

    private Singleton() {}

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

在上面的代码中，我们使用了 synchronized 关键字来保证 getInstance() 方法的线程安全性。因为在多线程环境下，可能会有多个线程同时调用 getInstance() 方法，如果不加锁的话，可能会导致多个线程同时创建不同的实例，这样就不能保证单例的唯一性了。加上 synchronized 锁之后，每次只能有一个线程进入该方法，其他线程需要等待锁释放后才能进入，这样就能保证单例的唯一性了。

相关问题

你作为一个Java领域的专家，请完成以下任务：手写尽可能多的单例模式，线程安全不安全都可以

1. 饿汉式（线程安全）

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

2. 懒汉式（线程不安全）

public class Singleton {
    private static Singleton INSTANCE = null;
    private Singleton(){}
    public static Singleton getInstance(){
        if(INSTANCE == null){
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }
}

3. 懒汉式（线程安全，同步方法）

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

4. 懒汉式（线程安全，双重校验锁）

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;
    }
}

5. 静态内部类（线程安全）

public class Singleton {
    private Singleton(){}
    private static class SingletonHolder{
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

6. 枚举（线程安全）

public enum Singleton {
    INSTANCE;
    public void doSomething(){
        //...
    }
}

手写线程安全的单例模式

要手写一个线程安全的单例模式，可以使用懒汉式和双重检查锁定的方式来实现。懒汉式是指在需要使用单例对象时才去创建它，双重检查锁定则是为了保证在多线程环境下只有一个线程能够创建该对象。

以下是一个示例代码：

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;
    }
}

在这个示例中，我们使用了volatile关键字来确保instance变量在多线程环境下的可见性。在getInstance()方法中，首先检查instance是否为null，如果为null，则进入同步块。在同步块内部再次检查instance是否为null，这是为了防止多个线程同时通过了第一个检查，进入同步块后再创建多个实例的情况。如果instance仍然为null，才会创建一个新的Singleton实例并赋值给instance变量。

需要注意的是，双重检查锁定方式只在Java 5及以上版本才能保证正确性，因为在Java 5之前的版本中，volatile关键字的语义不够强大，可能会导致创建出多个实例。而在Java 5及以上版本中，通过volatile关键字能够确保instance变量的可见性，并且禁止指令重排序，从而保证线程安全。

以上是一种手写线程安全的单例模式的实现方式，通过使用双重检查锁定和volatile关键字，能够在多线程环境下保证只有一个实例被创建。<span class="em">1</span><span class="em">2</span><span class="em">3</span>
#### 引用[.reference_title]
- *1* *2* *3* [Java--设计模式之单例模式+保证线程安全的5种写法（懒、汉、内、双、枚）](https://blog.csdn.net/JustinQin/article/details/120668592)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"]
[ .reference_list ]