关于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」，定期为你分享一些技术干货。

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

一、为什么应用单利模式

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

三、单利模式的实现形式

1、懒汉模式

2、饿汉式模式

3、动态外部类

4、枚举单利

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

五、小结

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

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

一、为什么应用单利模式

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

三、单利模式的实现形式

1、懒汉模式

2、饿汉式模式

3、动态外部类

4、枚举单利

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

五、小结

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复