JAVA设计模式之单例模式

1.什么是单例模式

单例模式的意思就是只允许存在一个实例。单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,避免频繁创建对象,节约内存,这个类称为单例类。

2. 前提知识

1. static修饰的成员变量或者方法,独立于该类的任何对象。它不依赖类特定的实例,被类的所有实例共享,只要这个类被加载,该成员变量或方法就可以通过类名去进行访问,它的作用是,不用创建对象就可以调用方法或者变量。

2. 使用private修饰的构造方法,不可以直接创建对象,只能通过调用方法获得:如下

public class A {
    public String name;
    // 使用private修饰的构造方法
    private A() {
        System.out.println("方法A被实例化");
    }

    public static A getInstance() {
        return new A();
    }
}

调用

public class B {
    public static void main(String[] args) {
        //这样创建会出错
        //A a = new A();
        // 调用静态方法创建对象实例
        A a = A.getInstance();
        a.name = "aaa";
        System.out.println(a.name);
    }
}

3. 单例分为饿汉式和懒汉式,又称为立即加载和延迟加载。我们可以理解为,饿了有吃的则立刻开吃,懒得动的除非你揍他它才干活。

3. 饿汉式

public class Singleton {
    private static Singleton singleton = new Singleton();
    // 私有化构造方法很重要,单例的重要特点
    private Singleton() {
    }
    // 使用内部静态方法返回实例
    public static Singleton getSingleton() {
        return singleton;
    }
}

在类加载的时候就完成了实例化,避免了多线程的同步问题。缺点是,因为类加载时就实例化了,如果该实例没被使用,则内存浪费

4. 懒汉式

public class Singleton {
    private static Singleton singleton = null;

    private Singleton() {
    }
    // 使用内部静态方法返回实例
    public static Singleton getSingleton() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

懒汉式只有在方法第一次被访问时才会实例化,不会出现内存浪费。这样的方式有个缺点,就是多线程的安全问题(当线程1运行到if判断语句时候,线程2也运行到if语句了,这样会出现两次实例化现象),所以这种写法不可采用。

  4.1 懒汉式改进

public class Singleton {
    private static Singleton singleton = null;

    private Singleton() {
    }
    //搞把锁实现安全
    public static synchronized Singleton getSingleton() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

这样可以保证了同一时刻只能有一个线程访问并获得实例。但是synchronized是修饰整个方法,代价大,每个线程访问都要进行同步,但是实际上不安全的内容出现在实例化代码处,因此我们用synchronized修饰代码块即可,于是还可以再改进。

  4.2 懒汉式再改进

public class Singleton {
    // 注意使用了volatile关键字
    private volatile static Singleton singleton = null;

    private Singleton() {
    }
    // 利用双重检测
    public static Singleton getSingleton() {
        // 如果线程1,2都为空
        if (singleton == null) {
            // 线程1,2都进入到这里
            synchronized (Singleton.class){
                // synchronized保证只有1个线程到这里
                if (singleton == null) {
                    // 空则实例化
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

通过双重检测保证安全,同时锁加在了静态代码块处,效率高。注意的是:singleton对象使用了volatile关键字,为什么使用这个关键字个小知识点。(阿里面试官问过我,volatile关键字那种场合使用。。。当时我是懵逼的,写道这里才知道!!!)

5.通过静态内部类实现

public class Singleton {
    private Singleton() {
    }

    private static class CreateSingleton {
        // 只创建了一次
        private static final Singleton singleton = new Singleton();
    }

    // 使用内部静态方法返回实例
    public static Singleton getSingleton() {
        return CreateSingleton.singleton;
    }
}

6. 总结:

1. 当想实例化一个单例类的时候,通过相应的获取对象的方法来得到,而不是使用 new

2. 单例模式保证了 系统内存中该类只存在一个对象,节省资源

3. 对于频繁操作的对象,创建对象又需要较大的时间开销,则可以使用单例提高性能(如爬虫,爬一个网页就要new一个爬虫,不如改成一个单例来爬,如频繁访问数据库或文件的对象,在spring中jdbc连接)

发布了105 篇原创文章 · 获赞 59 · 访问量 15万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 技术黑板 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览