目录

一、饿汉式之静态常量1.1 实现步骤1.2 优缺点说明 二、饿汉式之静态代码块三、静态内部类四、枚举式五、懒汉式（线程不安全）六、懒汉式（线程安全）七、懒汉式（同步代码块）八、双重检查锁

一、饿汉式之静态常量

1.1 实现步骤

1. 私有化构造方法 2. 本类内部创建对象实例并私有化 3. 提供一个公开的静态方法返回实例对象，供外部访问

代码实现

public class Singleton implements Serializable { //1.构造器私有化 private Singleton(){} //2.本类内部创建对象实例 private static final Singleton instance = new Singleton(); //3.提供一个公有的静态方法，返回实例对象 public static Singleton getInstance(){ return instance; } private Object readResolve(){ return instance; } }

1.2 优缺点说明

1）优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。 2）缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。 3) 这种方式基于classloader机制避免了多线程的同步问题。不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到了lazy loading的效果。 4）并且这种方式对于反射和序列化都是不安全的。 反射 测试

我们可以看到通过反射获取构造方法之后我们可以new一个实例，这个实例和通过饿汉式得到的实例对象并不是同一个实例。

序列化 工具类

public class SerializeUtil { //将当前对象序列化到一个obj的文件中 public static void serialize(Object obj) { ObjectOutputStream output = null; try { File file = new File("obj"); output = new ObjectOutputStream(new FileOutputStream(file)); output.writeObject(obj); output.flush(); } catch (IOException e) { e.printStackTrace(); } finally { try { output.close(); } catch (IOException e) { e.printStackTrace(); } } } //把obj文件反序列化成一个对象 public static Object unzerialize() { ObjectInputStream input = null; try { File file = new File("obj"); input = new ObjectInputStream(new FileInputStream(file)); //读取 Object object = input.readObject(); return object; } catch (Exception e) { e.printStackTrace(); } finally { try { input.close(); } catch (IOException e) { e.printStackTrace(); } } return null; } }

测试

可以看到，我们先把对象序列化到obj文件中，然后又从obj文件中反序列化获取两个对象，这两个对象并不是同一个对象。出现这种情况的原因是静态的变量在序列化的时候是不会被保存的，那么在反序列化的时候就会重新生成实例，这样就破坏了单例。

解决序列化问题的方法是，我们在类中加一个方法，让这个方法最终返回这个实例对象。就像开始代码中的那个readResolve()方法就是解决了这种序列化的问题。

二、饿汉式之静态代码块

这种方式和第一种方式有点类似。

public class Singleton2 implements Serializable { private Singleton2() { } private static Singleton2 instance; static { instance = new Singleton2(); } public static Singleton2 getInstance() { return instance; } }

这种方式和第一种方式有些类似，只不过把实例化的过程放在了静态代码块中，也是在类装载的时候就执行静态代码块中的代码，初始化类的实例。优缺点和第一种是一样的。

三、静态内部类

public class Singleton3 { //私有化构造方法 private Singleton3(){} //在静态内部类里面创建实例 private static class SingletonHolder{ private static final Singleton3 instance = new Singleton3(); } //对外提供静态公开方法用于获取对象 public static Singleton3 getInstance(){ return SingletonHolder.instance; } }

在Singleton3装载的时候并不会装载静态内部类，只有当我们去调用getInstance()方法的时候才会去装载静态内部类，而在装载类的时候，因为JVM的一种保护机制（具体叫啥忘了），线程是安全的。所以这种方式是属于一种线程安全，并且不会造成多余浪费的方式。但是这种方式对反射和序列化也是不安全的。

四、枚举式

public enum Singleton4 { INSTANCE{ @Override protected void doSomething() { System.out.println("doSomething"); } }; protected abstract void doSomething(); }

枚举式是Java 1.5之后才出来的一种形式，用这种形式实现单例是很简单的，并且线程安全且对反射和反序列化都是安全的。是推荐使用的一种形式。

五、懒汉式（线程不安全）

public class Singleton5 implements Serializable { private static Singleton5 instance; private Singleton5(){} //提供一个静态公开的方法，当使用到该方法的时候才会去创建instance public static Singleton5 getInstance(){ if(instance==null){ instance = new Singleton5(); } return instance; } }

这种方式起到了懒加载的效果，但是只能在单线程下使用。在多线程情况下，一个线程进入了if(singleton == null)判断语句块，还未来的及往下执行，另一个线程也通过这个判断语句，这时便会产生多个实例。同时这种方式对于反射和反序列化也是不安全的

六、懒汉式（线程安全）

public class Singleton6 { private static Singleton6 instance; private Singleton6(){} //提供一个静态公开的方法，当使用到该方法的时候才会去创建instance public static synchronized Singleton6 getInstance(){ if(instance==null){ instance = new Singleton6(); } return instance; } }

与懒汉式的线程不安全相比用一个synchronized关键字实现了线程安全的问题，但同时也带了了效率低的问题。其他的问题也没有解决。

七、懒汉式（同步代码块）

public class Singleton7 { //提供私有静态类的成员属性(不初始化) private static Singleton7 instance = null; //私有构造方法 private Singleton7() { } //对外提供公有静态方法获取对象 public static Singleton7 getInstance() { //判断instance是否已经被初始化 if (instance == null) { synchronized(Singleton7.class){ if(instance==null){ instance = new Singleton7(); } } } return instance; } }

解决了线程安全但是效率不高

八、双重检查锁

public class Student5 { //提供私有静态类的成员属性(不初始化) private volatile static Student5 instance = null; //私有构造方法 private Student5() { } //对外提供公有静态方法获取对象 public static Student5 getInstance() { //判断instance是否已经被初始化 if (instance == null) { synchronized(Student5.class){ if(instance==null){ instance = new Student5(); } } } return instance; } }

这种方式是一种比较好的方式，刚开始的时候instance为null，加入两个线程a和b同时通过了第一个if判断，然后线程a先得到锁进入第二个if判断，创建了一个实例。线程b得到锁之后通过判断得到instance不为null，直接return。后续的线程再进来在第一个if那里就已经进不到if判断里面的同步代码块了。解决了线程频繁等待锁所带来的消耗。同时使用volatile关键字使得变量的值能够及时在主内存中刷新，保证了每个线程得到的instance的值都是最新的。