单例设计模式

单例设计模式

• 单例设计模式：保证类在内存中只有一个对象。

• 如何保证类在内存中只有一个对象呢？

  • (1)控制类的创建，不让其他类来创建本类的对象。private
  • (2)在本类中定义一个本类的对象。Singleton s;
  • (3)提供公共的访问方式。 public static Singleton getInstance(){return s}

• 单例写法两种：

  • (1)饿汉式 开发用这种方式。

      //饿汉式
      class Singleton {
      	//1,私有构造函数
      	private Singleton(){}
      	//2,创建本类对象
      	private static Singleton s = new Singleton();
      	//3,对外提供公共的访问方法
      	public static Singleton getInstance() {
      		return s;
      	}
      	public static void print() {
      		System.out.println("11111111111");
      	}
      }
    

  • (2)懒汉式 面试写这种方式。有多线程的问题？

      //懒汉式,单例的延迟加载模式
      class Singleton {
      	//1,私有构造函数
      	private Singleton(){}
      	//2,声明一个本类的引用
      	private static Singleton s;
      	//3,对外提供公共的访问方法
      	public static Singleton getInstance() {
      		if(s == null)
      			//线程1,线程2
      			s = new Singleton();
      		return s;
      	}
      	public static void print() {
      		System.out.println("11111111111");
      	}
      }
    

  • (3)第三种格式

      class Singleton {
      	private Singleton() {}
      	//final是最终的意思,被final修饰的变量不可以被更改
      	public static final Singleton s = new Singleton();
      }
    

package com.heima.thread;

public class Demo01_Singleton {

	/**
	 * @param args
	 * * 单例设计模式：保证类在内存中只有一个对象。
	 */
	public static void main(String[] args) {
		//Singleton s1 = new Singleton();
		
		Singleton s1 = Singleton.s;				//成员变量被私有,不能通过类名.调用
		//Singleton.s = null;
		Singleton s2 = Singleton.s;
		
		System.out.println(s1 == s2);
		
	/*	Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		
		System.out.println(s1 == s2);*/
	}

}

/*
 * 饿汉式
class Singleton {
	//1,私有构造方法,其他类不能访问该构造方法了
	private Singleton(){}
	//2,创建本类对象
	//成员变量必须得用对象来调用,现在没有对象了,只能用类名来调用,所以加静态.
	private static Singleton s = new Singleton();
	//3,对外提供公共的访问方法
	public static Singleton getInstance() {				//获取实例
		return s;
	}
}*/

/*
 * 懒汉式，单例的延迟加载模式。
 * 多线程访问的时候有安全隐患，因为可能创建多个对象。
class Singleton {
	//1,私有构造方法,其他类不能访问该构造方法了
	private Singleton(){}
	//2,声明一个引用
	private static Singleton s ;
	//3,对外提供公共的访问方法
	public static Singleton getInstance() {				//获取实例
		if(s == null) {
			//线程1等待,线程2等待
			s = new Singleton();
		}
		return s;
	}
}*/

class Singleton {
	//1,私有构造方法,其他类不能访问该构造方法了
	private Singleton(){}
	//2,声明一个引用
	public static final Singleton s = new Singleton();
}

饿汉式和懒汉式的区别：
1.饿汉式是空间换时间(更好)，懒汉式是时间换空间。
2.在多线程访问时，饿汉式不会创建多个对象，而懒汉式有可能会创建多个对象。