java设计模式之单例模式
单例模式的定义：
单例模式指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点，属于创建型设计模式。
单例模式的应用场景：
- 需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少GC。
- 某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。
- 频繁访问数据库或者文件的对象。
实际运用中，J2EE标准中的ServletContext和ServletContextConfig、Spring框架应用中的ApplicationContext、Spring中创建的默认bean、数据库连接池、
全局线程池等等都是单例模式。
单例模式的几种实现方式：
1，饿汉式
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(){ } public static SingletonDemo1 getInstance(){ return instance; } public static void main(String[] args) { SingletonDemo1 instance1 = SingletonDemo1.getInstance(); SingletonDemo1 instance2 = SingletonDemo1.getInstance(); System.out.println(instance1==instance2); //返回的结果为true，说明不管取多少次都是同一个实例 } }
2，懒汉式
package singleton; /** * @ClassName SingletonDemo2 * @Description 懒汉式 * 需要使用该对象的时候再去实例化 * 缺点：会产生线程安全问题 * @Author liuyi * @Date 2020/6/7 13:23 * @Version 1.0 */ public class SingletonDemo2 { private static SingletonDemo2 instance; private SingletonDemo2(){ } public static SingletonDemo2 getInstance(){ if(instance==null){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } instance = new SingletonDemo2(); } return instance; } public static void main(String[] args) { //为什么说线程不安全 //因为使用了全局的静态变量，会造成多线程访问的时候会产生不唯一的实例 for (int i = 0; i <100 ; i++) { new Thread(()->{ System.out.println(getInstance()); }).start(); } //打印的对象完全乱了，根本不是同一个实例 } }
3，饿汉式（加锁）
package singleton; /** * @ClassName SingletonDemo2 * @Description 懒汉式（加锁） * 缺点：效率低 * @Author liuyi * @Date 2020/6/7 13:23 * @Version 1.0 */ public class SingletonDemo3 { private static SingletonDemo3 instance; private SingletonDemo3(){ } public synchronized static SingletonDemo3 getInstance(){ if(instance==null){ instance = new SingletonDemo3(); } return instance; } public static void main(String[] args) { //加了锁解决了懒汉式的线程不安全问题，但是这样效率就会明显降低 for (int i = 0; i <100 ; i++) { new Thread(()->{ System.out.println(getInstance()); }).start(); } } }
4，双重检查
package singleton; /** * @ClassName SingletonDemo2 * @Description 双重检查（比较完美的写法） * @Author liuyi * @Date 2020/6/7 13:23 * @Version 1.0 */ public class SingletonDemo4 { //必须加volatile关键字，防止指令重排 private static volatile SingletonDemo4 instance; private SingletonDemo4(){ } public static SingletonDemo4 getInstance(){ //为什么要进行双重检查 //比如两个线程同时进入该方法，都拿到instance为空，其中一个拿到锁并new了一个实例， //此时另外一个线程它并不知道你已经new了实例，所以当它拿到锁之后会继续new一个实例 //所以如果在锁里面继续判断一次是很有必须要的 if(instance==null){ synchronized (SingletonDemo4.class){ if(instance==null){ instance = new SingletonDemo4(); } } } return instance; } public static void main(String[] args) { for (int i = 0; i <100 ; i++) { new Thread(()->{ System.out.println(getInstance()); }).start(); } } }
5，静态内部类方式
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();
}
}
}
6，枚举方式
package singleton; /** * @Author liuyi * @Description 枚举单例 * 不仅可以解决线程同步，还可以防止反序列化(因为枚举类没有构造方法) * @Date 17:28 2020/6/7 * @Param * @return **/ public enum SingletonDemo6 { instance; public void test(){ System.out.println("测试测试"); } public static void main(String[] args) { instance.test(); for (int i = 0; i <100 ; i++) { new Thread(()->{ System.out.println(SingletonDemo6.instance); }).start(); } } }
容器式单例解决大规模生产单例问题：
package com.gupaoedu.vip.pattern.singleton.register; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * 大规模生产单例 */ public class ContainerSingleton { private ContainerSingleton(){} private static Map<String,Object> ioc = new ConcurrentHashMap<String, Object>(); public static synchronized Object getInstance(String className){ Object instance = null; //判断集合中是否有当前对象 if(!ioc.containsKey(className)){ try { //如果没有，通过反射创建对象，并放入map集合中 instance = Class.forName(className).newInstance(); ioc.put(className, instance); }catch (Exception e){ e.printStackTrace(); } return instance; }else{ //如果集合中有，则直接取出来返回 return ioc.get(className); } } }
ThreadLocal单例（线程内单例）：
ThreadLocal不能保证创建的对象是全局唯一的，但是能保证在单个线程中是唯一的，是线程安全的。
package com.gupaoedu.vip.pattern.singleton.threadlocal; /** * ThreadLocal实现线程内单例 */ public class ThreadLocalSingleton { private static final ThreadLocal<ThreadLocalSingleton> threadLocaLInstance = new ThreadLocal<ThreadLocalSingleton>(){ @Override protected ThreadLocalSingleton initialValue() { return new ThreadLocalSingleton(); } }; private ThreadLocalSingleton(){} public static ThreadLocalSingleton getInstance(){ return threadLocaLInstance.get(); } }
单例模式的优点：
- 单例模式可以保证内存中只有一个实例，减少内存的开销。
- 单例模式可以避免对资源的多重占用。
- 单例模式设置全局访问点，可以优化和共享资源的访问。
单例模式的缺点：
- 单例模式一般没有接口，扩展困难，违背开闭原则。
- 单例模式的代码通常写在一个类中，如果设计不合理，则很容易违背单一职责原则。
