Java中的23种设计模式之------------单例模式

**

单例模式：

**

在Java开发过程中单例模式是一种简单常见的设计模式。单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。
单例所具备的特点：

• 1.私有化的构造函数
  2. 私有的静态的全局变量
  3. 公有的静态的方法
  4. 单例类必须自己创建自己的唯一实例。
  5.单例类只能有一个实例。
  8.单例类必须给所有其他对象提供这一实例。
  实现单例模式的方式

1.饿汉模式：

/**
 * 饿汉式单例--初始化立即加载
 */
public class Singleton01 {
	//私有化的构造函数
	private Singleton01(){}
	//私有化的静态全局变量
	private static int value = 0;
	//自己创建对象
	private static final Singleton01 ONLY
			= new Singleton01();
	//公有静态工厂方法
	public static Singleton01 getInstance(){
		return ONLY;
	}
	public  int getValue() {
		return value;
	}
	public  void setValue(int value) {
		Singleton01.value = value;
	}
}

测试代码：

public class Test {
	public static void main(String[] args) {
		Singleton01 a = Singleton01.getInstance();
		Singleton01 b = Singleton01.getInstance();
		System.out.println("判断a和b的地址是否相同："+a.equals(b));
		a.setValue(5);
		System.out.println("输出中b的value:"+b.getValue());
	}
}

2.懒汉模式：

/**
 * 懒汉式单例--延时加载
 */
public class Singleton02 {
	//私有化的构造函数
	private Singleton02(){}
	//私有化的静态全局变量
	private static int value = 0;
	//自己创建对象
	private static Singleton02 ONLY;
	//公有静态工厂方法
	public static Singleton02 getInstance(){
		if(ONLY==null){
			ONLY = new Singleton02();
		}
		return ONLY;
	}
	public  int getValue() {
		return value;
	}
	public  void setValue(int value) {
		Singleton02.value = value;
	}
}

测试代码：

public class Test {
	public static void main(String[] args) {
		Singleton02 a = Singleton02.getInstance();
		Singleton02 b = Singleton02.getInstance();
		System.out.println("判断a和b的地址是否相同："+a.equals(b));
		a.setValue(5);
		System.out.println("输出中b的value:"+b.getValue());
	}
}

3.使用synchronized同步锁

/**
 * 懒汉式单例--延时加载
 */
public class Singleton03 {
	//私有化的构造函数
	private Singleton03(){}
	//私有化的静态全局变量
	private static int value = 0;
	//自己创建对象
	private static Singleton03 ONLY;
	//加锁的公有静态工厂方法
	synchronized public static Singleton03 getInstance(){
		if(ONLY==null){
			ONLY = new Singleton03();
		}
		return ONLY;
	}
	public  int getValue() {
		return value;
	}
	public  void setValue(int value) {
		Singleton03.value = value;
	}
}

• 在方法上加synchronized同步锁或是用同步代码块对类加同步锁，此种方式虽然解决了多个实例对象问题，但是该方式运行效率却很低下，下一个线程想要获取对象，就必须等待上一个线程释放锁之后，才可以继续运行。
  4.懒汉式双重检查：

public class Singleton04 {  
// 私有构造 private Singleton04() {} 
private static Singleton4 ONLY; 
// 双重检查   public static Singleton04
   getInstance() {
         if (ONLY == null) {
             synchronized (Singleton04.class) {
                 if (ONLY == null) {
                     ONLY = new Singleton04();
                 }
             }
         }
         return ONLY; } }

• 使用双重检查进一步做了优化，可以避免整个方法被锁，只对需要锁的代码部分加锁，可以提高执行效率。