java设计模式之单例模式

package singleton;

/**
 * @ClassName SingletonDemo1
 * @Description 饿汉式
 * 类加载到内存后，就实例化一个单例对象，JVM保证线程安全
 * 唯一缺点：不管用不用都会进行加载，但是影响不大，实际上是最适用的一种方式
 * @Author liuyi
 * @Date 2020/6/7 12:22
 * @Version 1.0
 */
public class SingletonDemo1 {
    //两种方式初始化实例,两种方式的效果是一样的
    静态常量方式
    private static final SingletonDemo1 instance = new SingletonDemo1();
    静态块方式
    private static final SingletonDemo1 instance;
    static {
        instance = new SingletonDemo1();
    }
    private SingletonDemo1(){

    }
     SingletonDemo1 getInstance(){
        return instance;
    }

    void main(String[] args) {
        SingletonDemo1 instance1 = SingletonDemo1.getInstance();
        SingletonDemo1 instance2 = SingletonDemo1.getInstance();
        System.out.println(instance1==instance2);
        返回的结果为true，说明不管取多少次都是同一个实例
    }
}

 * @ClassName SingletonDemo2
 * @Description 懒汉式
 * 需要使用该对象的时候再去实例化
 * 缺点：会产生线程安全问题
 * @Author liuyi
 * @Date 2020/6/7 13:23
 * @Version 1.0
  SingletonDemo2 {
     SingletonDemo2 instance;

     SingletonDemo2(){

    }

     SingletonDemo2 getInstance(){
        if(instance==null){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance =  SingletonDemo2();
        }
         main(String[] args) {
        为什么说线程不安全
        因为使用了全局的静态变量，会造成多线程访问的时候会产生不唯一的实例
        for (int i = 0; i <100 ; i++) {
            new Thread(()->{
                System.out.println(getInstance());
            }).start();
        }
        打印的对象完全乱了，根本不是同一个实例
    }
}

 * @ClassName SingletonDemo2
 * @Description 懒汉式（加锁）
 * 缺点：效率低
 * @Author liuyi
 * @Date 2020/6/7 13:23
 * @Version 1.0
  SingletonDemo3 {
     SingletonDemo3 instance;

     SingletonDemo3(){

    }

    synchronized  SingletonDemo3 getInstance(){
        ){
            instance =  SingletonDemo3();
        }
        加了锁解决了懒汉式的线程不安全问题，但是这样效率就会明显降低
        {
                System.out.println(getInstance());
            }).start();
        }
    }
}

 * @ClassName SingletonDemo2
 * @Description 双重检查（比较完美的写法）
 * @Author liuyi
 * @Date 2020/6/7 13:23
 * @Version 1.0
  SingletonDemo4 {
    必须加volatile关键字，防止指令重排
    volatile SingletonDemo4 instance;

     SingletonDemo4(){

    }

     SingletonDemo4 getInstance(){
        为什么要进行双重检查
        比如两个线程同时进入该方法，都拿到instance为空，其中一个拿到锁并new了一个实例，
        此时另外一个线程它并不知道你已经new了实例，所以当它拿到锁之后会继续new一个实例
        所以如果在锁里面继续判断一次是很有必须要的
        synchronized (SingletonDemo4.){
                ){
                    instance =  SingletonDemo4();
                }
            }
        }
        {
                System.out.println(getInstance());
            }).start();
        }
    }
}

package com.liuyi.entity;

/**
 * @ClassName SingletonDemo5
 * @Description 静态内部类方式
 * JVM保证线程安全
 * 加载外部类是不会加载内部类，实现了懒加载
 * 最完美的写法
 * @Author liuyi
 * @Date 2020/6/7 13:52
 * @Version 1.0
 */
public class SingletonDemo5 {

    private SingletonDemo5(){
        //防止恶意通过反射破坏单例        
　　　　 if(SingletonDemo5Inside.instance!=null){
            throw new RuntimeException("不允许创建多个实例");
        }
    }
    private static class SingletonDemo5Inside{
        private static final SingletonDemo5 instance = new SingletonDemo5();
    }

    public static SingletonDemo5 getInstance(){
        return SingletonDemo5Inside.instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i <100 ; i++) {
            new Thread(()->{
                System.out.println(SingletonDemo5.getInstance());
            }).start();
        }
    }
}

?

 * @Author liuyi
 * @Description 枚举单例
 * 不仅可以解决线程同步，还可以防止反序列化(因为枚举类没有构造方法)
 * @Date 17:28 2020/6/7
 * @Param  
 * @return 
 *enum SingletonDemo6 {

    instance;

     test(){
        System.out.println("测试测试");
    }
     main(String[] args) {
        instance.test();
        {
                System.out.println(SingletonDemo6.instance);
            }).start();
        }
    }
}

 com.gupaoedu.vip.pattern.singleton.register;

import java.util.Map;
 java.util.concurrent.ConcurrentHashMap;


 * 大规模生产单例
  ContainerSingleton {

     ContainerSingleton(){}

    static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();

    synchronized Object getInstance(String className){
        Object instance = ;
        判断集合中是否有当前对象
        if(!ioc.containsKey(className)){
             {
                如果没有，通过反射创建对象，并放入map集合中
                instance = Class.forName(className).newInstance();
                ioc.put(className,instance);
            } (Exception e){
                e.printStackTrace();
            }
             instance;
        }else{
            如果集合中有，则直接取出来返回
             ioc.get(className);
        }
    }

}

 com.gupaoedu.vip.pattern.singleton.threadlocal;


 * ThreadLocal实现线程内单例
  ThreadLocalSingleton {
    final ThreadLocal<ThreadLocalSingleton> threadLocaLInstance =
            new ThreadLocal<ThreadLocalSingleton>(){
                @Override
                protected ThreadLocalSingleton initialValue() {
                    return  ThreadLocalSingleton();
                }
            };

     ThreadLocalSingleton(){}

     ThreadLocalSingleton getInstance(){
         threadLocaLInstance.get();
    }
}