栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java设计模式(二)——单例模式

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java设计模式(二)——单例模式

定义:保证一个类只有一个实例,并且提供一个全局访问点(并且该类只提供一个取得其对象实例的方法(静态方法))。

场景:线程池、数据库连接池。

可以防止反复创建重量级类,节省内存。

实现方式 懒汉模式

使用的时候才开始实例化

  • 方式一:静态方法,线程不安全
import java.util.concurrent.TimeUnit;

public class SingletonTest {

    public static void main(String[] args){

        new Thread(()->{
            LazySingleton lazySingleton = null;
            lazySingleton = LazySingleton.getInstance();
            System.out.println(lazySingleton);
        },"t1").start();

        new Thread(()->{
            LazySingleton lazySingleton = null;
            lazySingleton = LazySingleton.getInstance();
            System.out.println(lazySingleton);
        },"t1").start();

        LazySingleton lazySingleton = LazySingleton.getInstance();
    }

}


class LazySingleton{

    private static LazySingleton instance;

    public static  LazySingleton getInstance() {
        if (instance == null){

            // 停留2秒,这样会有多个线程进到这里,即实例了n次,那就不是单例模式了
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

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

    private LazySingleton(){

    }

}

com.wzq.basics.singleton.LazySingleton@341867b0
com.wzq.basics.singleton.LazySingleton@1ce768be

结果是2个实例的,线程都进入了if (instance == null),会new多个实例,线程不安全,如果synchronized锁住整个方法,效率低,锁住的是整个类模板。

  • 方式二:双重检验锁,线程安全

效率高写,可以使用双重检验锁机制:

class LazySingleton{

    private static volatile LazySingleton instance;

    public static  LazySingleton getInstance() {
        if (instance == null){

            // 停留2秒,这样会有多个线程进到这里,即实例了n次,那就不是单例模式了
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 双重检验锁,锁住的是代码块,锁住类
            synchronized (LazySingleton.class){
                //再判断,防止上一个==null有多个线程进来
                if (instance == null){
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

这样还是会出现数据异常的情况,首先 instance = new LazySingleton();的底层汇编是:

  1. 分配空间,返回一个指向该空间的一个内存引用(堆空间)
  2. 对空间进行初始化
  3. 把内存引用赋值给instance

由于存在编译器指令重排的情况,以上顺序会出现不一致,会出现这种情况:1,3先执行,然后有其它线程访问第一个if (instance == null),结果发现不为空,直接return,这样那个线程就拿走了数据异常的实例,所以需要加volatile修饰instance,才不会有事,禁止指令重排。

饿汉模式

在类加载阶段就完成了实例的初始化。

  • 方式一:静态常量

类加载器加载到方法区的二进制文件,静态,常量。

原理是jvm的类加载器自动完成了static实例化。

步骤:1) 构造器私有化 (防止 new ) 2) 类的内部创建对象 3) 向外暴露一个静态的公共方法getInstance。

// 饿汉模式1静态常量
public class Hunger {

    //私有static,实例一次
    private static Hunger instance = new Hunger();

    //向外暴露口
    public static Hunger getInstance(){
        return instance;
    }

    private Hunger(){

    }

}

优缺点说明:

  1. 优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。

  2. 缺点:在类装载的时候就完成实例化,没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例,则会造成内存的浪费

  3. 这种方式基于 classloder 机制避免了多线程的同步问题,不过,instance 在类装载时就实例化,在单例模式中大多数都是调用 getInstance 方法, 但是导致类装载的原因有很多种,因此不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化 instance 就没有达到 lazy loading 的效果

  4. 结论:这种单例模式可用,可能造成内存浪费

序列化测试:

// 序列化,持久到磁盘,按对象字节,ObjectOutputStream,ObjectInputStream
// 默认指定序列化id,不然不能重新输出到同一个文件
public class SerializeTest {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Hunger instance = Hunger.getInstance();

        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("instance"));
        outputStream.writeObject(instance);
        outputStream.close();

        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("instance"));
        Hunger instance2 = (Hunger)inputStream.readObject();
        inputStream.close();

        System.out.println(instance == instance2); // false,多个实例

    }

}

输出false,说明不是单例了,解决方法如下:

// 饿汉模式
public class Hunger implements Serializable {

    private final static long serialVersionUID = 8391757654242165401L;

    private static Hunger instance = new Hunger();

    public static Hunger getInstance(){
        return instance;
    }

    private Hunger(){

    }

    // 解决反序列化单例问题
    Object readResolve() throws ObjectStreamException{
        return instance;
    }

}
  • 方式二:静态代码块
// 饿汉模式2静态代码块
public class Hunger {

    //私有static
    private static Hunger instance;
    
    //静态代码块实例
    static{
        instance = new Hunger();
    }

    //向外暴露口
    public static Hunger getInstance(){
        return instance;
    }

    private Hunger(){

    }

}
  1. 这种方式和上面的方式其实类似,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点和上面是一样的。

  2. 结论:这种单例模式可用,但是可能造成内存浪费

静态内部类方式

一样在类加载阶段就完成了实例的初始化

// 内部类
public class InnerClass {

    static class inner{
        private static final InnerClass instance = new InnerClass();
    }

    public static InnerClass getInstance(){
        return inner.instance;
    }

    private InnerClass(){

    }

}
public class Test {

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 反射获取
        Constructor innerClass = InnerClass.class.getDeclaredConstructor();
        // 暴力方式
        innerClass.setAccessible(true);
        InnerClass instance1 = innerClass.newInstance();

        InnerClass instance2 = InnerClass.getInstance();

        System.out.println(instance1 == instance2); // false 2个实例
    }
}

静态内部类方式在 Singleton 类被装载时并不会立即实例化,而是在需要实例化时,调用 getInstance 方法,才会装载 SingletonInstance 类,从而完成 Singleton 的实例化。

类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM 帮助我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。

以上使用static静态方式实现,存在弊端,我们用反射暴力获取实例时,出现多个实例了,违反单例模式。

需要调整构造函数InnerClass():

// 内部类
public class InnerClass {

    static class inner{
        private static InnerClass instance = new InnerClass();
    }

    public static InnerClass getInstance(){
        return inner.instance;
    }

    private InnerClass(){
        if (getInstance() != null){
            throw new RuntimeException("不能多个实例");
        }
    }

}
枚举单例

枚举可以防止反序列化重新创建新的对象。

//枚举方式
public enum  EnumTest {

    INSTANCE;

    public void print(){
        System.out.println(this.hashCode());
    }

}

底层枚举类型不能通过反射实例化,默认符合单例。

 EnumTest instance1 = EnumTest.INSTANCE;
 EnumTest instance2 = EnumTest.INSTANCE;
 System.out.println(instance1 == instance2); //true
 instance1.print(); // 一样
 instance2.print();
单例模式在 JDK 应用的源码分析
  1. 我们 JDK 中,java.lang.Runtime 就是经典的单例模式(饿汉式)

2)代码分析+Debug源码代码说明

单例模式注意事项和细节说明
  1. 单例模式保证了 系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能

  2. 当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用 new

  3. 单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)

推荐使用:双重锁、静态内部类、枚举

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/967250.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号