java设计模式-单例模式

最新推荐文章于 2024-07-31 10:24:41 发布

冰山丶

最新推荐文章于 2024-07-31 10:24:41 发布

阅读量186

点赞数

分类专栏： Java设计模式文章标签：设计模式 java

本文链接：https://blog.youkuaiyun.com/weixin_44877218/article/details/104996067

版权

Java设计模式专栏收录该内容

10 篇文章

订阅专栏

JAVA设计模式单例模式

介绍
1. 设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通用解决方案，设计模式代表了最佳的实践。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
2. 设计模式的本质是提高软件的维护性，通用性和拓展性，并降低软件的复杂度
设计模式的类型
1. 创建型模式：单利模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
2. 结构性模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
3. 行为模式：模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式（责任链模式）

单利模式

介绍
- 所谓类的单例模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。
- 比如Hibernate的sessionFactory，它充当数据存储源的代理，并负责创建session对象。SessionFactroy并不是一个轻量级的，一般情况下，一个项目通常只需要一个SessionFactroy就够，这时就会用到单利模式。
单例模式的八种方式
1. 饿汉式（静态常量）
2. 饿汉式（静态代码块）
3. 懒汉式（线程不安全）
4. 懒汉式（线程安全，同步方法）
5. 懒汉式（线程安全，同步代码块）
6. 双重检查
7. 静态内部类
8. 枚举
饿汉式（静态常量）应用实例
- 步骤：
  - 构造器私有化
  - 类的内部创建对象
  - 向外暴露一个静态的公共方法
  - 代码实现
- 代码
```
  public class SingletonTest01{
  
  	public static void main(String[] args) {
  		Singleton instance1=Singleton.getInstance();
  		Singleton instance2=Singleton.getInstance();
  		System.out.println(instance1==instance2);//true
  		System.out.println(instance1.hashCode()==instance2.hashCode());
  	}
  
  }
  //饿汉式静态变量
  class Singleton{
  	//构造器私有化外部不能new对象
  	private Singleton(){
  		
  	}
  	//本部内部类创建对象实例
  	private final static Singleton instance=new Singleton();
  	//提供一个公有的方法返回实例对象
  	public static Singleton getInstance() {
  		return instance;
  	}
  	
  }	
```
- 优缺点：
  - 优点：这种写法比较简单，就是在类装载的时候完成实例化。避免线程同步问题。
  - 缺点：在类装载的时候完成实例化，没有达到lazy loading的效果。如果从始至终从未使用这个实例，则会造成内存浪费。
  - 这种方式基于classloder机制避免了多线程同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他方式（或有其他的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果
  - 结论：这种单例模式可能造成内存浪费。

饿汉式的静态代码块

代码

  public class SingletonTest02{
  
  	public static void main(String[] args) {
  		Singleton02 instance1=Singleton02.getInstance();
  		Singleton02 instance2=Singleton02.getInstance();
  		System.out.println(instance1==instance2);//true
  		System.out.println(instance1.hashCode()==instance2.hashCode());
  	}
  
  }
  //饿汉式静态代码块
  class Singleton02{
  	//构造器私有化外部不能new对象
  		private Singleton02(){
  			
  		}
  		//本部内部类创建对象实例
  		private  static Singleton02 instance;
  		static {//静态代码块创建单例对象
  			instance=new Singleton02();
  		}
  		//提供一个公有的方法返回实例对象
  		public static Singleton02 getInstance() {
  			return instance;
  		}
  	
  }

优缺点
- 这种方式和静态变量的方式类似，只不过是将实例化的过程放在了静态代码块中，也是在类加载的时候，就执行静态代码块中的代码，初始化类的实例，
- 结论：这种单例模式可用，但是可能造成内存浪费。

懒汉式（线程不安全）

代码

  public class SingletonTest03{
  
  	public static void main(String[] args) {
  		Singleton03 instance1=Singleton03.getInstance();
  		Singleton03 instance2=Singleton03.getInstance();
  		System.out.println(instance1==instance2);//true
  		System.out.println(instance1.hashCode()==instance2.hashCode());
  	}
  
  }
  
  class Singleton03{
  	//本部内部类创建对象实例
  	private  static Singleton03 instance;
  	//私有化构造函数
  	private Singleton03(){
  
  	}
  	//提供一个公有的方法返回实例对象当使用这个方法的时候才去创建这个实例对象
  	public static Singleton03 getInstance() {
  		if(instance==null) {
  			instance=new Singleton03();
  		}
  		return instance;
  	}
  
  }

优缺点：
- 起到了lazy loading的效果，但是只能在单线程下使用。
- 如果在多线程下，一个线程进入了if（singleton==null）判断语句块，还来得及往下执行，另一个线程也通过了这个if判断语句，这时便会产生多个实例。所以多线程下不可使用这个方式。
- 结论：在实际开发中，不要使用这种方式。

懒汉式（线程安全，同步方法）

代码

  public class SingletonTest04{
  	public static void main(String[] args) {
  		Singleton04 instance1=Singleton04.getInstance();
  		Singleton04 instance2=Singleton04.getInstance();
  		System.out.println(instance1==instance2);//true
  		System.out.println(instance1.hashCode()==instance2.hashCode());
  	}
  }
  //懒汉式（线程安全的同步方法）
  class Singleton04{
  	//本部内部类创建对象实例
  	private  static Singleton04 instance;
  	//私有化构造函数
  	private Singleton04(){}
  	//提供一个公有的方法返回实例对象当使用这个方法的时候才去创建这个实例对象
  	public static  synchronized Singleton04 getInstance() {
  		if(instance==null) {
  			instance=new Singleton04();
  		}
  		return instance;
  	}
  }

优缺点：
- 解决了线程不安全的问题
- 效率太低了，每个线程在想获得类的实例时候，执行getInstance（）方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想要获得该实例，直接return就行了。方法进行同步效率太低了
- 结论：在实际开发中，不推荐使用这种方式

懒汉式（线程不安全，同步代码块）

代码

  public class SingletonTest05{
  	public static void main(String[] args) {
  		Singleton05 instance1=Singleton05.getInstance();
  		Singleton05 instance2=Singleton05.getInstance();
  		System.out.println(instance1==instance2);//true
  		System.out.println(instance1.hashCode()==instance2.hashCode());
  	}
  }
  //懒汉式（线程不安全安全的同步代码块）
  class Singleton05{
  	//本部内部类创建对象实例
  	private  static Singleton05 instance;
  	//私有化构造函数
  	private Singleton05(){}
  	//提供一个公有的方法返回实例对象当使用这个方法的时候才去创建这个实例对象
  	//并且加入了同步代码块，并没有解决了线程不安全的问题
  	public static  Singleton05 getInstance() {
  		if(instance==null) {
  			synchronized(Singleton05.class) {
  				instance=new Singleton05();
  			}
  		}
  		return instance;
  	}
  }

优缺点：
- 结论：这种方式并没有解决线程安全的问题，开发中这种方式不可用。

双重检查

代码

  public class SingletonTest06{
  	public static void main(String[] args) {
  		Singletron06 instance1=Singletron06.getInstance();
  		Singletron06 instance2=Singletron06.getInstance();
  		System.out.println(instance1==instance2);//true
  		System.out.println(instance1.hashCode()==instance2.hashCode());
  	}
  }
  //懒汉式（线程安全双重检查）解决了线程安全的问题和懒加载的问题同时保证了效率
  class Singletron06{
  	//本部内部类创建对象实例
  	private  static volatile Singletron06 instance;
  	//私有化构造函数
  	private Singletron06(){}
  	//提供一个公有的方法返回实例对象当使用这个方法的时候才去创建这个实例对象
  	public static  Singletron06 getInstance() {
  		if(instance==null) {
  			synchronized(Singletron06.class) {
  				if(instance==null) {
  					instance=new Singletron06();
  				}
  			}
  		}
  		return instance;
  	}
  }

优缺点：
- double-check是多线程中经常用到的，我们使用两次if（singleton==null）检查，这样就可以保证线程安全了。
- 这样，实例化代码只执行一次，后面再次访问时，判断if(singleton==null)直接return实例化对象，也避免多了反复进行方法同步。
- 线程安全，延迟加载，效率较高
- 结论：在实际开发中，推荐使用这种单例设计模式

静态内部类

代码

  public class SingletonTest07{
  
  	public static void main(String[] args) {
  		Singleton07 instance1=Singleton07.getInstance();
  		Singleton07 instance2=Singleton07.getInstance();
  		System.out.println(instance1==instance2);//true
  		System.out.println(instance1.hashCode()==instance2.hashCode());
  	}
  
  }
  //懒汉式静态内部类
  class Singleton07{
  	//构造器私有化外部不能new对象
  	private Singleton07(){}
  	//本部内部类创建对象实例
  	private static class SingletonInstance{
  		private final static Singleton07 INSTANCE=new Singleton07();
  	}
  	//提供一个公有的方法返回实例对象
  	public static Singleton07 getInstance() {
  		return SingletonInstance.INSTANCE;
  	}
  }

优缺点：
- 这种方式采用了类加载的机制来保证初始化实例时只有一个线程
- 静态内部类方式在singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成singleton的实例化。
- 类的静态属性只会在第一次加载类的时候初始化，所以在这里，jvm帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
- 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。
- 结论：推荐使用

枚举实现单例

代码

  public class SingletonTest08{
  
  	public static void main(String[] args) {
  		Singleton08 instance1=Singleton08.INSTANCE;
  		Singleton08 instance2=Singleton08.INSTANCE;
  		System.out.println(instance1==instance2);//true
  		System.out.println(instance1.hashCode()==instance2.hashCode());
  		instance1.sayOK();
  	}
  }
  //使用枚举可以实现单例
  enum Singleton08{
  	INSTANCE;
  	public void sayOK() {
  		System.out.println("OK");
  	}
  }

优缺点：
- 利用枚举来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化创建新的对象
- 结论：推荐使用

JDK的源码分析

代码

  //JDK的runtime就是使用了饿汉式静态变量的单例模式
  public class Runtime {
      private static Runtime currentRuntime = new Runtime();
      public static Runtime getRuntime() {
          return currentRuntime;
      }
      private Runtime() {}
  }

单例模式的注意事项和细节说明
- 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高性能。
- 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new
- 单例模式的使用场景:需要频繁的进行创建和销毁对象、创建对象时耗时过多或耗费资源过多（即：重量级对象，）但又经常用到的对象、工具了对象、频繁访问数据库或文件的对象（比如数据源、session工厂等）