Java设计模式（一）之单例模式

一、概述

单例模式的定义就是确保某一个类只有一个实例，并且提供一个全局访问点。属于设计模式三大类中的创建型模式。
单例模式具有典型的三个特点：

• 只有一个实例。
• 自我实例化。
• 提供全局访问点。

二、优缺点

优点：由于单例模式只生成了一个实例，所以能够节约系统资源，减少性能开销，提高系统效率，同时也能够严格控制客户对它的访问。
缺点：也正是因为系统中只有一个实例，这样就导致了单例类的职责过重，违背了“单一职责原则”，同时也没有抽象类，这样扩展起来有一定的困难。

三，实现

饿汉式：线程安全，调用效率高。但是不能延时加载。示例：

package com.sec.danli;

/**
 * 单例模式：确保一个类只有一个实例，并且自行实例化向整个系统提供这个实例
 *
 * 饿汉式单例模式
 */
public class Hungry {

    private Hungry(){

    }

    private static final  Hungry hungry=new Hungry();

    public static Hungry getInstance(){
        return hungry;
    }

}

由于该模式在加载类的时候对象就已经创建了，所以加载类的速度比较慢，但是获取对象的速度比较快，且是线程安全的。
懒汉式：线程不安全。示例：

public class SingletonDemo2 {

    //线程不安全的

    private static SingletonDemo2 instance = null;

    private SingletonDemo2() {
    }

    //运行时加载对象
    public static SingletonDemo2 getInstance() {
        if (instance == null) {
            instance = new SingletonDemo2();
        }
        return instance;
    }

}

由于该模式是在运行时加载对象的，所以加载类比较快，但是对象的获取速度相对较慢，且线程不安全。如果想要线程安全的话可以加上synchronized关键字，但是这样会付出惨重的效率代价。

懒汉式（双重同步锁）

package com.sec.danli;
/**
 * 懒汉式单例模式
 */
public class lazyMain {

    private lazyMain(){
        System.out.println(Thread.currentThread().getName()+"单例模式");
    }


    private static  lazyMain lazymain;

    //双层检测锁模式，DLC懒汉式
    public static lazyMain getInstance(){

        if(lazymain==null)
        {
            synchronized (lazyMain.class)
            {
                if(lazymain==null)
                {
                    lazymain =new lazyMain();//不是一个原子性操作

                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     */
                }
            }
        }
        return lazymain;
    }

    //多线程并发测试，正常
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
             lazyMain.getInstance();
            }).start();
        }
    }

}

静态内部类实现（线程安全）

package com.sec.danli;

/**
 * 静态内部类,线程安全
 */
public class Holder {
    private Holder(){

        System.out.println("静态内部类");
    }

    public static Holder getInstance(){
        return InnerClass.holder;
    }

    //静态内部类
    private static class InnerClass{

        private static final Holder holder=new Holder();

    }

    //测试
    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                    Holder.getInstance();
        }).start();
        }

    }


}

注：注意单例模式所属类的构造方法是私有的，所以单例类是不能被继承的。

四、常见应用场景

• 网站计数器。
• 项目中用于读取配置文件的类。
• 数据库连接池。因为数据库连接池是一种数据库资源。
• Spring中，每个Bean默认都是单例的，这样便于Spring容器进行管理。
• Servlet中Application
• Windows中任务管理器，回收站。
  常用

    private ClassInProperties classInProperties = SpringUtil.getBean(ClassInProperties.class);

    private static final ClassInHttpUtil CLASS_IN_HTTP_UTIL = new ClassInHttpUtil();

    private ClassInHttpUtil(){}

    public static ClassInHttpUtil getClassInHttpUtil(){
        return CLASS_IN_HTTP_UTIL;
    }

    public String httpGetEncryptRequest(ClassInRequestEnum methods, Map<String, Object> paramMap)  {
        Integer timeInMillis = Func.toInt((DateTime.now().getMillis() / 1000));
        paramMap.put("SID", classInProperties.getSId());
        paramMap.put("safeKey",  encryption(classInProperties.getKey()+timeInMillis));
        paramMap.put("timeStamp", timeInMillis);

        //链式构建请求
        String body = HttpRequest.post(classInProperties.getUrl() + "?action=" + methods)
                .form(paramMap)
                .timeout(20000)
                .execute().body();

        return UnicodeUtil.toString(body);
    }