Java设计模式-单例模式:单例的六种实现

栏目: Java · 发布时间: 5年前

内容简介:确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。UML类图单例类的构造函数是

确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

UML类图

Java设计模式-单例模式:单例的六种实现

单例类的构造函数是 private 内部私有的,确保外部不能通过 new 的方式创建新对象,内部自行实例化,并对外提供一个访问该单一实例的静态的方法 Instance()

单例模式的实现

普通饿汉式

/**
 * 普通饿汉式
 *
 * @author anlingyi
 */
public class Singleton {
    /**
     * 类加载时进行实例化对象
     */
    private static final Singleton SINGLETON = new Singleton();

    /**
     * 私有构造,防止外部new对象
     */
    private Singleton() {

    }

    /**
     * 通过静态方法获取对象实例
     *
     * @return
     */
    public static Singleton getInstance() {
        return SINGLETON;
    }

    public void say() {
        System.out.println("普通饿汉式:Hello World!");
    }
}
复制代码

调用方式:

Singleton singleton = Singleton.getInstance();
singleton.say();
复制代码

优缺点

优点:类加载时就进行实例化,之后的操作效率会很高。

缺点:由于类加载时就进行实例化,如果后续不对此类进行任何操作,就会导致内存的浪费。

线程不安全的懒汉式

/**
 * 懒汉式(线程不安全)
 *
 * @author anlingyi
 */
public class SingletonTwo {

    private static SingletonTwo instance;

    /**
     * 私有构造,防止外部new对象
     */
    private SingletonTwo() {

    }

    /**
     * 通过静态方法获取对象实例
     *
     * @return
     */
    public static SingletonTwo getInstance() {
        if(instance == null) {
            instance = new SingletonTwo();
        }

        return instance;
    }

    public void say() {
        System.out.println("懒汉式(线程不安全):Hello World!");
    }
}
复制代码

调用方式:

SingletonTwo singleton = SingletonTwo.getInstance();
singleton.say();
复制代码

优缺点

优点:在第一次调用的时候才进行实例化。

缺点:当多个线程同时进入到 if(instance == null) {...} 时,会创建多个对象。

同步锁懒汉式

/**
 * 同步锁懒汉式(线程安全,效率低)
 *
 * @author anlingyi
 */
public class SingletonThree {

    private static SingletonThree instance;

    /**
     * 私有构造,防止外部new对象
     */
    private SingletonThree() {

    }

    /**
     * 通过静态方法获取对象实例
     *
     * @return
     */
    public static synchronized SingletonThree getInstance() {
        if(instance == null) {
            instance = new SingletonThree();
        }

        return instance;
    }

    public void say() {
        System.out.println("同步锁懒汉式(线程安全,效率低):Hello World!");
    }
}
复制代码

调用方式:

SingletonThree singleton = SingletonThree.getInstance();
singleton.say();
复制代码

优缺点

优点:在第一次调用的时候才进行实例化,且线程安全。

缺点:使用 synchronized 的方式对方法加锁,会影响效率。

双重校验锁懒汉式

/**
 * 双重校验锁懒汉式(线程安全,且多线程环境下可以保持高性能)
 *
 * @author anlingyi
 */
public class SingletonFour {

    /**
     * volatile是为了防止指令重排序
     */
    private static volatile SingletonFour instance;

    /**
     * 私有构造,防止外部new对象
     */
    private SingletonFour() {

    }

    /**
     * 通过静态方法获取对象实例
     *
     * @return
     */
    public static SingletonFour getInstance() {
        if(instance == null) {
            synchronized (SingletonFour.class) {
                if(instance == null) {
                    instance = new SingletonFour();
                }
            }
        }

        return instance;
    }

    public void say() {
        System.out.println("双重校验锁懒汉式(线程安全,且多线程环境下可以保持高性能):Hello World!");
    }
}
复制代码

调用方式:

SingletonFour singleton = SingletonFour.getInstance();
singleton.say();
复制代码

优缺点

优点:在第一次调用的时候才进行实例化,且线程安全,效率较高。

缺点:实现复杂,且 volatile 需要在JDK1.5之后的版本才能确保安全。

静态内部类懒汉式

/**
 * 静态内部类懒汉式
 *
 * @author anlingyi
 */
public class SingletonFive {

    /**
     * 私有构造,防止外部new对象
     */
    private SingletonFive() {

    }

    /**
     * 通过静态方法获取对象实例
     *
     * @return
     */
    public static SingletonFive getInstance() {
        return Singleton.SINGLETON;
    }

    public void say() {
        System.out.println("静态内部类懒汉式:Hello World!");
    }

    /**
     * 静态内部类实例化对象
     */
    private static class Singleton {
        /**
         * 类加载时进行实例化对象
         */
        private static final SingletonFive SINGLETON = new SingletonFive();
    }
}

复制代码

调用方式:

SingletonFive singleton = SingletonFive.getInstance();
singleton.say();
复制代码

优缺点

优点:只有在调用 getInstance() 方法的时候,静态内部类才会被加载,从而对主类(我们需要的类)进行实例化,即线程安全,又效率高。

缺点:多创建一个类。

枚举类饿汉式(防止反序列化)

/**
 * 枚举类饿汉式(防止反序列化)
 *
 * @author anlingyi
 */
public enum  SingletonSix {
    INSTANCE;

    public void say() {
        System.out.println("枚举类饿汉式(防止反序列化):Hello World!");
    }
}
复制代码

调用方式:

SingletonSix singleton = SingletonSix.INSTANCE;
singleton.say();
复制代码

优缺点

优点:实现简单,防止反序列化生成多个实例,且线程安全。

缺点: Enum 需在JDK1.5之后版本使用。

单例模式的优缺点

优点

  • 单例模式在内存中只有一个实例,减少了内存开支,尤其是频繁的创建和销毁实例。
  • 由于只生成一个实例,所以减少了系统的性能开销。
  • 避免对资源的多重占用,例如写文件操作。
  • 单例模式可以在系统设置全局的访问点,优化和共享资源访问。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

Programming Computer Vision with Python

Programming Computer Vision with Python

Jan Erik Solem / O'Reilly Media / 2012-6-22 / USD 39.99

If you want a basic understanding of computer vision's underlying theory and algorithms, this hands-on introduction is the ideal place to start. As a student, researcher, hacker, or enthusiast, you'll......一起来看看 《Programming Computer Vision with Python》 这本书的介绍吧!

随机密码生成器
随机密码生成器

多种字符组合密码

UNIX 时间戳转换
UNIX 时间戳转换

UNIX 时间戳转换

HEX CMYK 转换工具
HEX CMYK 转换工具

HEX CMYK 互转工具