设计模式-单例模式

设计模式-单例模式

概念

单例模式（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();