JAVA设计模式

一、单例模式

1、单例模式

采取一定的方法,保证在整个软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)

① 饿汉式(静态常量)

​ 优点:写法简单、类装载时就完成实例化、避免了线程同步问题

​ 缺点:可能造成内存资源浪费

/**
 * 饿汉式(静态常量)
 */
class Single1JingTai{
    //1.私有化构造器
    private Single1JingTai(){
    }
    //2.本类内部创建对象实例
    private  final static Single1JingTai INIT = new Single1JingTai();
    //3.提供一个公有的静态方法,返回实例对象,供外部调用
    public static Single1JingTai getInstance(){
        return INIT;
    }
}
②饿汉式(静态代码块)

​ 第一种类似

​ 优点:写法简单、类装载时就完成实例化、避免了线程同步问题

​ 缺点:可能造成内存资源浪费,

/**
 * 饿汉式(静态代码块)
 */
class Single1Static {
    //私有化构造器;
    private Single1Static() {
    }
    //声明对象;
    private static Single1Static init;
    //静态代码块创建对象;
    static {
        init = new Single1Static();
    }
    //提供对外的调用接口,返回对象
    public static Single1Static getInstance() {
        System.out.println("INIT = " + init);
        return init;
    }
}
③懒汉式(线程不安全)

​ 优点:起到了懒加载的作用,但是只能在单线程使用

​ 缺点:多线程时,判断的地方可能会因此产生多个实例对象

/**
 * 饿汉式(线程不安全)
 */
class SingleE1 {
    //私有化构造器
    private SingleE1() {
    }
    //声明对象;
    private static SingleE1 init;
    //当调用方法时,才会创建对象
    public static SingleE1 getInstance() {
        //多线程时-->可能判断失误
        if (init == null) {
            init = new SingleE1();
        }
        return init;
    }
}
④懒汉式(线程安全、同步方法)

​ 优点:解决了线程不安全的问题

​ 缺点:每次都要经过同步,效率低

/**
 * 饿汉式(synchronized同步方法)
 */
class SingleE2 {
    //私有化构造器
    private SingleE2() {
    }
    //声明对象;
    private static SingleE2 init;
    //当调用方法时,才会创建对象,synchronized同步方法,但效率低
    public synchronized static SingleE2 getInstance() {
        if (init == null) {
            init = new SingleE2();
        }
        return init;
    }
}
⑤懒汉式(双检锁)

​ 优点:满足延迟加载,效率较高,推荐使用

/**
 * 饿汉式(双检锁)
 */
class SingleE3 {
    //私有化构造器
    private SingleE3() {
    }
    //声明对象; volatile-->"禁止指令重排序”(指令重排序会干扰程序的并发执行)
    private static volatile SingleE3 init;
    //当调用方法时,才会创建对象,先判断对象是否创建,创建则返回对象,
    // 否则进入同步方法,再次判断是否是否创建对象,创建则返回对象,否则创建对象并返回
    public static  SingleE3 getInstance() {
        if (init == null) {
            synchronized (SingleE3.class){
                if (init == null){
                    init = new SingleE3();
                }
            }
        }
        return init;
    }
}
⑥懒汉式(静态内部类)

​ 优点:这种方式采用了类装载的机制,来保证初始化实例时只有一个对象,

​ 避免了线程不安全、利用静态内部类特点实现延迟加载,效率高。

/**
 * 饿汉式(静态内部类)
 */
class SingleE4 {
    //私有化构造器;
    private SingleE4() {
    }
    //外部类SingeE4加载的时候,不会导致内部类getSingE4的加载;
    private static class getSingE4{
        private static final SingleE4  INIT = new SingleE4();
    }
    //当调用getInstance的方法,调用内部类的属性,才实例化;
    public static  SingleE4 getInstance() {
        return getSingE4.INIT;
    }
}
⑦懒汉式(枚举)

​ 优点:通过枚举来实现单例模式,不仅避免了多线程问题,而且还能防止反序列化重新创建新的对象(推荐使用)

/**
 * 饿汉式(枚举)
 */
enum SingleE5 {
    INIT;
}