单例模式的那些事

写在前面

  单例Singleton设计模式, 老生常谈的一个设计模式。但你真的用对了么? 用的姿势很重要!

1.概念解释

  单例顾名思义就是只产生一个实例对象。那怎样保证单一呢?把目标类提供给外部创建实例对象的能力收回,即构造函数设为私有,然后内部提供一个生成实例静态方法。设计成单例模式, 有各种各样的实现方式。

2.单例模式的设计

2.1 饿汉式单例

  饿汉式单例是指在方法调用前,实例就已经创建好了。

-实现代码:

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {

    }

    public static Singleton getInstance() {

        return instance;
    }
}

-验证高并发下的执行情况

public class SingletonClient {

    public static void main(String[] args) throws InterruptedException {

        Thread[] threads = new Thread[10];

        for (int i = 0; i < 10; i++) {

            final Singleton instance = Singleton.getInstance();

            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(instance.hashCode());
                }
            });
        }

        for (Thread thread : threads) {
            thread.start();
        }
    }
}
  • 结果
165827088
165827088
165827088
165827088
165827088
165827088
165827088
165827088
165827088
165827088

2.2 懒汉式单例

懒汉式单例是指在方法调用获取实例时才创建实例,因为相对饿汉式显得“不急迫”,所以被叫做“懒汉模式”。

1)单线程的懒汉式单例 -- 初学者最容易犯错的写法.

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {

    }

    public static Singleton getInstance() {

        if (instance == null) {

            try {
                // 刻意模仿多线程访问下创建实例不是单一的情况
                Thread.sleep(100); 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            instance = new Singleton();
        }
        return instance;
    }
}


上面创建单例在单线程下是木问题的。但在多线程访问下就会有问题啦。
如何改进呢?来,再往下看

2)线程安全的懒汉式单例.

-同步方法锁定
  同步方法效率很低, 它把真个方法都加了锁, 在高并发下, 只允许一个线程进入到该方法

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {

    }

    public synchronized static Singleton getInstance() {

        if (instance == null) {

            instance = new Singleton();
        }
        return instance;
    }
}

-同步代码块锁定
  同步代码块效率也很低,但比同步方法效率高点, 它把高并发的代码块加了锁, 在高并发下, 只允许一个线程进入到该代码块。

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {

    }

    public static Singleton getInstance() {

        try {

            synchronized (Singleton.class) {

                if (instance == null) {

                    Thread.sleep(100);

                    instance = new Singleton();
                }
            }
        } catch (Exception e) {

        }
        return instance;
    }
}

-双检查锁机制(推荐
这种方式不仅能保证线性安全, 还能提高效率。因为volatile关键字保证多线程间的可见性;在同步块中使用二次检查,以保证其不被重复实例化。集合其二者,这种实现方式既保证了其高效性,也保证了其线程安全性。

public class Singleton {

    // volatile 关键词修饰
    volatile private static Singleton instance = null;

    private Singleton() {

    }

    public static Singleton getInstance() {

        try {

            if (instance == null) {

                synchronized (Singleton.class) {

                    Thread.sleep(100);

                    instance = new Singleton();
                }
            }
        } catch (Exception e) {

        }
        return instance;
    }
}

3)使用静态内置类实现单例模式.

public class Singleton {

    private Singleton() {

    }

    private static class SingletonHandler {

        private static Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {

        return SingletonHandler.instance;
    }
}

4)使用静态代码块实现单例模式

public class Singleton {

    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    private Singleton() {

    }


    public static Singleton getInstance() {

        return instance;
    }
}

写在后面

新博客

posted @ 2017-06-20 20:44  坚守一辈子的幸福  阅读(253)  评论(0编辑  收藏  举报