Java设计模式之单例设计模式

15.1.单例模式的介绍

单例即单个的实例

1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
2. 单例模式有两种方式：饿汉式 和 懒汉式

15.2.单例模式步骤：

1. 构造器私有化 ----- 防止外部直接 new 一个对象，造成创建多个对象
2. 类的内部创建对象
3. 向外暴露一个静态的公共方法

15.3.饿汉式

类加载到内存后，就实例化一个单例，JVM保证线程安全
唯一缺点：不管用到与否，类加载时就完成实例化，存在浪费资源的可能

1. 常用写法

public class Hungry_1 {
    private static final Hungry_1 INSTANCE = new Hungry_1();
//    构造方法私有化，不被外部实例出来
    private Hungry_1() {};
    public static Hungry_1 getInstance() {return INSTANCE;}

//    测试
    public static void main(String[] args) {
//        测试线程是否安全
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Hungry_1.getInstance().hashCode());
                }
            }).start();
        }
    }
}

运行结果：线程安全

2. 完美写法

public enum  Hungry_2 {

    INSTANCE;

    //    测试
    public static void main(String[] args) {
//        测试线程是否安全
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Hungry_2.INSTANCE.hashCode());
                }
            }).start();
        }
    }

}

运行结果：线程安全，还可以防止反序列化

在这里利用了 枚举 的特性，关于枚举，具体可以看 20.Java之枚举

15.4.懒汉式

使用时才创建对象，但要注意线程安全问题

1. 懒汉式-1.0：线程不安全

public class Lazy_1 {
    private static Lazy_1 INSTANCE;
    //    不被外部实例化
    private Lazy_1() {}

    public static Lazy_1 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Lazy_1();
        }
        return INSTANCE;
    }

    //    测试
    public static void main(String[] args) {
//        测试线程是否安全
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Lazy_1.getInstance().hashCode());
                }
            }).start();
        }
    }
}

运行结果：

因为在多线程的时候，可能都同时进入了if (INSTANCE == null) 这个条件里，所以创建了多个对象

2. 懒汉式-2.0：给当前类上锁 synchronized，线程安全，但是执行效率低

public class Lazy_2 {
    private static Lazy_2 INSTANCE;
    //    不被外部实例化
    private Lazy_2() {}

    public static synchronized Lazy_2 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Lazy_2();
        }
        return INSTANCE;
    }

    //    测试
    public static void main(String[] args) {
//        测试线程是否安全
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Lazy_2.getInstance().hashCode());
                }
            }).start();
        }
    }
}

运行结果：

关键字sychronized获得的锁都是对象锁,而不是代码块的锁.
所以代码中哪个线程先执行sychronized关键字的方法,哪个线程就持有这把锁
在静态方法上加锁synchronized 表示锁定.class类 类级别锁

3. 懒汉式-3.0：对锁进行改进，提升效率

public class Lazy_3 {
    private volatile static Lazy_3 INSTANCE;
    //    不被外部实例化
    private Lazy_3() {}

    public static Lazy_3 getInstance() {
        if (INSTANCE == null) {
            synchronized (Lazy_3.class) {
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Lazy_3();
                }
            }
        }
        return INSTANCE;
    }

    //    测试
    public static void main(String[] args) {
//        测试线程是否安全
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Lazy_3.getInstance().hashCode());
                }
            }).start();
        }
    }
}

运行结果：

这是方法级别的互斥锁，第一个if (INSTANCE == null)是当创建对象后直接返回，第二个if (INSTANCE == null)目的是当多线程都第一次调用该方法时，可能都同时进入了第一个null条件，这时有了互斥锁也没有用，因为还是会排着队创建对象，所以在进入互斥锁后，还要判断一次是否对象被实例化过
如果方法使用static修饰，默认锁对象：当前类.class，关于互斥锁和synchronized概念，可以看 37.Java之线程（单线程、多线程、并发、并行、继承 Thread 类、实现Runnable接口、线程的常用方法、线程的生命周期、线程的同步机制、互斥锁、线程的死锁与释放锁）
关于volatile关键字，是一个轻量型的同步机制，而synchronized是重量型的同步机制，可以使底层执行顺序一致

4. 懒汉式-4.0：完美解决方案，线程安全

public class Lazy_4 {
    //    不被外部实例化
    private Lazy_4() {};

    private static class LazyHolder {
        private final static Lazy_4 INSTANCE = new Lazy_4();
    }

    public static Lazy_4 getInstance() {
        return LazyHolder.INSTANCE;
    }

    //    测试
    public static void main(String[] args) {
//        测试线程是否安全
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Lazy_4.getInstance().hashCode());
                }
            }).start();
        }
    }
}

运行结果：

静态内部类方式，JVM保证单例，加载外部类时不会加载内部类，当多线程同时调用时，因为有final所以保证了只会创建一个对象
关于final可以看 16.Java之final关键字

15.5.饿汉式 与 懒汉式 区别

1. 二者最主要的区别在于创建对象的时机不同：
   饿汉式是在类加载时就创建了对象实例
   而懒汉式是在使用时才创建
2. 饿汉式不存在线程安全问题，懒汉式存在线程安全问题
3. 饿汉式存在浪费资源的可能，因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题
4. 在 javaSE 标准类中，java.lang.Runtime 就是经典的单例模式