浅谈单例模式（java实现）

最新推荐文章于 2024-07-24 15:19:30 发布

SunShine·He

最新推荐文章于 2024-07-24 15:19:30 发布

阅读量217

点赞数 2

分类专栏：设计模式文章标签： java 设计模式单例模式

本文链接：https://blog.csdn.net/Gao_JiaHe/article/details/88981046

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.前言
在Java开发过程中，很多场景下都会碰到或要用到单例模式，在设计模式里也是经常作为指导学习的热门模式之一，相信每位开发同事都用到过。为了更好地理解，重新学习了单例模式，并写了本篇文章，希望能帮助到你，也请各位大神能多多指教。

2.简介
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

3.特点

单例类只能有一个实例。
单例类必须自己创建自己的唯一实例。
单例类必须给所有其他对象提供这一实例。

单例模式保证了全局对象的唯一性，比如系统启动读取配置文件就需要单例保证配置的一致性。

4.注意事项

在获取单例的时候，要保证不能产生多个实例对象，getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。
在使用单例对象的时候，要注意单例对象内的实例变量是会被多线程共享的，推荐使用无状态的对象，不会因为多个线程的交替调度而破坏自身状态导致线程安全问题。

5.适用场景

要求生产唯一序列号。
WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
需要频繁的进行创建和销毁的对象。
创建对象时耗时过多或耗费资源过多，但又经常用到的对象。

6.单例方法的实现

饿汉式（静态常量）

public class Singleton {
	//定义一个唯一实例
    private final static Singleton INSTANCE = new Singleton();

    private Singleton(){}
	//获取实例
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

优点：
这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
缺点：
在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

2.饿汉式（静态代码块）

public class Singleton {
	//声明（静态代码块只能使用静态变量）
    private static Singleton instance;
	//静态代码块在类加载器装载时创建对象
    static {
        instance = new Singleton();
    }

    private Singleton() {}
	//返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点和上面的方式一样

懒汉式(线程不安全)

public class Singleton {
	//声明变量
    private static Singleton singleton;
	
    private Singleton() {}
	//返回实例对象
    public static Singleton getInstance() {
    	//判断该对象是否被创建
        if (singleton == null) {
        	//创建对象
            singleton = new Singleton();
        }
        return singleton;
    }
}

这种写法起到了Lazy Loading的效果，但是只能在单线程下使用。如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

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

public class Singleton {
	//声明变量
    private static Singleton singleton;
	
    private Singleton() {}
	//在获取对象方法上添加synchronized关键字，保证线程安全
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

优点：
解决了上第三种实现方式的线程不安全问题，添加了synchronized关键字，保证线程安全，是线程同步。

缺点：
这种方法效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了,方法进行同步效率太低要改进。

5. 懒汉式(线程安全，同步代码块)

public class Singleton {
	//定义静态的变量
    private static Singleton singleton;

    private Singleton() {}
	//获取对象
    public static Singleton getInstance() {
    	//检查是否被创建
        if (singleton == null) {
            synchronized (Singleton.class) {
            	//再次进行检查
            	if(singleton == null){
            	 	singleton = new Singleton();
            	} 
            }
        }
        return singleton;
    }
}

Double-Check概念对于多线程开发者来说不会陌生，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。

静态内部类

public class Singleton {
	
    private Singleton() {}
	
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

以上就是本文要介绍的所有单例模式的理解和实现，相信这篇文章能让大家更清楚的理解单例模式，希望大家有问题可以探讨，多多指教！