设计模式笔记--单例
饿汉模式
// 它是在类加载的时候就立即初始化,并且创建单例对象
//优点:没有加任何的锁、执行效率比较高,
//在用户体验上来说,比懒汉式更好
//缺点:类加载的时候就初始化,不管你用还是不用,我都占着空间
//浪费了内存,有可能占着茅坑不拉屎
//绝对线程安全,在线程还没出现以前就是实例化了,不可能存在访问安全问题
public class Hungry {
private static final Hungry instance = new Hungry();
private Hungry() {
System.out.println(">>>>>create");
}
public static Hungry getInstance() {
return instance;
}
}
测试
public class Test implements Runnable {
public void run() {
Hungry.getInstance();
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(new Test()).start();
}
}
}
结果
>>>>>create
懒汉模式
1、线程安全类型:
public class LazyOne {
private static LazyOne LAZY_ONE;
private LazyOne() {
System.out.println(">>>>create LazyOne");
}
public static LazyOne getInstance() {
if (LAZY_ONE == null) {
LAZY_ONE = new LazyOne();
}
return LAZY_ONE;
}
}
结果:
>>>>create LazyOne
>>>>create LazyOne
2、同步类型
public class LazyTwo {
private static LazyTwo lazyTwo;
private LazyTwo() {
System.out.println(">>>>create LazyTwo");
}
public static LazyTwo getInstance() {
if (lazyTwo == null) {
synchronized (LazyTwo.class) {
if (lazyTwo == null) {
lazyTwo = new LazyTwo();
}
}
}
return lazyTwo;
}
}
结果:
>>>>create LazyTwo
3、使用静态内部类避免同步带来的性能消耗
public class LazyThree {
private static class LazyHolder {
private static final LazyThree lazy_three = new LazyThree();
}
private LazyThree() {
System.out.println(">>>>create LazyThree");
}
public static LazyThree getInstance() {
return LazyHolder.lazy_three;
}
}
结果:
>>>>create LazyThree