【设计模式系列】--单例模式

在前面的博文中，小编介绍了设计模式中的原型模式，不知道有没有帮助到有需要的小伙伴呢`(*∩_∩*)′，今天这篇博文，小编继续来介绍相关的设计模式，今天要和大家见面的是单例模式，不由得又让小编想起Darry Ring，或许只能想想而已`(*∩_∩*)′，开篇闲扯到这里，接着步入正题，今天这篇博文，小编会从什么是单例模式，为什么要使用单例模式，饿汉式，懒汉式、双重检查以及配之以相关的Demo进行讲解，希望对有需要的小伙伴有帮助，还请小伙伴多多指教。

什么是单例模式

单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象，其实GOF对单例模式的定义是：保证一个类， 只有一个实例存在，同时提供能对该实例加以访问的全局访问方法，我们来看一下单例模式的结构图：

为什么要使用单例模式

在应用系统开发中，我们常常有以下需求

a、在多个线程之间，比如servlet环境，共享同一个资源或者操作同一个对象。

b、在整个程序空间使用全局变量，共享资源。

c、大规模系统中，为了性能的考虑，需要节省对象的创建时间等等。

因为单例模式可以保证为一个类只生成唯一的实例对象，所以这些情况，单例模式就派上用场了。

单例模式的实现

a、饿汉式

b、懒汉式

c、双重检查

首先，我们来实现一个简单的，新建一个java项目，新建Person类，生成get和set方法，保证人只有一个实例，计划生育，响应国家号召是不是`(*∩_∩*)′，编写相关代码，如下所示：

public class Person {
	public String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	

}

public class MainClass {
	 public static void main(String[] args){
		 Person per = new Person();
		 Person per2 = new Person();
		 per.setName("xiaoding");
		 per2.setName("dingding");
		 
		 System.out.println(per.getName());
		 System.out.println(per2.getName());
	 }

}

通过Person类，getName得到的是两个name，表明这两个根本就不是一个对象，也就是说，通过person类，我们生成了两个不同的对象，如果是一个的话，她们的名字应该是一样的，我们如何保证只有一个对象呢？我们在MainClass里面new的是她的构造函数，改造Person的代码，把构造函数私有化，代码如下所示：

public class Person {
	public String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	//构造函数私有化
	private Person(){
		
	}
	
	//提供一个全局的静态方法
	public static Person getPerson(){
		return new Person();
	}


}

public class MainClass {
	 public static void main(String[] args){
		 Person per = Person.getPerson();
		 Person per2 = Person.getPerson();
		 per.setName("xiaoding");
		 per2.setName("dingding");
		 
		 System.out.println(per.getName());
		 System.out.println(per2.getName());
	 }

}

运行还是两个对象，我们如何保证是一个对象呢？如何保证实例化一个对象呢？我们可以采用饿汉式，编写Person的代码部分我们直接通过对象就能调用，如下所示：

public class Person {
	public static final Person person = new Person();
	public String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	//构造函数私有化
	private Person(){
		
	}
	
	//提供一个全局的静态方法
	public static Person getPerson(){
		Return person;
	}

}

这个时候就表示，他们是同一个对象，getPerson的是一个对象，那么什么是懒汉式呢？重新新建一个了Person2，编写相关代码如下所示：

public class Person2 {
	private String name;
	private static Person2 person;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	//构造函数私有化
	private Person2(){
		
	}
	
	//提供全局的静态方法
	public static Person2 getPerson(){
		if(person == null){
			person = new Person2();
		}
		return person;
	}
	

}

这个呢就是所谓的饿汉式，懒汉式类加载的时候直接初始化，如果是多线程，懒汉式是不能保证只有一个实例的，那么我们如何解决这个问题呢？新建类Person3，编写相关代码：

public class Person3 {
	
	private String name;
	private static Person3 person;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	//构造函数私有化
	private Person3(){
		
	}
	
	//提供全局的静态方法
		public static Person3 getPerson(){
			if(person == null){
				person = new Person3();
			}
			return person;
		}
	

}

public class Person4 {
	
	private String name;
	private static Person4 person;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	//构造函数私有化
	private Person4(){
		
	}
	
	//提供全局的静态方法
		public static Person4 getPerson(){
			if(person == null){
				synchronized(Person4.class){
					if(person == null){
						person = new Person4();
					}
				}
			}
			
			return person;
			
		}

}