并发（五）-单例模式

这里系统的说一下单例模式。

本文参考的文章,地址如下：

微信公众号：Java后端技术

文章：Java多线程编程-（12）-单例模式几种写法的错与对

作者：徐刘根

主要是四大类：饿汉、懒汉、双重校验锁DCL、

1.饿汉模式

示例如下：

public class Singleton {

    /*为了防止外部访问，所以实例是private的
    为了在static方法中访问，所以必须是static
    至于为什么，叫饿汉模式。我想，因为在程序走到下面这一行时，
    会初始化，调用构造方法。在没有调用getInstance方法时，就创建好了实例。
    因为，可能叫做饿汉模式吧*/
    private static Singleton singleton = new Singleton();
    
    private Singleton() {
        System.out.println("666");
    }
    public static Singleton getInstance() {
        return singleton;
    }
}

2.懒汉模式

示例如下：

public class SingletonByLazy {

    private static SingletonByLazy singleton;
    
    /*这里必须是private修饰符，否则，就可以new多个对象，这是单例模式最基本的保证*/
    private SingletonByLazy() {}
    
    /*需要注意的是，必须加上synchronized关键字。否则会导致对象的访问变得不安全。
     * 饿汉的优点是延迟加载，在你需要的时候进行加载。缺点是必须使用同步*/
    public static synchronized SingletonByLazy getInstance() {
        if (singleton == null) {
            singleton = new SingletonByLazy();
        }
        return singleton;
    }
}

3.双重校验锁DCL

代码比上面两种多一些，绕一些，但是思想还是值得学习的嘛！看下面的例子：

public class SingletonByDCL {

    /*这里切记，volatile关键字不可以缺少。
     * 不然会因为指令重排，导致在第一个判空时，将未初始化的对象返回。*/
    private volatile static SingletonByDCL singleton;
    
    /*这里必须是private修饰符，否则，就可以new多个对象，这是单例模式SingletonByLazy.java最基本的保证*/
    private SingletonByDCL() {}
    
    /*需要注意的是，必须加上synchronized关键字。否则会导致对象的访问变得不安全。
     * 饿汉的优点是延迟加载，在你需要的时候进行加载。缺点是必须使用同步*/
    public static SingletonByDCL getInstance() {
        if (singleton == null) {
            synchronized (SingletonByDCL.class) {
                if (singleton == null) {
                    singleton = new SingletonByDCL();
                }
            }
        }
        return singleton;
    }
}

4.静态内部类

public class SingletonByStaticClass {

    /*通过类加载机制，保证创建单一对象*/
    private static class SingletonHolder {
        private static final SingletonByStaticClass single = new SingletonByStaticClass();
    }
    
    private SingletonByStaticClass() {}
    
    /*对于JAVA的加载机制来说，当第一次访问类的静态字段时，会触发类的加载*/
    public static SingletonByStaticClass getInstance() {
        return SingletonHolder.single;
    }
}

接下来，我要单独说一下static关键字。因为非常重要。

小例子：

public class Test {

    public void method01(){
        System.out.println("method01");
    }
    
    public static void method02(){
        System.out.println("method02");
    }
    
    public static void main(String args[]){
        new Test().method01();
        method02();
    }
}


执行结果：
method01
method02

例子很简单，但是要说明的地方是：静态方法中不能直接调用非静态方法。

为什么呢?首先static的成员是在类加载的时候初始化的，而非static的成员是在创建对象的时候初始化的。先后顺序是，先加载才能初始化。那么加载的时候，初始化static成员，非static成员是在创建对象的时候初始化的。也就是说，static属于类，而非static属于对象。

下面说static的特点：

1.随着类的加载而加载，随着类的消失而消失（能消失吗？ 这里我有疑问，有待验证）。

2.静态先存在，对象后存在。

3.被所有对象共享。

4.直接调用

使用时注意事项：

1.静态方法只能方法静态成员。

2.静态方法中不能使用super  this 关键字。原因呢，上方的解释，懂了的话，这一点自然就明白了。

3.主函数是静态的。

就说这么多了。。。