设计模式(一)之单例模式
饿汉式
- 类加载到内存后,就实例化一个单例对象,JVM保证线程安全
- 简单实用,推荐使用
- 唯一缺点:不管用到与否,类加载时完成实例化操作
第一种写法:
声明私有静态常量创建对象
private static final HungryPattern01 INSTANCE = new HungryPattern01();
private HungryPattern01() {
}
public static HungryPattern01 getInstance() {
return INSTANCE;
}
第二种写法:
在静态代码块中创建对象,并对私有静态常量进行赋值
private static final HungryPattern02 INSTANCE;
static {
INSTANCE = new HungryPattern02();
}
private HungryPattern02() {
}
public static HungryPattern02 getInstance() {
return INSTANCE;
}
懒汉式(Lazy Coding)
饿汉式不管实例对象有没有被用到,都会使用类加载完成实例化操作,懒汉式虽然达到了按需初始化的目的,但是却带来了线程不安全的问题。
第一种写法:
private static LazyPattern01 INSTANCE;
private LazyPattern01() {
}
public static LazyPattern01 getInstance() {
if (INSTANCE == null) {
return new LazyPattern01();
}
return INSTANCE;
}
为了体现出这种写法带来的线程不安全问题,为此我进行了简单的多线程测试。
private static LazyPattern01 INSTANCE;
private LazyPattern01() {
}
public static LazyPattern01 getInstance() {
if (INSTANCE == null) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new LazyPattern01();
}
return INSTANCE;
}
//测试方法
@Test
public void test03() {
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(LazyPattern01.getInstance().hashCode()))
.start();
}
}
第二种写法:
使用synchronized
关键字进行加锁,以同步方法的方式来实现线程安全,但这种方式往往效率比较低。
private static LazyPattern02 INSTANCE;
private LazyPattern02() {
}
public static synchronized LazyPattern02 getInstance() {
if (INSTANCE == null) {
INSTANCE = new LazyPattern02();
}
return INSTANCE;
}
第三种写法:
妄图通过同步代码块的方式提高效率,然而并不可行。
private static LazyPattern03 INSTANCE;
private LazyPattern03() {
}
public static LazyPattern03 getInstance() {
if (INSTANCE == null) {
synchronized (LazyPattern03.class) {
INSTANCE = new LazyPattern03();
}
}
return INSTANCE;
}
第四种写法:
在第三种写法的基础上,增加了双重判断。
private static volatile LazyPattern04 INSTANCE;
private LazyPattern04() {
}
public static LazyPattern04 getInstance() {
if (INSTANCE == null) {
synchronized (LazyPattern04.class) {
if (INSTANCE == null) {
INSTANCE = new LazyPattern04();
}
}
}
return INSTANCE;
}
第五种写法:
采用静态内部类方式,JVM保证单例,加载外部类时不会加载内部类,这样就可以实现懒加载。
private LazyPattern05() {
}
private static class LazyPattern05Holder {
private static final LazyPattern05 INSTANCE = new LazyPattern05();
}
public static LazyPattern05 getInstance() {
return LazyPattern05Holder.INSTANCE;
}
第六种写法:
《Effective Java》中推荐使用枚举实现单例模式,堪称最完美的单例写法。
不仅可以解决线程同步的问题,还可以防止反序列化。
public enum LazyPattern06 {
INSTANCE;
}