java单例模式过去里面的属性_快速理解Java中的六种单例模式

饿汉式(推荐)

package concurencyv2.chapter1;

public class SingletonV2 {

private static final SingletonV2 instance = new SingletonV2();

private SingletonV2() {}

public static SingletonV2 getInstance() {

return instance;

}

}

优点：初试化静态的instance创建一次。如果我们在Singleton类里面写一个静态的方法不需要创建实例，它仍然会早早的创建一次实例。而降低内存的使用率。

缺点：没有lazy loading的效果，从而降低内存的使用率。

单线程下

package concurencyv2.chapter1;

public class SingletonV1 {

private static SingletonV1 instance = null;

private SingletonV1() {}

public SingletonV1 getInstance() {

if(null == instance)

instance = new SingletonV1();

return SingletonV1.instance;

}

}

注解: Singleton的静态属性instance中，只有instance为null的时候才创建一个实例，构造函数私有，确保每次都只创建一个，避免重复创建。

缺点：4只在单线程的情况下正常运行，在多线程的情况下，就会出问题。例如：当两个线程同时运行到判断instance是否为空的if语句，并且instance确实没有创建好时，那么两个线程都会创建一个实例。

懒汉式

package concurencyv2.chapter1;

public class SingletonV3 {

private SingletonV3() {

}

private static SingletonV3 instance;

public synchronized static SingletonV3 getInstance() {

if(null == instance)

instance = new SingletonV3();

return SingletonV3.instance;

}

}

注解：在单线程的基础上加上了同步锁，使得在多线程的情况下可以用。例如：当两个线程同时想创建实例，由于在一个时刻只有一个线程能得到同步锁，当第一个线程加上锁以后，第二个线程只能等待。第一个线程发现实例没有创建，创建之。第一个线程释放同步锁，第二个线程才可以加上同步锁，执行下面的代码。由于第一个线程已经创建了实例，所以第二个线程不需要创建实例。保证在多线程的环境下也只有一个实例。

缺点：每次通过getInstance方法得到singleton实例的时候都有一个试图去获取同步锁的过程。而众所周知，加锁是很耗时的。能避免则避免。

double check

package concurencyv2.chapter1;

public class SingletonV4 {

private SingletonV4() {

}

private static SingletonV4 instance;

public static SingletonV4 getInstance() {

if(null == instance) {

synchronized (SingletonV4.class) {

if(null == instance)

instance = new SingletonV4();

}

}

return SingletonV4.instance;

}

}

注解：只有当instance为null时，需要获取同步锁，创建一次实例。当实例被创建，则无需试图加锁。

缺点: 可能会出现空指针异常，一个线程获取了同步锁，并且创建了，但是还没有完成初始化。 另外一个线程直接getInstace,因此这个线程可能获取到的对象，有些地方没有初始化完成，造成引用的空指针现象。

double check and add volatile (推荐)

package concurencyv2.chapter1;

public class SingletonV5 {

private SingletonV5() {

}

private static volatile SingletonV5 instance;

public static SingletonV5 getInstance() {

if(null == instance) {

synchronized (SingletonV5.class) {

if(null == instance)

instance = new SingletonV5();

}

}

return SingletonV5.instance;

}

}

优点：在instance上添加了volatile，使得每次执行读操作的时候保证写操作已经完成.

静态内部类 (推荐)

package concurencyv2.chapter1;

public class SingletonV6 {

private SingletonV6() {}

private static class SingletonHolder {

public static final SingletonV6 instance = new SingletonV6();

}

public SingletonV6 getInstance() {

return SingletonHolder.instance;

}

}

枚举enum

package concurencyv2.chapter1;

public class SingletonV7 {

private SingletonV7() {

}

private enum Singleton {

SINGLETON;

private SingletonV7 instance;

Singleton() {

instance = new SingletonV7();

}

}

public static SingletonV7 getInstance() {

return Singleton.SINGLETON.instance;

}

}

利用enum只初始化一次的特性，保证了线程安全性.