饿汉式

写法一：静态常量实现

/**

* @desc 饿汉式（静态常量）

*/

public class Singleton1 {

private Singleton1(){}

private static final Singleton1 instance = new Singleton1();

public static Singleton1 getInstance(){

return instance;

}

}

写法二：静态代码块实现

/**

* @desc 饿汉式(静态代码块)

*/

public class Singleton2 {

private Singleton2(){}

private static Singleton2 instance;

static {

instance = new Singleton2();

}

public static Singleton2 getInstance(){

return instance;

}

}

懒汉式

写法一：线程不安全

/**

* 懒汉式(线程不安全)

*/

public class Singleton3 {

private Singleton3(){}

private static Singleton3 instance;

public static Singleton3 getInstance(){

if(instance==null){

instance = new Singleton3();

}

return instance;

}

}

写法二：线程安全，效率低

/**

* @desc 懒汉式(线程安全,效率低)

*/

public class Singleton4 {

private Singleton4(){}

private static Singleton4 instance;

public static synchronized Singleton4 getInstance(){

if(instance==null){

instance = new Singleton4();

}

return instance;

}

}

写法三：线程安全，效率高

/**

* 懒汉式(线程安全，效率高)

*/

public class Singleton5 {

private Singleton5(){}

//多线程保证可见性

private static volatile Singleton5 instance;

//双重检查

public static Singleton5 getInstance(){

if(instance==null){

synchronized(Singleton5.class){

if(instance==null){

instance = new Singleton5();

}

}

}

return instance;

}

}

静态内部类实现

/**

* @desc 静态内部类实现

*/

public class Singleton6 {

private Singleton6(){}

//静态内部类

private static class SingletonInstance{

private static final Singleton6 INSTANCE = new Singleton6();

}

public static Singleton6 getInstance(){

return SingletonInstance.INSTANCE;

}

}

枚举类实现

/**

* @desc 枚举类实现

*/

public class Singleton7 {

private Singleton7(){}

private enum SingletonInstance{

INSTANCE;

private final Singleton7 singleton;

SingletonInstance(){

singleton = new Singleton7();

}

private Singleton7 getInstance(){

return singleton;

}

}

public static Singleton7 getInstance(){

return SingletonInstance.INSTANCE.getInstance();

}

}