文章目录
单例模式
解释
单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)。
形式
- 饿汉式(静态常量)
- 饿汉式(静态代码块)
- 懒汉式(线程不安全)
- 懒汉式(线程安全,同步方法)
- 懒汉式(线程安全,同步代码块)
- 双重检查
- 静态内部类
- 枚举
饿汉式(静态常量)
- 构造器私有化 (防止被new)
- 类的内部创建
- 向外暴露一个静态的公共方法
package singleton;
/**
* @author pangjian
* @ClassName Singleton1
* @Description 饿汉式(静态变量)
* @date 2021/7/2 11:10
*/
public class Singleton1 {
// 构造器私有化,使外界不能new
private Singleton1(){}
// 本内内部创建对象实例
private final static Singleton1 singleton = new Singleton1();
// 提供一个公有的静态方法,返回实例对象
public static Singleton1 getInstance(){
return singleton;
}
}
package singleton;
/**
* @author pangjian
* @ClassName SingletonTest01
* @Description 测试
* @date 2021/7/2 11:06
*/
public class SingletonTest01 {
public static void main(String[] args){
Singleton1 singleton1 = Singleton1.getInstance();
Singleton1 singleton11 = Singleton1.getInstance();
System.out.println(singleton11 == singleton11);
}
}
测试结果:true
优点
优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
缺点
在类装载的时候就完成实例化,没有达到Lazy Loading(懒加载)的效果。如果从始至终从未使用过这个实例,则会造成内存的浪费
饿汉式(静态代码块)
- 先声明,然后把创建单例对象语句放到了静态代码块中
package singleton;
/**
* @author pangjian
* @ClassName Singleton2
* @Description 饿汉式(静态代码块)
* @date 2021/7/2 11:19
*/
public class Singleton2 {
// 构造器私有化,使外界不能new
private Singleton2(){}
// 本内内部创建对象实例
private static Singleton2 singleton;
// 在静态代码块中创建单例对象
static {
singleton = new Singleton2();
}
// 提供一个公有的静态方法,返回实例对象
public static Singleton2 getInstance(){
return singleton;
}
}
package singleton;
/**
* @author pangjian
* @ClassName SingletonTest01
* @Description 测试
* @date 2021/7/2 11:06
*/
public class SingletonTest01 {
public static void main(String[] args){
Singleton2 singleton1 = Singleton2.getInstance();
Singleton2 singleton11 = Singleton2.getInstance();
System.out.println(singleton11 == singleton11);
}
}
测试结果:true
优缺点和上面一样
懒汉式(线程不安全)
- 让调用者使用到实例的时候才去创建,而不是类加载的时候创建
package singleton;
/**
* @author pangjian
* @ClassName Singleton3
* @Description 懒汉式(线程不安全)
* @date 2021/7/2 11:26
*/
public class Singleton3 {
private static Singleton3 singleton3;
private Singleton3(){}
/**
* @Description:第一次调用该方法,会new一个实例,而第二次发现不为空,则不会new,这也使该类只有一个实例
* @return singleton.Singleton3
* @date 2021/7/2 11:30
*/
public static Singleton3 getInstance(){
if(singleton3 == null){
singleton3 = new Singleton3();
}
return singleton3;
}
}
测试代码不贴了,和上面差不多,测试结果:true
优点
起到了Lozy loading的效果,节省内存
缺点
只能在单线程下使用。如果在多线程下,一个线程进入了if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
懒汉式(线程安全,同步方法)
- 使用同步方法
package singleton;
/**
* @author pangjian
* @ClassName Singleton4
* @Description 懒汉式(线程安全,同步方法)
* @date 2021/7/2 11:36
*/
public class Singleton4 {
private static Singleton4 singleton4;
private Singleton4(){}
/**
* @Description:当一个线程进入到同步方法,其他线程只能等待
* @return singleton.Singleton3
* @date 2021/7/2 11:30
*/
public static synchronized Singleton4 getInstance(){
if(singleton4 == null){
singleton4 = new Singleton4();
}
return singleton4;
}
}
优缺点分析
解决了线程不安全问题,但效率太低了,每个线程在想获得类的实例时候,执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了,后面的想获得该类实例,直接return就行了。方法进行同步效率太低,也不推荐使用。
懒汉式(线程安全,同步代码块)
- 把同步方法换成同步代码块
public static synchronized Singleton4 getInstance(){
if(singleton4 == null){
synchronized (Singleton4.class) {
singleton4 = new Singleton4();
}
}
return singleton4;
}
结论
但是这种同步并不能起到线程同步的作用。假如一个线程进入了if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。
双重检查
- 在对该类加一个锁的前提下,再加一层判断
package singleton;
/**
* @author pangjian
* @ClassName Singleton5
* @Description 双重检查
* @date 2021/7/2 12:03
*/
public class Singleton5 {
// volatile保证不同线程对共享变量操作的可见性,也就是说一个线程修改了volatile修饰的变量,当修改写回主内存时,另外一个线程立即看到最新的值。
private static volatile Singleton5 singleton5;
private Singleton5(){}
/**
* @Description:加入双重检查,解决了线程安全问题,同时解决懒加载问题
* @return singleton.Singleton3
* @date 2021/7/2 11:30
*/
public static Singleton5 getInstance(){
if(singleton5 == null){
// 锁住该类,所有访问该类的线程,一次只有一个可以执行。,即使两个线程进入到此,一个线程先进去判断为空就创建单例对象,由于volatile修饰单例对象,第二个进去的时候,判断不为空,则不会创建对象,保留了只有一个单例
synchronized (Singleton5.class) {
if (singleton5 == null) {
singleton5 = new Singleton5();
}
}
}
return singleton5;
}
}
优点
线程安全,延迟加载,效率较高,推荐使用
静态内部类
package singleton;
/**
* @author pangjian
* @ClassName Singleton6
* @Description 静态内部类完成
* @date 2021/7/2 12:30
*/
public class Singleton6 {
private static volatile Singleton6 singleton6;
private Singleton6(){}
/**
* @Description:静态内部类
* @date 2021/7/2 12:32
*/
private static class SingletonInstance{
private static final Singleton6 INSTANCE = new Singleton6();
}
public static Singleton6 getInstance(){
return SingletonInstance.INSTANCE;
}
}
优点
这种方式采用了类装载的机制来保证初始化实例时只有一个线程。静态内部类方式在singleton类被装载时并不会立即实例化,而是在需要实例化时,调用getlnstance方法,才会装载SingletonInstance类,从而完成singleton的实例化。类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM帮助我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。避免了线程不安全,利用静态内部类特点实现延迟加载,效率高,推荐使用
枚举
package singleton;
/**
* @author pangjian
* @ClassName Singleton7
* @Description 枚举
* @date 2021/7/2 12:36
*/
public class Singleton7 {
public static void main(String[] args) {
Singleton instance = Singleton.INSTANCE;
Singleton instance1 = Singleton.INSTANCE;
System.out.println(instance == instance1);
}
}
enum Singleton {
INSTANCE;
}
优点
避免了线程同步问题,而且能防止反序列化重新创建新的对象,大神推荐使用的方式
使用场景
单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)