设计模式之单例模式写法详解

单例模式是Java设计模式中最为常见的一种设计模式，在很多框架中也使用到单例模式写法。

就比如说，在项目中有一个类，他在项目的很多地方都被使用到的时候，你就需要去初始化这个类去调用对应的方法，每次初始化都是一个新的对象，就导致内存的浪费，增加GC负担，单例模式就解决了这种问题。

单例模式的原则是：一个对象只允许有一个实例存在。

单例模式主要注意两个地方：

    1.私有化构造方法

    单例模式必须私有化构造方法，防止外部直接进行初始化对象。

    2. 必须定义一个静态方法，返回该实例

    私有化构造方法后，外部就不能通过new来创建对象，但是我们向外部开放一个静态的方法供外部调用。

接下来就给大家详细介绍单例模式中常见几种写法

1. 懒汉式（线程不安全）

但是这种写法，在多线程环境下的时候，是不安全的，这种方式是不推荐用的。

public class Car {
	
	private  String name;//名称
	private  Double  price;//价格
	
	private static Car car=null;

	private Car() {//写单例模式-最重要的是私有化构造方法
		
	}
	
	public  static Car  getInstance() {
		if(car==null) {
			car =new Car();
		}
		return  car;
	};
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	
}
           

2. 懒汉式（线程安全）

这种方式在上面写法的基础上加入了synchronized 关键字，加锁使他线程不安全变得线程安全了，但是在效率上变慢了，这种方式也不推荐使用

public class Car {
	
	private  String name;//名称
	private  Double  price;//价格
	private static Car car=null;

	private Car() {//写单例模式-最重要的是私有化构造方法
		
	}
	
	public  static synchronized Car  getInstance() {
		if(car==null) {
			car =new Car();
		}
		return  car;
	};
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	
}
           

3. 饿汉式(静态常量)

这种写法不会出现线程不安全问题，因为他在类加载的时候就实例化好了，这种方式推荐使用，但不是最好，因为如果系统里面有很多这种类，都是在加载的时候就实例化好了， 但是！！如果说我有一部类并没有使用到，你也给他实例化了，是不是会造成内存的浪费，那么我能不能在需要使用的时候在给他创建呢？

public class Car {

	private  String name;//名称
	private  Double  price;//价格
	
	private final static Car car=new Car();

	private Car() {//写单例模式-最重要的是私有化构造方法
		
	}
	
	public  static  Car  getInstance() {
		
		return  car;
	};
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	
}
           

4. 饿汉式(静态代码块)

这种方式其实和上面写法差不多，只不过是把类加载初始化实例的过程放在了静态代码块中，优缺点和上面一样。

public class Car {

	private  String name;//名称
	private  Double  price;//价格
	
	private static Car car=null;
	
	static {
		car =new Car();
	}

	private Car() {//写单例模式-最重要的是私有化构造方法
		
	}
	
	public  static  Car  getInstance() {
		
		return  car;
	};
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	
}
           

5. 双重效检锁(推荐使用)

加入两重判断，在加锁保证线程安全，推荐使用。静态变量需要volatile关键字进行修饰，保证线程安全。

public class Car {

	private  String name;//名称
	private  Double  price;//价格
	
	private static volatile Car car=null;//volatile一定要加这个关键字，保证线程安全
	

	private Car() {//写单例模式-最重要的是私有化构造方法
		
	}
	
	public  static  Car  getInstance() {
		
		if(car==null) {//一重判断
			synchronized (Car.class) {//加锁
				if(car ==null) {//二重判断
					car =new Car();
				}
			}
		}
		
		return  car;
	};
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	
}
           

6. 静态内部类

这种方式使用JVM来帮我们保证了线程的安全性，因为在类进行初始化的时候，别的线程是无法进入的，从而保证了线程的安全性，在Car类进行加载的时候，内部类是不会加载的，所以只有当调用getInstance方法的时候，对象才会被初始化。也比较推荐使用

public class Car {

	private  String name;//名称
	private  Double  price;//价格
	
	private Car() {//写单例模式-最重要的是私有化构造方法
		
	}
	
	private  static class CarSingle{//静态内部类
		private  static final  Car car =new Car();
	}
	
	public  static  Car  getInstance() {
		return  CarSingle.car;
	};
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	
}
           

7. 枚举(推荐使用)

在jdk1.5以上加入了枚举的方式，可以通过这种方式来实现单例模式，它不仅解决了多线程的安全问题，代码上还非常的简洁，优雅。

public enum Car {
		getInstance;
	
	public void show() {
		System.out.println("测试枚举");
	}
}
           

以上就是一些单例模式常用的写法

单例模式的适用场景就是当一个类被重复多次使用的时候，那这个类就可以用单例来写，常用的多就是体现在一些工具类上面。