单例设计模式

1、什么单例设计模式？

保证在一个jvm种，只能存在一个实例，保证对象唯一性。

2、单例设计模式应用场景？

 1.Windows的Task Manager(任务管理器)就是典型的单例模式，想想看，是不是呢，你能打开两个windows task manager吗？

2.网站的计数器，一般也是采用单例模式实现，否则难以同步。

3.应用程序的日志应用，一般都可用单例模式实现，这一般是由于共享的日志一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

4.web应用的配置对象读取，一般也应用单例模式，这个是由于配置文件是共享的资源。

5.数据库连接池的设计一般也是采用单例模式。

6.多线程的线程池的设计一把也是采用单例模式，这是由于线程池要方便对池中的线程进行控制

7.HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例.

3、单例的优缺点？

优点：

    1.在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例，这样就防止其他对象对自己的实例化，确保所有的对象都访问一个实例

    2.单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。

    3.提供了对唯一实例的受控访问。

    4.由于在系统内存中只存在一个对象，因此可以节约系统资源，当需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。

    5.允许可变数目的实例。

    6.避免对共享资源的多重占用。

缺点：

   1.不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。

    2.由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。

    3.单例类的职责过重，在一定程度上违背了“单一职责原则”。

    4.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

4、单例的创建方式

   1. 饿汉式:类初始化时,会立即加载该对象，线程天生安全,调用效率高。

    2. 懒汉式: 类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能。

    3. 静态内部方式:结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载，加载类是线程安全的。

    4. 枚举单例: 使用枚举实现单例模式 优点:实现简单、调用效率高，枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞， 缺点没有延迟加载。

    5. 双重检测锁方式 (因为JVM本质重排序的原因，可能会初始化多次，不推荐使用)

1.使用饿汉式创建单例

public class SingleCaseDemo {
    //饿汉式
    //类初始化的时候，就会创建对象，天生线程安全，调用效率比较高，如果不使用对象的时候，会浪费内存

    //new 出来的对象放进永久区，不会被垃圾回收器回收掉
    private static final SingleCaseDemo singleCaseDemo=new SingleCaseDemo();
    //1.将构造函数私有化
    private SingleCaseDemo(){
    }
    //不会产生线程安全问题 因为加了  static final
    public static SingleCaseDemo getInstance(){
        return singleCaseDemo;
    }
    public static void main(String arg[]){
        SingleCaseDemo s1=SingleCaseDemo.getInstance();
        SingleCaseDemo s2=SingleCaseDemo.getInstance();
        System.out.println(s1==s2);
    }
}

2.懒汉式创建单例

public class SingleCaseDemo {

    //懒汉式
    //类初始化时不会创建该对象，真正需要的时候才会加载（创建），天生线程不安全，需要解决线程安全问题，所以效率比较低

    private static SingleCaseDemo singleCaseDemo;

    //1.将构造函数私有化
    private SingleCaseDemo() {
    }

    public static synchronized SingleCaseDemo getInstance() {
        if (singleCaseDemo == null) {
            singleCaseDemo = new SingleCaseDemo();
        }
        return singleCaseDemo;
    }

    public static void main(String arg[]) {
        SingleCaseDemo s1 = SingleCaseDemo.getInstance();
        SingleCaseDemo s2 = SingleCaseDemo.getInstance();
        System.out.println(s1 == s2);
    }
}

3.使用枚举创建单例

public class SingleCaseDemo {

    //枚举创建单例
    private SingleCaseDemo() {
    }
    public static SingleCaseDemo getInstance() {
        return SingleDemoEnum.INSTANCE.getInstance();
    }
    //枚举本身就是属于单例
    enum SingleDemoEnum {
        INSTANCE;
        private SingleCaseDemo singleCaseDemo;
        SingleDemoEnum() {
            singleCaseDemo = new SingleCaseDemo();
        }
        public SingleCaseDemo getInstance() {
            return this.singleCaseDemo;
        }
    }
    public static void main(String arg[]) {
        SingleCaseDemo s1 = SingleCaseDemo.getInstance();
        SingleCaseDemo s2 = SingleCaseDemo.getInstance();
        System.out.println(s1 == s2);
    }
}

4.使用双重检验锁创建单例

public class UserEntity {
    //使用双重检验锁创建单例模式
    private static UserEntity userEntity;
    private UserEntity() {
    }
    public static UserEntity getInstance() {
        if (userEntity == null) {
            synchronized (UserEntity.class) {
                if (userEntity == null) {
                    userEntity = new UserEntity();
                }
            }
        }
        return userEntity;
    }

    public static void main(String[] args) {
        UserEntity u1 = UserEntity.getInstance();
        UserEntity u2 = UserEntity.getInstance();
        System.out.println(u1 == u2);
    }
}

5 、使用静态内部类创建单例

/**
 * 静态内部类方式
 * 思考懒汉式和饿汉式优缺点
 * 饿汉式优点：天生线程安全，执行效率高 缺点：如果我不使用该对象的时候，比较占内存、没有延迟加载
 * 懒汉式优点：占内存小、具有延迟加载功能。缺点：线程不安全，需要加锁，加锁后执行效率变低了、阻塞、等待。
 *
 * 静态内部类方式结合饿汉式和懒汉式优点，具备延迟加载、天生线程安全、真正需要才会去创建对象。
 */
public class UserEntity {

    public UserEntity(){
        System.out.println("UserEntity对象已经被创建了....");
    }
    //内部类在什么时候会初始化，需要外部类调用内部类才会初始化。
    public static class SingletonClassInstance{
        public static final UserEntity userEntity=new UserEntity();
    }
    public static UserEntity getInstance(){
        return SingletonClassInstance.userEntity;
    }
    public static void main(String[] args){
        UserEntity u1=UserEntity.getInstance();
        UserEntity u2=UserEntity.getInstance();
        System.out.println(u1==u2);
    }
}

QQ群：247394475

关注微信公众号实时获取新内容