单例模式

一、 单例模式

1. 单例模式 ：就是一个类有且只有一个实例，只 new 一个对象。模式的目的是使得类的一个对象成为系统中的唯一实例。

2. Java语言中，有两种构建方式
   懒汉式 和 饿汉式

二、懒汉式
在需要实例化对象的时候才new一个对象，比较懒，需要才做。
在访问量较小时，采用懒汉实现

package com.lixu.javabase.single;

/**
 * 单例模式
 * 懒汉式：需要的时候实例化对象
 */
public class Singleton {

	private static Singleton single;
	
	public Singleton(){
		
	}
	
	//当single为null时(有需要)才创建实例对象
	//线程不安全
	public static Singleton getInstance(){
		if(single == null){
			single = new Singleton();
		}
		return single;
	}
}

三、懒汉式：synchronized实现线程安全

1. 实例化的方法加synchronized锁

package com.lixu.javabase.single;

/**
 1. 单例模式
 2. 懒汉式：需要的时候实例化对象
 3. synchronized 实现线程安全
 */
public class Singleton1 {

	private static Singleton1 single;
	
	public Singleton1(){
		
	}
	
	//当single为null时(有需要)才创建实例对象
	//synchronized 同步锁
	public static synchronized Singleton1 getInstance(){
		if(single == null){
			single = new Singleton1();
		}
		return single;
	}
}

2. 双重检验锁法（DCL）

package com.lixu.javabase.single;

/**
 * 单例模式
 * 懒汉式：需要的时候实例化对象
 * synchronized 实现线程安全
 * 双重检验锁法（DCL）
 */
public class Singleton2 {

	private static Singleton2 single;
	
	public Singleton2(){
		
	}
	
	//双重检验锁法（DCL）:线程安全且性能较好 
	//Singleton2.class ???? /single
	public static Singleton2 getInstance(){
		if(single == null){
			synchronized (Singleton2.class) {
				if(single == null){
					return new Singleton2();
				}
			}
		}
		return single;
	}
}

四、饿汉式
类加载时就直接实例化对象 ，不管什么情况，先实例化再说

1. 类加载机制

package com.lixu.javabase.single;

/**
 * 单例模式
 * 饿汉式：类加载时就直接实例化对象
 */
public class Singleton3 {

	private static Singleton3 single = new Singleton3();
	
	public Singleton3(){
		
	}
	
	//使用类加载机制，避免了多线程的同步问题
	public static Singleton3 getInstance(){
		return single;		
	}
}

2. 内部类实现

package com.lixu.javabase.single;

/**
 * 单例模式
 * 饿汉式：内部类实现
 */
public class Singleton4 {

    public Singleton4(){}
	
    public static class SingletonHolder {
    	private static Singleton4 single = new Singleton4();
    }
    
    public static Singleton4 getInstance() {
        return SingletonHolder.single;
    }
		
}