简单了解Java单例模式(Singleton)

http://c.biancheng.net/view/1338.html
https://www.cnblogs.com/zhucj-java/p/13534551.html
https://www.cnblogs.com/restartyang/articles/7770856.html
https://www.imooc.com/article/310708

单例模式定义

单例模式是指一个类只有一个实例，而且该类可以自己创建自己的实例。

单例模式的应用

1.在高并发的系统中生成单号要求唯一，可以将生成单号的实例写为单例模式
2.数据库中的连接池
3.枚举类
4.系统中的上下文
5.spring中@Autowired默认注入的是单例注入
6.spring中在需要@Autowired默认注入的是多例注入时可在需要注入的类加上@Scope(value="prototype")---prototype原型模式，每次获取Bean的时候会有一个新的实例

单例模式的优缺点

优点：

1.由于在系统内存中只存在一个对象，因此可以 节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。
2.单例模式设置全局访问点，可以优化和共享资源的访问。
3.避免对共享资源的多重占用。

缺点

1.单例模式没有接口，扩展困难，则除了修改原来的代码，没有第二种途径，违背开闭原则。

单例模式的实现

分为饿汉式和懒汉式、其中饿汉式在类被加载时就创建了实例、懒汉式在第一次调用时创建实例（在多线程下有线程安全问题）

饿汉式实现

/**
 * 单例模式-饿汉式
 * 饿汉式不管有没有调用getInstance()方法,都会预先在系统中创建一个静态对象
 * 饿汉式优点： 在多线程模式下是安全的
 * 缺点： 没有调用方法前就被加载，会占用内存
 */
public class BaJie extends JPanel {
    private static volatile BaJie instance = new BaJie();

    private BaJie(){
        JLabel j = new JLabel(new ImageIcon("src/main/resources/img/Bajie.jpg"));
        this.add(j);
    }
    public static BaJie getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        JFrame jf = new JFrame("饿汉式单例模式测试");
        jf.setLayout(new GridLayout(1, 2));
        Container contentPane = jf.getContentPane();
        BaJie baJie = BaJie.getInstance();
        contentPane.add(baJie);
        BaJie baJie2 = BaJie.getInstance();
        contentPane.add(baJie2);

        if(baJie == baJie2){
            System.out.println("他们是同一个人");
        } else {
            System.out.println("他们不是同一个人");
        }
        jf.pack();
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

运行结果：

他们是同一个人

懒汉式实现

为解决在多线程下不安全对创建实例的方法加锁synchronized

/**
 * 单例模式--懒汉式
 * 该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例
 * 懒汉式优点：只有调用方法才创建对象，不会占用内存
 * 缺点：在多线程模式下不安全
 */
public class President {

    private static volatile President instance = null;

    //private 避免类在外部被实例化
    private President(){
        System.out.println("生产一个美国总统");
    }

    /**
     * synchronized为解决多线程下懒汉式存在的线程安全问题
     * synchronized 给对象和方法或代码块加锁，使得同一时刻只有一个线程执行该代码
     * @return
     */
    public static synchronized President getInstance(){
        if (instance == null){
            instance = new President();
        } else {
            System.out.println("已有美国总统，不能再生产！");
        }
        return instance;
    }

    public void getName(){
        System.out.println("获得一个美国总统：特朗普");
    }

    public static void main(String[] args) {

        //线程1
        Thread thread1 = new Thread(){

            @Override
            public void run(){
                President d1 = President.getInstance();
                System.out.println(d1.hashCode());
            }
        };

        thread1.start();

        //线程2
        Thread thread2 = new Thread(){

            @Override
            public void run(){
                President d2 = President.getInstance();
                System.out.println(d2.hashCode());
            }
        };
        thread2.start();
        
        President d3 = President.getInstance();
        System.out.println(d3.hashCode());
    }
}

main执行结果：

生产一个美国总统
338093198
已有美国总统，不能再生产！
338093198
已有美国总统，不能再生产！
338093198

在多线程下通过加锁可以解决线程安全问题
如果不加synchronized执行结果为：

生产一个美国总统
生产一个美国总统
1587888397
已有美国总统，不能再生产！
1368198263
1587888397

产生了1587888397、1368198263两个实例

扩展为有限的多例模式Multitcm

生成指定个数的实例存到Map中，使用时随机取一个使用

有限的多例模式实现

/**
 * 多例模式Multitcm
 * 维护一个指定数量的对象池，当请求个数超过控制的总数时，开始循环重复使用
 */
public class DuoLi {
    private static int num = 4; //对象数量
    private static int count = 1; //对象序号
    private static Map map = new HashMap();
    static {
        for (int i=1; i<=num; i++){
            map.put(i, new DuoLi());
        }
    }

    private DuoLi(){

    }

    public static DuoLi getInstance(){
        DuoLi duoLi = map.get(count);
        System.out.println(String.format("我是第%s个实例", count));
        count++;
        if (count > num){
            count = 1;
        }
        return duoLi;
    }

    public static void main(String[] args) {
        for (int i=0; i<5; i++){
            DuoLi duoLi = DuoLi.getInstance();
            System.out.println(duoLi.hashCode());
        }
    }
}

执行结果为

我是第1个实例
1558600329
我是第2个实例
636718812
我是第3个实例
445051633
我是第4个实例
1051754451
我是第1个实例
1558600329

第五次取的对象为第一个实例

剩下的问题

已知类的创建方式有 new，反射、序列化、克隆
在单例模式由于构建方法被私有化不可通过new创建，那么反射、序列化、克隆是否可以创建第二个实例呢？
https://my.oschina.net/u/3568600/blog/1827375