设计模式之单例模式

最新推荐文章于 2023-02-09 14:50:48 发布

FangWenJuno

最新推荐文章于 2023-02-09 14:50:48 发布

阅读量138

点赞数 1

分类专栏：设计模式

本文链接：https://blog.csdn.net/fangwenjuno/article/details/116713647

版权

设计模式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

单例模式:

单例模式保证了系统应用中只存在一个该对象,节省系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高性能,

应用场景:创建对象耗时过多或者耗费资源过多时,但又经常需要使用到的对象,例如工具类对象,频繁访问数据和文件的对象(访问数据源, session工厂等)

饿汉式(静态常量):

package com.block.designPattern.singleton;

/**
 * @ClassName SingletonTest
 * @author: fangwenjun
 * @date: Created in 2021/5/12 13:55
 * @description:
 * @version: 1.0
 */
public class SingletonTest {


    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());

    }
}

/**
 * 饿汉式: 静态变量
 */
class Singleton {

    /**
     * 构造器私有化
     */
    private Singleton(){

    }

    /**
     * 创建实例对象
     */
    private final static Singleton SINGLETON = new Singleton();

    /**
     * 对外的公共方法, 获取唯一实例
     * @return
     */
    public static Singleton getInstance(){
        return SINGLETON;
    }
}

说明:

写法较简单,在类装载的时候已经完成了实例化, 避免了多线程的同步问题,
在单例模式下大多数都是调用getInstance方法获取实例,但是导致类装载(classloader机制)的情况有很多种,不排除在项目其他地方对这个类进行装载,这时候这个类的单例模式就没到达预期效果, 初始化的实例没有被使用,造成内存的浪费
在确保是单例模式下,其他位置没有进行装载时,可以使用,要不然会造成内存浪费

饿汉式(静态代码块):

package com.block.designPattern.singleton.o2;

/**
 * @ClassName SingletonTest
 * @author: fangwenjun
 * @date: Created in 2021/5/12 13:55
 * @description:
 * @version: 1.0
 */
public class SingletonTest {


    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());

    }
}

/**
 * 饿汉式: 静态代码块
 */
class Singleton  {

    /**
     * 构造器私有化
     */
    private Singleton(){

    }
    
    static {
        // 静态代码块实例化对象
        SINGLETON = new Singleton();
    }

    /**
     * 创建实例对象
     */
    private final static Singleton SINGLETON;

    /**
     * 对外的公共方法, 获取唯一实例
     * @return
     */
    public static Singleton getInstance(){
        return SINGLETON;
    }
}

说明:

静态代码块的这种方式跟静态变量的方式的结果是一样的,都会在类加载的时候初始化实例, 同样缺点是会造成内存浪费

懒汉式(线程不安全):

package com.block.designPattern.singleton.o3;

/**
 * @ClassName SingletonTest
 * @author: fangwenjun
 * @date: Created in 2021/5/12 13:55
 * @description:
 * @version: 1.0
 */
public class SingletonTest {


    public static void main(String[] args) {
        com.block.designPattern.singleton.o3.Singleton instance = com.block.designPattern.singleton.o3.Singleton.getInstance();
        com.block.designPattern.singleton.o3.Singleton instance1 = com.block.designPattern.singleton.o3.Singleton.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());

    }
}

/**
 * 懒汉式: 线程不安全
 */
class Singleton {

    /**
     * 构造器私有化
     */
    private Singleton(){
    }

    /**
     * 定义实例变量
     */
    private static Singleton singleton;

    /**
     * 提供静态公共方法懒加载实例
     * @return
     */
    public static Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

说明:

这种懒汉式是线程不安全的, 在多线程的情况下,线程A进入if判断后,还未实例化,线程B判断时对象为null,进入if判断,这时就违反了单例模式下只能有一个实例的规定. 在多线程的情况下不能使用这种懒汉式,实际开发时也尽量别用

懒汉式(线程安全,同步方法):

package com.block.designPattern.singleton.o3;

/**
 * @ClassName SingletonTest
 * @author: fangwenjun
 * @date: Created in 2021/5/12 13:55
 * @description:
 * @version: 1.0
 */
public class SingletonTest03 {


    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());

    }
}

/**
 * 懒汉式: 线程安全 同步方法
 */
class Singleton {

    /**
     * 构造器私有化
     */
    private Singleton(){
    }

    /**
     * 定义实例变量
     */
    private static Singleton singleton;

    /**
     * 提供静态公共方法懒加载实例
     * @return
     */
    public static synchronized Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

说明:

解决了线程不安全的问题,但是也带来了缺点, 效率较低,该同步方法只需实例化一次即可,其他线程都是直接return实例, 使用同步方法降低了效率,不推荐使用.
使用同步代码块去降低锁的粒度的话, 连线程安全的问题都没有解决,所以开发时不能使用
使用双重检查可以解决线程安全和效率问题,

双重检查:

package com.block.designPattern.singleton.o3;

/**
 * @ClassName SingletonTest
 * @author: fangwenjun
 * @date: Created in 2021/5/12 13:55
 * @description:
 * @version: 1.0
 */
public class SingletonTest03 {


    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());

    }
}

/**
 * 懒汉式: 线程安全 同步方法
 */
class Singleton {

    /**
     * 构造器私有化
     */
    private Singleton(){
    }

    /**
     * 定义实例变量
     */
    private static volatile Singleton singleton;

    /**
     * 提供静态公共方法懒加载实例,使用双重检查解决线程安全和提升效率的问题
     * @return
     */
    public static Singleton getInstance(){
        if (singleton == null){
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

说明:

这种方法即解决了线程安全问题,也解决了懒汉式的效率较低的问题,

静态内部类:

package com.block.designPattern.singleton.o3;

/**
 * @ClassName SingletonTest
 * @author: fangwenjun
 * @date: Created in 2021/5/12 13:55
 * @description:
 * @version: 1.0
 */
public class SingletonTest03 {


    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());

    }
}

/**
 * 懒汉式: 线程安全 同步方法
 */
class Singleton {

    /**
     * 构造器私有化
     */
    private Singleton(){
    }

    /**
     * 定义静态内部类, 实例化对象
     */
    private static class SingletonInstance{
        private static final Singleton SINGLETON = new Singleton();
    }

    /**
     * 提供静态公共方法懒加载实例,使用静态内部类的方式加载实例,即解决线程安全又是懒加载的
     * @return
     */
    public static Singleton getInstance(){
        return SingletonInstance.SINGLETON;
    }
}

说明:

静态内部类的方式,在外部类进行加载时,不会直接加载内部类,解决了懒加载问题, 在getInstance()方法获取实例时,使用内部类的方式获取,这时进行内部类的加载, 类加载机制本身就是线程安全的,即解决了实例化时线程不安全的问题.
类的静态属性只会在第一次类加载的时候初始化,这样就保证的线程安全,
优点: 避免了线程不安全问题,实现懒加载,效率较高

枚举:

package com.block.designPattern.singleton.o4;

import lombok.Getter;

/**
 * @ClassName SingletonTest04
 * @author: fangwenjun
 * @date: Created in 2021/5/12 16:15
 * @description:
 * @version: 1.0
 */
public class SingletonTest04 {

    public static void main(String[] args) {
        Singleton fang = Singleton.FANG;
        Singleton fang2 = Singleton.FANG;
        System.out.println(fang.hashCode());
        System.out.println(fang2.hashCode());

    }

    @Getter
    enum Singleton {
        FANG();
    }
}

说明:

枚举的方式也可以即能实现单例模式,也能解决线程安全问题,还可以解决反序列化重新创建对象的问题,
枚举方式也是java的作者Josh Bloch推荐的方式

总结:

单例模式解决的问题: 采取一定的方法保证在整个软件系统中,对于某个类只能存在一个对象实例

总共有多种写法: 饿汉式(静态变量,静态代码块) 懒汉式(线程不安全,线程安全),双重检查,静态内部类,枚举等方式

本人刚入门其他不完善之处还请指出.

FangWenJuno

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式之单例模式

单例模式:单例模式保证了系统应用中只存在一个该对象,节省系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高性能,应用场景:创建对象耗时过多或者耗费资源过多时,但又经常需要使用到的对象,例如工具类对象,频繁访问数据和文件的对象(访问数据源, session工厂等)饿汉式(静态常量):package com.block.designPattern.singleton;/** * @ClassName SingletonTest * @author: fangwenjun * @da
复制链接

扫一扫

专栏目录