目录
一、饿汉式
1、通过普通类实现
有漏洞的单例模式：
package com.wxl;
import java.io.Serializable;
public class Singleton1 implements Serializable {
private Singleton1(){
System.out.println("private Singleton1()");
}
private static final Singleton1 INSTANCE=new Singleton1();
public static Singleton1 getINSTANCE(){
return INSTANCE;
}
}
测试代码：
package com.wxl;
public class Test {
public static void main(String[] args) {
Singleton1 s1=Singleton1.getINSTANCE();
System.out.println(s1.toString());
Singleton1 s2=Singleton1.getINSTANCE();
System.out.println(s2.toString());
}
}
效果：可以看到hash值一致，的确是单例模式
?上面的代码仍然存在一定的问题，因为使用了Serializable，如果使用反射、反序列化依然可以被修改，再此优化后：
package com.wxl;
import java.io.Serializable;
public class Singleton1 implements Serializable {
private Singleton1(){
if(INSTANCE!=null){//应对反射创建对象
throw new RuntimeException("单例对象不可以重复创建");
}
System.out.println("private Singleton1()");
}
private static final Singleton1 INSTANCE=new Singleton1();
public static Singleton1 getINSTANCE(){
return INSTANCE;
}
public Object readResolve(){//应对反序列化
return INSTANCE;
}
}
即使是这样还是存在一个问题，对于unsafe破解也是无法预防的，目前并没有一个预防unsafe的方法。
2、枚举类单例模式
package com.wxl;
public enum Singleton2 {
INSTANCE;
Singleton2(){//枚举类里构造方法默认为private
System.out.println("private Singleton2()");
}
public static Singleton2 getInstance(){
return INSTANCE;
}
}
测试：
public class Test {
public static void main(String[] args) {
Singleton2 s1=Singleton2.getInstance();
System.out.println(s1.toString());
Singleton2 s2=Singleton2.getInstance();
System.out.println(s2.toString());
}
}
?可以看到构造了一次，是单例模式。
对于枚举类来说本省就可以防止反射和反序列化创建新对象，但对于unsafe还是无法预防。
总体来讲，推荐使用枚举类。
二、懒汉式
懒汉式需要考虑创建时线程安全。
1、普通懒汉式
package com.wxl;
import java.io.Serializable;
public class Singleton3 implements Serializable {
private static Singleton3 INSTANCE=null;
private Singleton3(){
System.out.println("private Singleton3");
}
//synchronized排队机制，相当于锁，避免多线程环境下的问题
public static synchronized Singleton3 getInstance(){
if(INSTANCE==null){
INSTANCE=new Singleton3();
}
return INSTANCE;
}
}
这种模式下由于加了并发锁，对于性能有很大的影响。
由此优化出了一下实现方式：DCL
2、双检懒汉式
package com.wxl;
import java.io.Serializable;
public class Singleton4 implements Serializable {
private static volatile Singleton4 INSTANCE=null;//volatile 可见性，有序性
private Singleton4(){
System.out.println("private Singleton4");
}
public static Singleton4 getInstance(){
if(INSTANCE==null){
synchronized (Singleton4.class){//只需要在创建并发时控制即可
if(INSTANCE==null){
INSTANCE=new Singleton4();
}
}
}
return INSTANCE;
}
}
优化后基本不会影响性能，而且多线程安全。
3、静态内部类实现（推荐）
通过静态内部类来实现：不仅保证线程安全，而且又有懒汉的特点（推荐使用）
package com.wxl;
import java.io.Serializable;
public class Singleton5 implements Serializable {
private Singleton5(){
System.out.println("private Singleton5");
}
private static class Holder{
static Singleton5 INSTANCE=new Singleton5();
}
public static Singleton5 getInstance(){
return Holder.INSTANCE;
}
}
