乐趣区

关于设计模式:设计模式笔记单例模式

1. 单例设计模式简介

所谓类的单例设计模式,就是采取肯定的办法保障在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个获得其对象实例的办法(静态方法)。比方 Hibernate 的 SessionFactory,它充当数据存储源的代理,并负责创立 Session 对象。SessionFactory 并不是轻量级的,个别状况下,一个我的项目通常只须要一个 SessionFactory 就够,这是就会应用到单例模式。

2. 单例设计模式八种形式

单例模式有八种形式:
(1) 饿汉式 (动态常量)
(2) 饿汉式(动态代码块)
(3) 懒汉式 (线程不平安)
(4) 懒汉式(线程平安,同步办法)
(5) 懒汉式(线程平安,同步代码块)
(6) 双重查看
(7) 动态外部类
(8) 枚举

2.1 饿汉式(动态常量)

饿汉式(动态常量)利用实例步骤如下:
(1) 结构器私有化(避免 new)
(2) 类的外部创建对象
(3) 向外裸露一个动态的公共办法,获取类的实例
(4) 代码实现

// 饿汉式(动态常量)
public class Singleton {
    //1. 结构器私有化
    private Singleton() {}
    //2,本类外部能创建对象实例
    private final static Singleton instance = new Singleton();
    //3. 提供一个私有的静态方法,返回实例对象
    public static Singleton getInstance() {return instance;}
}

public class SingletonTest {public static void main(String[] args) {Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.err.println(instance==instance2);
        System.err.println("instance.hashCode="+instance.hashCode());
        System.err.println("instance2.hashCode="+instance2.hashCode());
    }
}

阐明
(1) 长处:这种写法比较简单,就是在类装载的时候就实现实例化。防止了线程同步问题。
(2) 毛病:在类装载的时候就实现实例化,没有达到 Lazy Loading 的成果。如果从始至终从未应用过这个实例,则会造成内存的节约
(3) 这种形式基于 classloder 机制防止了多线程的同步问题,不过,instance 在类装载时就实例化,在单例模式中大多数都是调用 getInstance 办法,然而导致类装载的起因有很多种,因而不能确定有其余的形式(或者其余的静态方法)导致类装载,这时候初始化 instance 就没有达到 lazy loading 的成果
(4) 这种单例模式可用,可能造成内存节约

2.2 饿汉式(动态代码块)

class Singleton2{
    //1. 结构器私有化
    private Singleton2() {}
    //2,本类外部能创建对象实例
    private static Singleton2 instance;
    static {// 在动态代码块中,创立单例对象
        instance = new Singleton2();}
    //3. 提供一个私有的静态方法,返回实例对象
    public static Singleton2 getInstance() {return instance;}
    
}

阐明:
(1) 这种形式和下面的形式其实相似,只不过将类实例化的过程放在了动态代码块中,也是在类装载的时候,就执行动态代码块中的代码,初始化类的实例。优缺点和下面是一样的。

(2)这种单例模式可用,然而可能造成内存节约

2.3 懒汉式(线程不平安)

class Singleton3{
    private static Singleton3 instance;
    
    private Singleton3() {}
    // 提供一个动态的私有办法,当应用到该办法时,才去创立 instance, 即懒汉式
    public static Singleton3 getInstance() {if(instance==null) {instance = new Singleton3();
        }
        return instance;
    }
}

阐明:
(1) 起到了 Lazy Loading 的成果,然而只能在单线程下应用
(2) 如果在多线程下,一个线程进入了 if (singleton == null) 判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可应用这种形式
(3) 论断:在理论开发中,不要应用这种形式

2.4 懒汉式(线程平安, 同步办法)

class Singleton4{
    private static Singleton4 instance;
    
    private Singleton4() {}
    // 提供一个动态的私有办法,退出同步办法,解决线程平安问题
    public static synchronized Singleton4 getInstance() {if(instance==null) {instance = new Singleton4();
        }
        return instance;
    }
}

阐明:
(1) 解决了线程不平安问题
(2) 效率太低了,每个线程在想取得类的实例时候,执行 getInstance() 办法都要进行同步。而其实这个办法只执行一次实例化代码就够了,前面的想取得该类实例,间接 return 就行了。办法进行同步效率太低
(3) 在理论开发中,不举荐应用这种形式

2.4 懒汉式(线程平安,同步办法)

class Singleton4{
    private static Singleton4 instance;
    
    private Singleton4() {}
    // 提供一个动态的私有办法,退出同步办法,解决线程平安问题
    public static synchronized Singleton4 getInstance() {if(instance==null) {instance = new Singleton4();
        }
        return instance;
    }
}

阐明:
(1) 解决了线程不平安问题
(2) 效率太低了,每个线程在想取得类的实例时候,执行 getInstance() 办法都要进行同步。而其实这个办法只执行一次实例化代码就够了,前面的想取得该类实例,间接 return 就行了。办法进行同步效率太低
(3) 不举荐应用这种形式

2.5 懒汉式(线程平安,同步代码块)

class Singleton5{
    private static Singleton5 instance;
    
    private Singleton5() {}
    // 提供一个动态的私有办法,退出同步解决的代码,解决线程平安问题
    public static Singleton5 getInstance() {if(instance==null) {synchronized (Singleton5.class) {instance = new Singleton5();
            }
        }
        return instance;
    }
}

阐明:
(1) 这种形式,本意是想对第四种实现形式的改良,因为后面同步办法效率太低,改为同步产生实例化的的代码块
(2) 然而这种同步并不能起到线程同步的作用。跟 2.3 种实现形式遇到的情景统一,如果一个线程进入了 if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例
(3) 在理论开发中,不能应用这种形式

2.6 双重查看

ublic class SingletonTest06 {public static void main(String[] args) {System.out.println("双重查看");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
        
    }

}

// 懒汉式(线程平安,同步办法)
class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    // 提供一个动态的私有办法,退出双重查看代码,解决线程平安问题, 同时解决懒加载问题
    // 同时保障了效率, 举荐应用
    
    public static  Singleton getInstance() {if(instance == null) {synchronized (Singleton.class) {if(instance == null) {instance = new Singleton();
                }
            }
            
        }
        return instance;
    }
}

阐明:
(1) Double-Check 概念是多线程开发中常应用到的,如代码中所示,咱们进行了两次 if (singleton == null)查看,这样就能够保障线程平安了
(2) 这样,实例化代码只用执行一次,前面再次拜访时,判断 if (singleton == null),间接 return 实例化对象,也防止的重复进行办法同步
(3) 线程平安;提早加载;效率较高
(4) 在理论开发中,举荐应用这种单例设计模式

2.7 动态外部类

public class SingletonTest07 {public static void main(String[] args) {System.out.println("应用动态外部类实现单例模式");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }

}
// 动态外部类实现,举荐应用
class Singleton {
    private static volatile Singleton instance;
    
    // 结构器私有化
    private Singleton() {}
    
    // 写一个动态外部类, 该类中有一个动态属性 Singleton
    private static class SingletonInstance {private static final Singleton INSTANCE = new Singleton(); 
    }
    
    // 提供一个动态的私有办法,间接返回 SingletonInstance.INSTANCE
    
    public static synchronized Singleton getInstance() {return SingletonInstance.INSTANCE;}
}

阐明:
(1) 这种形式采纳了类装载的机制来保障初始化实例时只有一个线程。
(2) 动态外部类形式在 Singleton 类被装载时并不会立刻实例化,而是在须要实例化时,调用 getInstance 办法,才会装载 SingletonInstance 类,从而实现 Singleton 的实例化。
(3) 类的动态属性只会在第一次加载类的时候初始化,所以在这里,JVM 帮忙咱们保障了线程的安全性,在类进行初始化时,别的线程是无奈进入的。
(4) 长处:防止了 线程不平安,利用动态外部类特点实现提早加载,效率高
(5) 举荐应用

2.8 枚举

public class SingletonTest08 {public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);
        
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
        
        instance.sayOK();}
}

// 应用枚举,能够实现单例, 举荐
enum Singleton {
    INSTANCE; // 属性
    public void sayOK() {System.out.println("ok~");
    }
}

阐明:
(1) 这借助 JDK1.5 中增加的枚举来实现单例模式。不仅能防止多线程同步问题,而且还能避免反序列化从新创立新的对象。
(2) 这种形式是 Effective Java 作者 Josh Bloch 提倡的形式

3. 单例模式注意事项和细节阐明

(1) 单例模式保障了 零碎内存中该类只存在一个对象,节俭了系统资源,对于一些须要频繁创立销毁的对象,应用单例模式能够进步零碎性能
(2) 当想实例化一个单例类的时候,必须要记住应用相应的获取对象的办法,而不是应用 new
(3) 单例模式应用的场景:须要频繁的进行创立和销毁的对象、创建对象时耗时过多或消耗资源过多(即:重量级对象),但又常常用到的对象、工具类对象、频繁拜访数据库或文件的对象(比方数据源、session 工厂等)

退出移动版