java单例的几种实现方式

1.懒汉式

线程不安全，如果两个线程同时执行到了

if (instance == null) {//这一句判断都为真，紧接着就会创建两个实例

public class Singleton {
private static Singleton instance;
private Singleton (){}

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

线程安全的，每次调用方法都会对对象枷锁，非常影响性能

public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {  //对方法枷锁性能不高
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

线程安全的，double-check

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

2.饿汉式的，这种是借助jvm的特性来实现的，因为静态变量在类加载的时候就初始化完成了，所以不需要线程同步，缺点就是累加载时就完成了

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

3.静态内部类，jvm在调用getInstance()时才会进行类的初始化

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

4.通过枚举实现，枚举实例的创建时线程安全的，并且对序列化有保证

public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}

1.懒汉式

线程不安全，如果两个线程同时执行到了

if (instance == null) {//这一句判断都为真，紧接着就会创建两个实例

public class Singleton {
private static Singleton instance;
private Singleton (){}

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

线程安全的，每次调用方法都会对对象枷锁，非常影响性能

public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {  //对方法枷锁性能不高
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

线程安全的，double-check

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

2.饿汉式的，这种是借助jvm的特性来实现的，因为静态变量在类加载的时候就初始化完成了，所以不需要线程同步，缺点就是累加载时就完成了

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

3.静态内部类，jvm在调用getInstance()时才会进行类的初始化

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

4.通过枚举实现，枚举实例的创建时线程安全的，并且对序列化有保证

public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}