关于java:单利模式与多线程

我是阿福，公众号「JavaClub」作者，一个在后端技术路上摸盘滚打的程序员，在进阶的路上，共勉！
文章已收录在 JavaSharing中，蕴含Java技术文章，面试指南，资源分享。

一、为什么应用单利模式

单利：外表的意思就是一个类只能存在一个实例，那咱们什么时候会用到单利模式呢？

最常见的有以下几种场景：

1、Windows的Task Manager（工作管理器）就是很典型的单例模式
2、我的项目中，读取配置文件的类，个别也只有一个对象。没有必要每次应用配置文件数据，每次new一个对象去读取。
3、数据库连接池的设计个别也是采纳单例模式，因为数据库连贯是一种数据库资源。
4、在Spring中，每个Bean默认就是单例的，这样做的长处是Spring容器能够治理。
5、在servlet编程中/spring MVC框架，每个Servlet也是单例 /控制器对象也是单例.

综上所述单利有两个益处：

1、节俭内存
2、方便管理

二、单利模式的定义及特点

单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创立这个实例的一种模式。

单例模式有三个特点：

1、类只有一个实例对象；
2、该单例对象必须由单例类自行创立；
3、类对外提供一个拜访该单例的全局拜访点；

三、单利模式的实现形式

咱们实现单利模式次要抓住三个特点：

1、将构造函数私有化
2、在类的外部创立实例
3、提供获取惟一实例的办法

1、懒汉模式

该模式的特点是在类加载时没有创立实例，只有第一次调用办法getInstance()时才会创立单利对象，具体代码如下：

/** * 懒汉式单利模式（线程平安，调用效率不高，然而，能够实现延时加载） */public class SingletonL {    private static SingletonL instance = null;    private SingletonL() {  //防止类在内部被实例化    }    //创建对象的内部办法    public static SingletonL getInstance() {        if (null == instance) {            instance = new SingletonL();        }        return instance;    }}

这个试验尽管能获得一个对象的实例，然而在多线程的环境中，就会取的多个实例对象，那么如何解决懒汉模式在多线程中的问题呢？

申明synchronized关键字

既然多线程能够同时进入getInstance办法，那么只须要对getInstance办法申明synchronized关键字即可。

批改SingletonL.java后的代码如下：

public static synchronized SingletonL getInstance()

自定义线程类 MyThread1.java, MyThread2.java 代码如下：

public class MyThread1 extends Thread{    @Override    public void run() {        System.out.println(SingletonL.getInstance().hashCode());    }}public class MyThread2 extends Thread{    @Override    public void run() {        System.out.println(SingletonL.getInstance().hashCode());    }}

创立测试类Test.java,代码如下：

public class Test {    public static void main(String[] args) {        MyThread1 myThread1=new MyThread1();        myThread1.start();        MyThread2 myThread2=new MyThread2();        myThread2.start();     }}

程序运行后果：

1823766773
1823766773

此办法退出同步办法synchronized关键字失去了雷同实例对象，然而此办法运行效率很低，因为是同步运行的，下一个线程想要获得对象，必须等上一个线程开释锁之后，能力继续执行。

同步代码块

同步办法是对办法的整体加锁，而同步代码块是对实例变量做操作。

批改代码批改SingletonL.java后的代码如下：
`

public static  SingletonL getInstance() {    synchronized (SingletonL.class){        if (null == instance) {            instance = new SingletonL();        }        return instance;    }}

`
其实应用同步代码块操作效率也很低，那咱们如何批改同步代码块的代码来提高效率呢？

针对同步代码做一些解决，代码如下：

public static  SingletonL getInstance() {        if (instance==null){            synchronized (SingletonL.class){                if (null == instance) {                    instance = new SingletonL();                }                return instance;            }        }      return instance;    }

这样解决是因为当第一个线程调用办法创建对象，其余线程调用办法的时候发现该实例变量存在，就会间接调用而不会须要做期待的操作。

2、饿汉式模式

该模式的特点在类加载的时候就创建对象，在调用getInstance()是对象曾经存在。

/** * 饿汉式单利模式（线程平安，调用效率高，然而，不能够延时加载） */public class SingletonE implements Serializable {    //避免被援用    private static SingletonE instance = new SingletonE();    //避免被实例化    private SingletonE() {    }    public static SingletonE getInstance() {        return instance;    }}

阐明饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会波及多个线程对象拜访该对象的问题。虚拟机保障只会装载一次该类，必定不会产生并发拜访的问题。

3、动态外部类

该模式的特点是通过一个动态外部类创立实例对象，而后调用getInstance()实现单利，是线程平安的

/** * 动态外部类单利模式（线程平安，调用效率高。 然而，能够延时加载） */public class SingletonJt {    private static class staticFactory {        private  static   final  SingletonJt instance = new SingletonJt();    }    //避免被实例化    private SingletonJt() {    }    public static SingletonJt getInstance() {        return staticFactory.instance;    }}

阐明外部类没有static属性，则不会像饿汉式那样立刻加载对象，只有真正调用getInstance(),才会加载动态外部类。加载类时是线程平安的。instance是static final 类型，保障了内存中只有这样一个实例存在，而且只能被赋值一次，从而保障了线程安全性。

4、枚举单利

/** * 枚举单利模式（线程平安，调用效率高，不能延时加载） */public enum  Singletonenum {    INSTANCE;}public class Client {    public static void main(String[] args) {        Singletonenum singletonenum=Singletonenum.INSTANCE;        Singletonenum singletonenum1=Singletonenum.INSTANCE;        System.out.println(singletonenum==singletonenum1);    }}

阐明枚举自身就是单利模式，不能够实现延时加载。

四、单例模式的效率平安问题

两种形式实现懒汉模式的平安问题：
1、反射
2、序列化和反序列化

通过反射中的setAccessible(true)办法,破解懒汉式单利模式，具体代码如下：

/**     * 测试懒汉式单利模式（反射）     */    public static void testSingleLFs() throws Exception {       Class c= Class.forName("com.designpattern.pattern.singletonpattern.SingletonL");       Constructor constructor=c.getDeclaredConstructor(null);       constructor.setAccessible(true);       SingletonL singletonL1=(SingletonL) constructor.newInstance();       SingletonL singletonL11=(SingletonL) constructor.newInstance();        System.out.println(singletonL1==singletonL11); //返回为false    }

那咱们如何防止这个问题呢?只须要在在单利模式中退出这段代码即可：即在公有结构器中加一个判断规定即可实现，System.out.println(singletonL1==singletonL11); //返回为true

private SingletonL() {  //防止类在内部被实例化        if (null==instance){            throw new RuntimeException("实例曾经存在");        }    }

通过序列化和反序列化破解单利模式，思路是先把实例的对象写到一个文件当中，而后在读到程序当中，具体代码如下：

/**     * 测试懒汉式单利模式（序列化和反序列化）     * @param singletonL     * @throws Exception     */    public static void testSingleLxL(SingletonL singletonL) throws Exception {        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("D:/a.txt"));        oos.writeObject(singletonL);        oos.close();        ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream("D:/a.txt"));        System.out.println((SingletonL)objectInputStream.readObject());    }

防止这个问题的形式是在懒汉式单利模式中退出一段代码即可：

//反序列化时，如果定义了readResolve()则间接返回此办法指定的对象。而不须要独自再创立新对象！    private Object readResolve() throws ObjectStreamException {        return instance;    }

单利模式实现形式的效率问题，阐明几点：咱们须要借助这个类

CountDownLatch – 同步辅助类，在实现一组正在其余线程中执行的操作之前，它容许一个或多个线程始终期待。
• countDown() 以后线程调此办法，则计数减一
• await()，调用此办法会始终阻塞以后线程，直到计时器的值为0

具体代码如下：

/** * 测试单利模式的效率 */public class ClientTest {    public static void main(String[] args) throws InterruptedException {        long start = System.currentTimeMillis();        int count = 10;        final CountDownLatch countDownLatch=new CountDownLatch(count);        for (int j = 0; j < count; j++) {  //多线程环境下            new Thread(new Runnable() {                public void run() {                    for (int i = 0; i < 10000; i++) {                        //测试那种实现形式批改这里即可                        SingletonL singletonL = SingletonL.getInstance(); //测试懒汉式                                    }                    countDownLatch.countDown();                }            }).start();        }        countDownLatch.await();    //main线程阻塞，直到计数器变为0，才会持续往下执行！        long end = System.currentTimeMillis();        System.out.println("总耗时："+(end-start));    }}

五、小结

常见的单利模式实现形式
次要：
饿汉式：(线程平安，调用效率高，然而，不能够实现延时加载)
懒汉式：（线程平安，调用效率不高，然而，能够实现延时加载）
动态外部类式：（线程平安，调用效率高，然而，能够延时加载）
枚举式：（线程平安，调用效率高，然而，不能够实现延时加载）
选用形式：
单利对象占用资源少，不须要延时枚举好于饿汉式
单利对象占用资源大须要延时加载，动态外部类好于懒汉式

看到这里明天的分享就完结了，如果感觉这篇文章还不错，来个分享、点赞、在看三连吧，让更多的人也看到～

欢送关注集体公众号 「JavaClub」，定期为你分享一些技术干货。