当前位置：首页 > article >正文

JAVA----单例模式

article 2024/10/25 22:07:50

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() {
    }
}