设计模式笔记--单例

饿汉模式

// 它是在类加载的时候就立即初始化，并且创建单例对象

    //优点：没有加任何的锁、执行效率比较高，
    //在用户体验上来说，比懒汉式更好

    //缺点：类加载的时候就初始化，不管你用还是不用，我都占着空间
    //浪费了内存，有可能占着茅坑不拉屎

    //绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题
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