设计模式-单例模式

概念

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

优点

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。 

2、避免对资源的多重占用（比如写文件操作）。

缺点

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景

1、要求生产唯一序列号。 

2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。 

3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

例子

/** * 设计模式-单例模式 * * Created by laizhiyuan on 2017/6/13. */public class SinglePatternDemo {    /**     * Desc: 请原谅我的偷懒     *       方便编写，这里将连个例子作为SinglePatternDemo类成员进行演示     *       实际应该写两个类     */    /**     * 饿汉式     */    public static class HungrySingle{        private HungrySingle(){        }        private static HungrySingle single = new HungrySingle();        private static HungrySingle newInstance(){            return single;        }    }    /**     * 懒汉式     */    public static class LazySingle{        private static volatile Object lock = new Object();        private static int i = 1;        private LazySingle(){        }        private static LazySingle single = null;        /**         * 线程安全         *         * @return         */        private static LazySingle newSecurityInstance(){            /**             * 双重锁定             */           if (single == null){                synchronized (lock){                    if (single == null){                        System.out.println("第" + i++ + "次实例化");                        single = new LazySingle();                    }                }            }            return single;        }        /**         * 线程不安全         *         * @return         */        private static LazySingle newNotSecurityInstance(){            if (single == null){                System.out.println("第" + i++ + "次实例化");                single = new LazySingle();            }            return single;        }    }    /**     * 测试线程安全     */    private static class ThreadSecurity extends Thread{        @Override        public void run() {            Thread.yield();            SinglePatternDemo.LazySingle.newSecurityInstance();        }    }    /**     * 测试线程不安全     */    private static class ThreadNotSecurity extends Thread {        @Override        public void run() {            Thread.yield();            SinglePatternDemo.LazySingle.newNotSecurityInstance();        }    }    /**     * 测试     *     * @param args     */    public static void main(String[] args) {        /**         * 将其它两个注释，一个一个测试         */        //testIsEquest();        //testThreadSecurity();        /**         * 测试这个方法时多跑几次，就有结果了         */        testThreadNotSecurity();    }    /**     * 测试线程不安全     */    private static void testThreadNotSecurity(){        /**         * 1000条线程创建SinglePatternDemo.LazySingle对象         */        for (int i = 0; i < 1000; i++){            ThreadNotSecurity thread = new ThreadNotSecurity();            thread.start();        }    }    /**     * 测试线程安全     */    private static void testThreadSecurity(){        /**         * 1000条线程创建SinglePatternDemo.LazySingle对象         */        for (int i = 0; i < 1000; i++){            ThreadSecurity thread = new ThreadSecurity();            thread.start();        }    }    /**     * 测试是否单例     */    private static void testIsEquest(){        SinglePatternDemo.HungrySingle hungrySingle =                SinglePatternDemo.HungrySingle.newInstance();        SinglePatternDemo.HungrySingle hungrySingle2 =                SinglePatternDemo.HungrySingle.newInstance();        SinglePatternDemo.LazySingle lazySingle =                SinglePatternDemo.LazySingle.newSecurityInstance();        SinglePatternDemo.LazySingle lazySingle2 =                SinglePatternDemo.LazySingle.newSecurityInstance();        System.out.println(hungrySingle == hungrySingle2);        System.out.println(lazySingle == lazySingle2);    }}

控制台输出

testIsEquest();

testThreadSecurity();

testThreadNotSecurity();