java设计模式系列之《一》----- 单例模式

单例模式-----饿汉模式（执行效率高但是会有资源的浪费，因为只在启动时创建实例，所以不存在线程安全问题）

/**
 * 功能描述: 单例模式-----饿汉模式（执行效率高但是会有资源的浪费，因为只在启动时创建实例，所以不存在线程安全问题）
 * @date: 2019/8/6
 */
public class Order {

    //JVM保证类的静态成员只能被加载一次
    public static Order order = new Order();

    private Order() {
    }

    public static Order getInstance() {
        return order;
    }
}

单例模式-----懒汉模式（线程安全但是效率会有影响,推荐DCL）

/**
 * 功能描述: 单例模式-----懒汉模式（线程安全但是效率会有影响,推荐DCL）
 * @date: 2019/8/6
 */
public class OrderLazy {

    public static OrderLazy orderLazy;

    private OrderLazy() {};


    //写法有问题，一直new对象肯定不是单例的
//    public static OrderLazy getInstance() {
//        if(null == orderLazy) {
//            return new OrderLazy();
//        }
//        else return orderLazy;
//    }


    //--------加锁，线程安全但是效率会有影响
//    public static synchronized OrderLazy getInstance() {
//        if (null == orderLazy) {
//            orderLazy = new OrderLazy();
//        }
//        return orderLazy;
//    }

    //DCL双重检查锁的机制，第一个判断排除了已经有实例的情况，但是多线程环境下
    //若当前没有OrderLazy实例，则可能有多个线程进入第一个if判断
    //此时加锁，第一个线程进入会创建OrderLazy实例，但是一同进来的第一层if条件下的
    //其他线程也会创建新的实例，所以才会有第二层if，保证只有一个线程创建了OrderLazy实例
    public static OrderLazy getInstance() {//----------------多线程环境下的懒汉单例模式推荐
        if(null == orderLazy) {
            synchronized (OrderLazy.class) {
                if(null == orderLazy) {
                    orderLazy = new OrderLazy();
                }
            }
        }
        return orderLazy;
    }
}

单例模式-----静态内部类（推荐，线程安全,不浪费空间）

/**
 * 功能描述: 单例模式-----静态内部类（推荐，线程安全,不浪费空间）
 * @date: 2019/8/6
 */
public class OrderStatic {

    private OrderStatic () {};

    //懒加载--类加载时，其内部类不会同时被加载，只有在其静态成员被调用才会发生
    public static class OrderStaticSon {
        //线程安全--JVM保证了类的静态成员只会加载一次
        public static OrderStatic orderStatic = new OrderStatic();
    }

    public static OrderStatic getInstance() {
        return OrderStaticSon.orderStatic;
    }

}

 

 

单例模式测试类

**
 * 功能描述: 单例模式测试类
 * @date: 2019/8/6
 */
public class OrderTest {

    public static void main(String[] args) {

        ThreadOrder[] ThreadArr = new ThreadOrder[10];
        for (int i = 0; i < ThreadArr.length; i++) {
            ThreadArr[i] = new ThreadOrder();
            ThreadArr[i].start();
        }
    }

}

// 测试线程--十个线程测试，通过对象的hashcode是否相同判断是单例还是多例
class ThreadOrder extends Thread {
    @Override
    public void run() {
        System.out.println(OrderStatic.getInstance().hashCode());
    }
}

项目中最佳实践一般是配置类的单例，如：RedisConfig,AlipayConfig