单例模式

有如下五中方式可以实现单例模式

饿汉

概念

恶汉模式，在成员变量声明时就会创建对象，也就是类被首次加载时就会创建对象

优劣势

优:

不存在线程安全问题

劣:

因为首次加载即创建，所以如果对象较大可能会拖慢程序启动速度

代码

public class HungrySingletom implements Print {
    private HungrySingletom() {
    }

    private static HungrySingletom INSTANCE = new HungrySingletom();

    public static HungrySingletom getInstance() {
        return INSTANCE;
    }

    @Override
    public void printSomeThing() {
        System.out.println("恶汉打印数据");
    }
}

class Client {
    public static void main(String[] args) {
        HungrySingletom.getInstance().printSomeThing();
    }
}

懒汉

需要的时候才去创建，缺点是默认线程不安全

线程不安全懒汉

概念

初始变量为空，当我们获取的时候如果静态实例为空则创建一个对象。

如果我们在多线程中去获取单例对象则是线程不安全的，极有可能会创建多个实例

代码

本例中我们给getInstance方法加上了synchronized关键字，这样就可以保证了获取单例方法的线程安全。

在调用的时候我们会for循环创建200个线程打印对象地址，最终结果打印对象地址相同，没有出现线程不安全问题。


public class LazyThreadSafeSingleTon implements Print, Print1 {
    private static LazyThreadSafeSingleTon instance = null;

    private LazyThreadSafeSingleTon() {
    }

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

    @Override
    public void printSomeThing() {
        System.out.println("线程安全懒汉单例");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 200; i++) {
            final int index = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    LazyThreadSafeSingleTon myInstance = LazyThreadSafeSingleTon.getInstance();
                    myInstance.printMsg("索引：" + index + "   " + myInstance.toString());
                }
            }).start();
        }
    }

    @Override
    public void printMsg(String msg) {
        System.out.println(msg);
    }
}

线程安全懒汉

方法加锁实现线程安全单例

在获取单例的方法上加上synchronized锁，实现线程安全

优劣势

优势: 使用的时候再初始化，可以加快初始化时间

劣势在方法上加上了synchronized所以每次获取实例的时候都会加锁，当频繁获取实例的时候会明显降低效率。解决办法是使用双检索单例。

代码


public class LazyThreadSafeSingleTon implements Print, Print1 {
    private static LazyThreadSafeSingleTon instance = null;

    private LazyThreadSafeSingleTon() {
    }

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

    @Override
    public void printSomeThing() {
        System.out.println("线程安全懒汉单例");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 200; i++) {
            final int index = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    LazyThreadSafeSingleTon myInstance = LazyThreadSafeSingleTon.getInstance();
                    myInstance.printMsg("索引：" + index + "   " + myInstance.toString());
                }
            }).start();
        }
    }

    @Override
    public void printMsg(String msg) {
        System.out.println(msg);
    }
}

双检索方式实现单例

双检索代码理解

一下文字是对下面代码的说明

线程1第一次获取实例 线程第一次调用的时候会先进入第一重判断，此时instance为空，进入加锁代码。然后进入第二重判断，此时instance仍然为空，开始初始化。

线程2在线程1初始化过程中获取实例 因为实例尚没有初始化，所以线程2第一重判断instance为空，二此时线程1正在初始化所以线程2要等待锁。延迟后线程1释放锁，线程1进入锁内并进行第二重判断。因为线程1已经初始化了，所以此时instance不为空，所以不进入第二重判断。直接跳到返回实例的代码

线程3在线程1、2完成后进入 线程3进入第一重判断，此时instance不为空，直接跳到返回instance部分

为什么一定要加volatie关键字

将我很久以前写的列举发一下吧，目前我仍然觉得写的没问题

代码


public class DoubleLockThreadSafeSingleTon implements Print1 {
    private static volatile DoubleLockThreadSafeSingleTon instance;//volatie是必须的
    private DoubleLockThreadSafeSingleTon(){}

    public static DoubleLockThreadSafeSingleTon getInstance() {
        if(instance==null){//第一重判断
            synchronized (DoubleLockThreadSafeSingleTon.class){//加锁
                if (instance==null){//第二重判断
                    instance=new DoubleLockThreadSafeSingleTon();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i=0;i<200;i++){
            System.out.println(DoubleLockThreadSafeSingleTon.getInstance().toString());
        }
    }

    @Override
    public void printMsg(String msg) {
        System.out.println(msg);
    }
}

静态内部类

理解

本例代码中StaticClassSingleton实例在StaticClassSingletonHolder的静态变量中初始化

优劣势

优势在不使用锁的情况下实现了单例模式

劣势需要多创建一个内部类

代码


public class StaticClassSingleton implements Print {
    private StaticClassSingleton() {
    }

    public static StaticClassSingleton getInstance() {
        return StaticClassSingletonHolder.instance;
    }

    static class StaticClassSingletonHolder {
        static StaticClassSingleton instance = new StaticClassSingleton();
    }

    @Override
    public void printSomeThing() {
        System.out.println("静态内部类实现单例");
    }

    public static void main(String[] args) {
        StaticClassSingleton.getInstance().printSomeThing();
    }
}

枚举

很多人可能是不知道的，枚举实例中是可以编写方法代码的，根据这种方式我们可以巧妙的实现单例模式。

优劣势

优势不需要锁就可以实现单例劣势暂未想到

代码

public enum EnumSingleton implements Print {
    INSTANCE,DEFAULT;

    @Override
    public void printSomeThing() {
        System.out.println(name());
    }

    public static void main(String[] args) {
        EnumSingleton.INSTANCE.printSomeThing();
        EnumSingleton.DEFAULT.printSomeThing();
    }
}

扩展枚举代码变种实现路由

我们可以在枚举中定义方法，然后再实例中重写该方法，从而实现不同的枚举实例有自己的行为


public enum EnumSingleton implements Print {
    INSTANCE{
        @Override
        public void action(){
            System.out.println("INSTANCE单例方法");
        }
    },DEFAULT{
        @Override
        public void action(){
            System.out.println("DEFAULT单例方法");
        }
    };

    @Override
    public void printSomeThing() {
        System.out.println(name());

    }

    public static void main(String[] args) {
        EnumSingleton.INSTANCE.printSomeThing();
        EnumSingleton.DEFAULT.printSomeThing();
        EnumSingleton.INSTANCE.action();
        EnumSingleton.DEFAULT.action();
    }

    public void action() {

    }
}

设计模式-单例模式