JAVA----单例模式

1.单例模式概念:

单例模式是一种设计模式,他的核心是确保一个类只有一个实例,单例模式主要有两种方式:饿汉式与懒汉式

2.饿汉式

饿汉就是一个迫切的意思,类加载就会导致该单实例被创建

饿汉式第一种方式:

class Singleton{

//在本类中创建本类对象
    private static Singleton instance=new Singleton();

//提供一个公共的访问方式,让外界获取该对象
    public static Singleton getInstance(){
        return instance;
    }

//私有构造方法
    private Singleton() {
    }
}

我们来对上面这个饿汉式解析一下:

1.私有构造方法,对于构造方法,我们使用private修饰,那么就保证了外界不能通过new这个操作来获取实例

2.饿汉,我们在类里面new一个实例,这个成员变量用private修饰,外界是无法获取的,同时static修饰了他,我们知道静态成员的初始化是在类加载的阶段触发的,所以只要这个类一被加载,那么我们的实例也就创建好了

3.getInstance方法,同样也是static修饰的,这是因为在本类中创建的实例是被static修饰的,普通的方法不能直接去访问,所以要将获取对象的这个方法也用static修饰,Singleton这个类不能构建实例,我们要想获取实例就只能类名.getInstance来获取到实例,然后通过这个实例去调用其他的方法或成员变量

饿汉式第二种方式:

class Singleton2{

private static Singleton2 instance ;

static {
    instance=new Singleton2();
}

//对外提供方法获取该对象
public static Singleton2 getInstance(){
    return instance;
}

    //私有化的构造方法
    private Singleton2() {
    }
}

这种方式和第一种类似,只不过在本类当中创建对象的方式变成了使用静态代码块来创建

饿汉式第三种方式(枚举方式):

public enum Singleton3{
    instance;
}

枚举方式实现单例模式是极力推荐的单例实现模式,因为枚举类型是线程安全的,并且只会装载一次,枚举实现的单例模式是唯一一种不会被破坏的单例实现模式

饿汉式总结说明:

这种方式在成员位置声明Singlleton类型的静态变量,并创建Singleton类的对象instance。instance对象会随着类的加载而创建。如果对象足够大1的话,而一直没有使用就会造成内存的浪费

2.懒汉式

类加载不会导致该单实例对象被创建,而是首次使用才会被创建

懒汉式第一种方式(线程不安全的):

class Singleton3{
//声明成员变量,不进行初始化
    private static Singleton3 instance;

//提供获取对象的方法
    public static Singleton3 getInstance(){
        if(instance==null){
            instance=new Singleton3();
        }
        return instance;
    }

//私有化的构造方法
    private Singleton3() {
    }
}

1.私有化的构造方法,是为了不让外界通过new创建多个实例

2.声明Singleton3类的成员变量不进行初始化

3.由于懒汉式是当我们用到时才去创建对象,所以在调用getinstance方法时才去创建

4.单列模式是一个类只能创建一个对象供外界使用,所以在调用getinstance方法时,getinstance方法内要做一次判断,判断一下instance这个变量是否为空,为空则创建这个实例,不为空则直接return

5.上面这种写法之所以线程不安全,是因为在多线程中,如果线程1调用getinstance这个方法执行到if语句,然后被操作系统调度到线程2,线程2也执行getinstance这个方法,线程2执行完毕后,又调度到线程1的if语句,这时执行new的操作,此时线程1和线程2都单独创建了一个SIngleton3的对象,这时就不满足单例模式只能创建一个对象的原则,所以就是线程不安全的

懒汉式第二种方式(线程安全的):

class Singleton3{
    private static Singleton3 instance;

    public static synchronized Singleton3 getInstance(){
        if(instance==null){
            instance=new Singleton3();
        }
        return instance;
    }
    private Singleton3() {
    }
}

懒汉式线程安全的,只需要在getinstance方法加上synchronized修饰就行了,这是给这个方法加上锁,锁对象是this,这样就保证了当一个线程执行getinstance方法时,不会被其他线程调度走

懒汉式第三种方式(双重检查锁):

为什么要使用双重检查锁,对于上述的两种懒汉式来说,getinstance方法大多数都是在进行读操作,而我们说,多线程里面,读操作是线程安全的,而写操作是线程不安全的,写操作只有new 对象赋值给instance,我们没必要让每个线程必须持有锁才能调用该方法,我们需要调整加锁的时机,来提高性能

class Singleton3{
    private static Singleton3 instance;

    public static synchronized Singleton3 getInstance(){
        if(instance==null){
            synchronized (Singleton3.class){
                if(instance==null){
                    instance=new Singleton3();
                }
            }
        }
        return instance;
    }
    private Singleton3() {
    }
}

1.双重锁模式,只是在前面两种方式的基础上,将getinstance方法就行了修改,首先对instance进行判断,如果instance对象为空,那么就进行抢占锁操作,抢到锁之后,在进行一次判断,如果为空就进行new对象,如果第一次判断,instance不为空,那么说明instance已经创建,直接返回这个对象就行了

对双重检查锁的优化:

在多线程的情况下,双重检查锁,可能会出现空指针问题,出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作,要解决双重检查锁模式带来空指针异常的问题,只需要使用volatile关键字,volatile关键字可以保证可见性和有序性

class Singleton3{
    private static volatile Singleton3 instance;

    public static synchronized Singleton3 getInstance(){
        if(instance==null){
            synchronized (Singleton3.class){
                if(instance==null){
                    instance=new Singleton3();
                }
            }
        }
        return instance;
    }
    private Singleton3() {
    }
}

添加volatile关键字之后,能够保证多线情况下的线程安全也不会有性能问题

懒汉式第四种方式(静态内部类):

静态内部类单例模式中实例有内部类创建,由于JVM在加载外部类的过程中,是不会加载静态内部类的,只有内部类的属性/方法被调用时才会被加载,并初始化其静态属性。静态属性由于被static修饰,保证只被实例化一次,并且严格保证实例化顺序

class Singleton4{
private static class SingletonHolder{
private final static Singleton4 INSTANCE=new Singleton4();    
}

public static Singleton4 getInstance(){
    return SingletonHolder.INSTANCE;
}
    private Singleton4() {
    }
}

说明:

第一次加载SIngleton4类时不会去初始化INSTANCE,只有第一次调用getinstance,虚拟机加载SingletonHolde并初始化INSTANCE,这样不仅能保证线程安全,也能保证Singleton类的唯一性

静态内部类的方式在没有加锁的情况下,保证了线程安全,有没有影响性能和空间的浪费

相关推荐
20岁30年经验的码农12 分钟前
爬虫基础
1024程序员节
licy__32 分钟前
计算机网络IP地址分类,子网掩码,子网划分复习资料
1024程序员节
Chris-zz1 小时前
Linux:磁盘深潜:探索文件系统、连接之道与库的奥秘
linux·网络·c++·1024程序员节
JasonYin~1 小时前
《探索 HarmonyOS NEXT(5.0):开启构建模块化项目架构奇幻之旅 —— 模块化基础篇》
1024程序员节
Teamol20202 小时前
求助帖:ubuntu22.10 auto install user-data配置了为何还需要选择语言键盘(如何全自动)
linux·ubuntu·1024程序员节
尘佑不尘2 小时前
shodan5,参数使用,批量查找Mongodb未授权登录,jenkins批量挖掘
数据库·笔记·mongodb·web安全·jenkins·1024程序员节
SeniorMao0073 小时前
结合Intel RealSense深度相机和OpenCV来实现语义SLAM系统
1024程序员节
网安_秋刀鱼3 小时前
CSRF防范及绕过
前端·安全·web安全·网络安全·csrf·1024程序员节
WW、forever3 小时前
【ArcGIS Pro实操第4期】绘制三维地图
1024程序员节