单例各种实现代码

单例各种实现代码

1. 懒汉式单例实现

```java
/**
 * 懒汉式单例
 */
public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
    }

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

2. 饿汉式单例实现

```java
/**
 * 饿汉式单例
 */
public class HungrySingleton {
    private static HungrySingleton instance = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return instance;
    }
}
```

3. 双重检查锁定实现

```java
/**
 * 双重检查锁定实现
 */
public class DoubleCheckLockSingleton {
    private volatile static DoubleCheckLockSingleton instance;

    private DoubleCheckLockSingleton() {
    }

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

4. 静态内部类实现

```java
/**
 * 静态内部类实现
 */
public class InnerClassSingleton {
    private InnerClassSingleton() {
    }

    private static class SingletonHolder {
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }

    public static InnerClassSingleton getInstance() {
        return SingletonHolder.instance;
    }
}
```

5. 枚举类单例实现

```java
/**
 * 枚举类单例实现
 */
public enum EnumSingleton {
    INSTANCE;

    public void doSomething() {
        // do something
    }
}
```

6. 容器单例实现

```java
/**
 * 容器单例实现
 */
public class ContainerSingleton {
    private static Map<String, Object> container = new ConcurrentHashMap<String, Object>();

    private ContainerSingleton() {
    }

    public static Object getInstance(String className) {
        Object instance = null;
        if (!container.containsKey(className)) {
            try {
                instance = Class.forName(className).getDeclaredConstructor().newInstance();
                container.put(className, instance);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return instance;
        } else {
            return container.get(className);
        }
    }
}

 

为什么懒汉式单例类成员是static的？

因为懒汉式单例类需要在类加载的时候就进行实例化，而类的静态成员变量会在类加载的时候进行初始化，所以把单例类的实例化对象定义为static类型能够保证在类加载的时候就进行实例化。

不是在getInstance时候实例化的吗？

getInstance方法会在类加载的时候就被JVM加载，保证其线程安全，如果不定义为static类型的话，getInstance方法在类加载的时候就不会被加载，等到调用getInstance才会加载，这样就不能保证线程安全了。

static是在类加载的时候实例化，不是在调用的时候实例化，所以把单例类的实例化对象定义为static类型能够保证在类加载的时候就进行实例化。

这些都是线程安全的吗？

上述所有的单例实现都是线程安全的，包括懒汉式单例、饿汉式单例、双重检查锁定实现、静态内部类实现、枚举类单例实现、容器单例实现，它们都是通过在getInstance方法上加synchronized关键字或者在类加载时初始化单例类的实例化对象来保证线程安全的。 懒汉式单例不是线程安全的吗？ 懒汉式单例的getInstance是通过加synchronized关键字来保证线程安全的，而不是在类加载时初始化单例类的实例化对象。 如果没加synchronized就是线程不安全的，也就是多线程操作的时候可能会出现多个实例的情况。 双重检查锁定实现是线程安全的吗？双重检查锁定实现是线程安全的，因为它使用了synchronized关键字来保证线程安全，并且它在实例化单例对象时使用了双重检查，确保多线程操作时只有一个线程能够实例化单例对象。静态内部类实现是线程安全的吗静态内部类实现是线程安全的，因为它在类加载时就已经实例化了一个静态内部类，而这个静态内部类只会被实例化一次，保证了单例类实例化对象的唯一性。类加载只会加载一次吗？类加载只会加载一次，一个类只会被类加载器加载一次，多次加载同一个类只会得到一个Class对象，但是如果类被卸载，可能会再次被加载。多线程情况下，类可能重复加载吗？在多线程情况下，类可能会被重复加载，因为多个线程可能会同时加载同一个类，但是只会得到一个Class对象，也就是说不会出现多个实例。 懒汉式单例会有线程安全问题吗？懒汉式单例如果没有加synchronized关键字就会有线程安全问题，因为多个线程可能会同时进入getInstance方法，而instance变量可能没有被初始化，从而导致多个线程得到不同的实例。静态内部类实现是线程安全的吗？静态内部类实现是线程安全的，因为它在类加载时就已经实例化了一个静态内部类，而这个静态内部类只会被实例化一次，保证了单例类实例化对象的唯一性。