设计模式（四）单例模式的学习和使用

最新推荐文章于 2023-04-16 14:34:49 发布

新星飞扬

最新推荐文章于 2023-04-16 14:34:49 发布

阅读量255

点赞数

分类专栏：设计模式文章标签：设计模式 singleton

本文链接：https://blog.csdn.net/lly983909814/article/details/72123687

版权

设计模式专栏收录该内容

3 篇文章 0 订阅

订阅专栏

什么是单例模式

    单例模式(Singleton Pattern) 涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
    注意：
        1、单例类只能有一个实例。
        2、单例类必须自己创建自己的唯一实例。
        3、单例类必须给所有其他对象提供这一实例。

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
解决类型：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的。
应用实例：

1、一个党只能有一个主席。
2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。
2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。
关系图
设计模式之单例模式

单例模式的五种写法
恶汉式、懒汉式、双重校验锁、枚举和静态内部类

一、恶汉式

恶汉式（静态常量）

/**
 * 恶汉式（静态常量）
 * 适合线程：单线程
 * 是否同步： 不同步
 * 线程安全：不安全
 * 效率：：效率低
 *
 */
public class Singleton {
    private static Singleton singleton =new Singleton ();//static 关键字只实例化一次，实例类存放在老年代

    private Singleton() {}

    public static Singleton getInstance(){
        return singleton;
    }

    public void  getMessage(){
        System.out.println("come");
    }
}

test.java
    @Test
    public void test1(){
        Singleton singleton = Singleton.getInstance();
        singleton.getMessage();
    }

堆内存对比，
一次调用一个
come
Heap
PSYoungGen total 28672K, used 6546K [0x00000000e0b00000, 0x00000000e2a80000, 0x0000000100000000)
eden space 25088K, 26% used [0x00000000e0b00000,0x00000000e1164b10,0x00000000e2380000)
from space 3584K, 0% used [0x00000000e2700000,0x00000000e2700000,0x00000000e2a80000)
to space 3584K, 0% used [0x00000000e2380000,0x00000000e2380000,0x00000000e2700000)
ParOldGen total 64000K, used 0K [0x00000000a2200000, 0x00000000a6080000, 0x00000000e0b00000)
object space 64000K, 0% used [0x00000000a2200000,0x00000000a2200000,0x00000000a6080000)
PSPermGen total 21504K, used 5500K [0x000000009d000000, 0x000000009e500000, 0x00000000a2200000)
object space 21504K, 25% used [0x000000009d000000,0x000000009d55f2d0,0x000000009e500000)

一次调用两个
come
come
Heap
PSYoungGen total 28672K, used 6546K [0x00000000e0b00000, 0x00000000e2a80000, 0x0000000100000000)
eden space 25088K, 26% used [0x00000000e0b00000,0x00000000e1164b18,0x00000000e2380000)
from space 3584K, 0% used [0x00000000e2700000,0x00000000e2700000,0x00000000e2a80000)
to space 3584K, 0% used [0x00000000e2380000,0x00000000e2380000,0x00000000e2700000)
ParOldGen total 64000K, used 0K [0x00000000a2200000, 0x00000000a6080000, 0x00000000e0b00000)
object space 64000K, 0% used [0x00000000a2200000,0x00000000a2200000,0x00000000a6080000)
PSPermGen total 21504K, used 5500K [0x000000009d000000, 0x000000009e500000, 0x00000000a2200000)
object space 21504K, 25% used [0x000000009d000000,0x000000009d55f2e8,0x000000009e500000)

恶汉式（静态代码块，一变种）

/**
 * 懒汉式（静态代码块）
 * 适合线程：单线程
 * 是否同步：不 同步
 * 线程安全：不安全
 * 效率：：效率低
 *
 */
public class Singleton {
    private static Singleton singleton;

    static{
        singleton=new Singleton();//和上面static用法一样
    }

    private Singleton() {}

    public static Singleton getInstance(){
        return singleton;
    }

    public void  getMessage(){
        System.out.println("come");
    }
}

和上面一样

二、懒汉式

懒汉式（静态常量）

/**
 * 懒汉式（静态常量）
 * 适合线程：单线程
 * 是否同步： 不同步
 * 线程安全：不安全
 * 效率：：效率低
 *
 */
public class Singleton {
    private static Singleton singleton;

    private Singleton() {}
    //此方法起到了调用这个方法才加载这个类，起到了懒加载作用
    public static Singleton getInstance(){
        if (singleton==null) {
            singleton=new Singleton();
            System.out.println("我被实例化了");
        }
        return singleton;
    }

    public void  getMessage(){
        System.out.println("come");
    }
}


test.java
@Test
    public void test1(){
        Singleton singleton = Singleton.getInstance();
        singleton.getMessage();
        Singleton singleton1 = Singleton.getInstance();
        singleton1.getMessage();
    }

结果很清楚了，就不打印堆内存了
我被实例化了
come
come

懒汉式（synchronized 同步锁）

/**
 * 懒汉式（synchronized 同步锁）
 * 适合线程：多线程
 * 是否同步： 同步
 * 线程安全：安全
 * 效率：：效率低
 *
 */
public class Singleton {
    private static Singleton singleton;

    private Singleton() {}

    public static synchronized Singleton getInstance(){
        if (singleton==null) {
            singleton=new Singleton();
            System.out.println("我被实例化了");
        }
        return singleton;
    }

    public void  getMessage(){
        System.out.println("come");
    }
}

test.java
@Test
    public void test1(){
        Singleton singleton = Singleton.getInstance();
        singleton.getMessage();
        Singleton singleton1 = Singleton.getInstance();
        singleton1.getMessage();
    }

同上

懒汉式（synchronized 同步代码块一）

/**
 * 懒汉式(同步代码块)
 * 适合线程：多线程
 * 是否同步： 同步
 * 线程安全：安全
 * 效率：：效率低
 *
 */
public class Singleton {
    private static Singleton singleton;

    private Singleton() {}

    public static  Singleton getInstance(){
        if (singleton==null) {
            synchronized(Singleton.class){
                singleton=new Singleton();
                System.out.println("我被实例化了");
            }
        }
        return singleton;
    }

    public void  getMessage(){
        System.out.println("come");
    }
}

懒汉式（synchronized 同步代码块二）

/**
 * 懒汉式(同步代码块)
 * 适合线程：多线程
 * 是否同步： 同步
 * 线程安全：安全
 * 效率：：效率低
 *
 */
public class Singleton {
    private static Singleton singleton;

    private Singleton() {}

    public static  Singleton getInstance(){
        synchronized(Singleton.class){
            if (singleton==null) {
                singleton=new Singleton();
                System.out.println("我被实例化了");
            }
        }
        return singleton;
    }

    public void  getMessage(){
        System.out.println("come");
    }
}

三、双重校验锁

/**
 * 双重校验锁
 * 适合线程：多线程
 * 是否同步： 同步
 * 线程安全：安全
 * 效率：：效率高
 *
 */
public class Singleton {
    private volatile static Singleton singleton;

    private Singleton() {}

    public static  Singleton getInstance(){
        if (singleton==null) {
            synchronized(Singleton.class){
                if (singleton==null) {
                    singleton=new Singleton();
                    System.out.println("我被实例化了");
                }
            }
        }
        return singleton;
    }

    public void  getMessage(){
        System.out.println("come");
    }
}

四、静态内部类

/**
 * 静态内部类
 * 适合线程：单线程
 * 是否同步：不 同步
 * 线程安全：不安全
 * 效率：：效率低
 *
 */
public class Singleton {
    private static class SingletonClazz{
        private static final Singleton singleton=new Singleton();
    }

    private Singleton() {}

    public static final Singleton getInstance(){
        return SingletonClazz.singleton;
    }

    public void  getMessage(){
        System.out.println("come");
    }
}

5、枚举

/**
 * 枚举
 * 适合线程：多线程
 * 是否同步： 同步
 * 线程安全：安全
 * 效率：：效率高
 *
 */
public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
        System.out.println("我被调用啦");
    }  
}  
test.java
    @Test
    public void test1(){
        Singleton s = Singleton.INSTANCE;
        s.whateverMethod();
    }

我被调用啦

以上学习了cantellow 、李天炜、菜鸟教程-单例模式

新星飞扬

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式（四）单例模式的学习和使用

什么是单例模式单例模式(Singleton Pattern) 涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。注意： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。意图
复制链接

扫一扫