设计模式之单例模式

最新推荐文章于 2024-10-23 22:17:36 发布

原创最新推荐文章于 2024-10-23 22:17:36 发布 · 241 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #singleton #单例模式

设计模式专栏收录该内容

21 篇文章

订阅专栏

前言

单例模式（Singleton Pattern）保证一个类仅有一个实例，并提供一个它的全局访问点。

一.单例模式简介

单例模式（Singleton Pattern）为了防止多次实例化一个对象，为该对象提供一个访问该实例的方法，让类自身负责保存它唯一的实例，这个类可以保证没有其他实例可以被创建。

二.单例模式多种用法分析

1.懒汉式–非线程安全单例模式

设计分析：需要一个私有的（private）空构造方法，防止外部类通过new创建实例。提供一个创建实例的方法getinstance()来创建实例，若实例已经被创建过，则直接返回原有实例。

线程安全问题：在单线程的程序中，用此方法可以实现单例，但在多线程编程中，当两个线程同时调用getinstance()方法时，因为两个线程的instance对象都为空，这两个线程可能都会执行new Singleton()，这两个线程可能各自创建一个instance对象，创建出多个instance对象即不是单例模式了，也就存在线程安全的问题了。

为什么称为懒汉：要在第一次引用实例的时候，才进行实例化，实现懒加载效果，节省内存资源，所以称为懒汉式。

代码如下：

package com.pattern.singleton.singleton;

/**
 * 懒汉式-非线程安全式
 * 
 * @author 葫芦娃
 * 
 */
public class Singleton {

    // 单例对象
    private static Singleton instance;

    // 私有的构造函数，使用private修饰，防止外界通过new再次创建对象
    private Singleton() {
    }

    // 提供一个外部访问该实例的方法
    public static Singleton getinstance() {
        // 只有当不存在的时候创建（线程不安全，没有加锁，可以被多个线程调用）
        if (instance == null) {
            instance = new Singleton();
        }
        // 若存在，直接返回该实例
        return instance;
    }
}

2.懒汉式——线程安全单例模式

设计分析：与上面的不同之处在于，getinstance()方法添加了synchronized关键字修饰，即添加了方法同步，多线程会在进入此方法前排队依次执行，所以就解决了上面方式的线程安全问题，多线程编程中使用，也可以保证对象实现单例。

代码如下：

package com.pattern.singleton.singleton;
/**
 * 懒汉式-线程安全式
 * @author 葫芦娃
 *
 */
public class LazySingleton {

    // 单例对象
    private static LazySingleton instance;

    // 私有的构造函数，使用private修饰，防止外界通过new再次创建对象
    private LazySingleton() {
    }

    // 提供一个外部访问该实例的方法,并使用synchronized关键字同步
    public static synchronized LazySingleton getinstance() {
        // 只有当不存在的时候创建
        if (instance == null) {
            instance = new LazySingleton();
        }
        // 若存在，直接返回该实例
        return instance;
    }
}

3.饿汉式–线程安全单例模式

设计分析： 在类初始化静态变量的时候，将instance实例化，提供私有的构造方法，防止通过new创建对象，提供getinstance()方法来创建实例。

线程安全问题： 因为类加载的时候，实例就已经初始化完成，就算有多个线程调用，也不会重复创建了，但缺点就是浪费内存资源。

为什么称为饿汉：在类加载的时候，初始化静态变量的时候就创建了该对象。就像一个饿汉，不管有用没用的，先吃到肚子里再说。

代码如下：

package com.pattern.singleton.singleton;

/**
 * 饿汉式单例模式（线程安全）
 * 
 * @author 葫芦娃
 *
 */
public class HungrySingleton {

    // 静态单例对象，程序运行直接初始化
    private static HungrySingleton instance =new HungrySingleton();

    // 私有的构造函数，使用private修饰，防止外界通过new再次创建对象
    private HungrySingleton() {
    }

    // 提供一个外部访问该实例的方法
    public static HungrySingleton getinstance() {
        //在静态变量中已经初始化，直接返回该实例
        return instance;
    }
}

4.双检锁/双重校验锁式——线程安全单例模式

设计分析： 提供一种即不耗费内存资源(懒加载)，还能保证线程安全的方式创建单例模式。

双重校验：
1. 第一重校验：if (instance == null)防止实例已经初始化，还要让多线程每次进行synchronized排队，提高效率。
2. 第二重校验：if (instance == null)防止多线程并发时，保证只有一个线程在进行实例化操作，即实现单例，还能保证线程安全。

代码如下：

package com.pattern.singleton.singleton;

/**
 * 双检锁/双重校验锁式的单例(线程安全)
 * 
 * @author 葫芦娃
 *
 */
public class DoubleCheckLockingSingleton {

    // volatile修饰的单例对象
    private static volatile DoubleCheckLockingSingleton instance;

    // 私有的构造函数，使用private修饰，防止外界通过new再次创建对象
    private DoubleCheckLockingSingleton() {
    }

    // 提供一个外部访问该实例的方法
    public static DoubleCheckLockingSingleton getinstance() {
        //第一重校验：防止实例已经初始化，还要每次进行加锁，提高效率
        if (instance == null) {
            // 线程同步，当多个线程的instance为null,都可以通过第一重校验
            synchronized (DoubleCheckLockingSingleton.class) {
                // //第二重校验：防止多个线程的访问，只允许有一个进入，其他线程排队等第一个线程访问结束再进入，保证instance对象的单例
                if (instance == null) {
                    instance = new DoubleCheckLockingSingleton();
                }
            }
        }
        return instance;
    }
}

5.客户端：

在客户端中，对比实例是单例，即创建的都是同一个实例。

代码如下：

package com.pattern.singleton.client;

import com.pattern.singleton.singleton.DoubleCheckLockingSingleton;
import com.pattern.singleton.singleton.HungrySingleton;
import com.pattern.singleton.singleton.LazySingleton;
import com.pattern.singleton.singleton.Singleton;

public class Client {
    public static void main(String[] args) {
        // 通过new Singleton()来创建实例已经被禁用了，只能通过下面提供的方式
        Singleton singleton1 = Singleton.getinstance();
        Singleton singleton2 = Singleton.getinstance();
        if (singleton1 == singleton2) {
            System.out.println("懒汉式非线程安全：singleton1和singleton2是相同实例");
        } else {
            System.out.println("懒汉式非线程安全：singleton1和singleton2是不同实例");
        }

        // 线程安全的单单例模式
        final LazySingleton lazySingleton4 = LazySingleton.getinstance();
        // 饿汉式单例，保证了线程安全
        final HungrySingleton hungrySingleton5 = HungrySingleton.getinstance();
        // 双重校验创建线程安全的单例对象
        final DoubleCheckLockingSingleton doubleCheckLockingSingleton7 = DoubleCheckLockingSingleton.getinstance();
        new Thread(new Runnable() {

            public void run() {
                LazySingleton lazySingleton5 = LazySingleton.getinstance();
                if (lazySingleton4 == lazySingleton5) {
                    System.out.println("懒汉式线程安全：lazySingleton4和lazySingleton4是相同实例");
                } else {
                    System.out.println("懒汉式线程安全：lazySingleton4和lazySingleton4是不同实例");
                }

                HungrySingleton hungrySingleton6 = HungrySingleton.getinstance();
                if (hungrySingleton5 == hungrySingleton6) {
                    System.out.println("饿汉式线程安全：hungrySingleton5和hungrySingleton6是相同实例");
                } else {
                    System.out.println("饿汉式线程安全：hungrySingleton5和hungrySingleton6是不同实例");
                }

                DoubleCheckLockingSingleton doubleCheckLockingSingleton8 = DoubleCheckLockingSingleton.getinstance();
                if (doubleCheckLockingSingleton7 == doubleCheckLockingSingleton8) {
                    System.out.println("双重校验锁式线程安全：doubleCheckLockingSingleton7和doubleCheckLockingSingleton8是相同实例");
                } else {
                    System.out.println("双重校验锁式线程安全：doubleCheckLockingSingleton7和doubleCheckLockingSingleton8是不同实例");
                }
            }
        }).start();

    }
}

6.运行结果展示

懒汉式非线程安全：singleton1和singleton2是相同实例
懒汉式线程安全：lazySingleton4和lazySingleton4是相同实例
饿汉式线程安全：hungrySingleton5和hungrySingleton6是相同实例
双重校验锁式线程安全：doubleCheckLockingSingleton7和doubleCheckLockingSingleton8是相同实例