Java设计模式-----单例模式

当某个类采用单例模式时，该类只会有一个实例供外部访问，主要特点如下：

1）类的构造方法私有化，即使用private修饰构造方法

2）在类的内部定义一个该类的对象并将其实例化，用private static修饰

3）定义一个static方法将该类的实例返回

方法一（饿汉式）

public class Singleton1 {
	//私有化构造函数，禁止通过构造方法来创建对象
	private Singleton1() {
		
	}
	//将自身的实例对象设置为一个属性并初始化
	private static final Singleton1 instance = new Singleton1();
	//通过get方法返回该类的实例
	public static Singleton1 getInstance() {
		return instance;
	}
}

优点：代码简单，线程安全，不需要加synchronized，运行效率高。

缺点：当类Singleton1被加载的时候，会初始化static的instance，这样静态变量instance就一直占着一段内存（即使没有使用instance），所以可能会浪费内存。

方法二（饱汉式）

public class Singleton2 {
	//私有化构造函数
	private Singleton2() {
		
	}
	//定义一个类型为Singleton2的属性，但不初始化
	private static Singleton2 instance;
	
	//通过get方法将实例返回，当多线程访问该方法时，会存在线程不安全的问题
	public static Singleton2 getInstance() {
		if(instance == null) {//这里可能有多个线程进来，创建多个实例
			instance = new Singleton2();
		}
		return instance;
	}
}

优点：代码简单，是有在使用时才会创建instance，不会因此浪费内存。

缺点：线程不安全，多线程的情况下可能会有多个Singleton2实例。

方法三（解决方法二的线程不安全问题）

public class Singleton3 {
	
	private Singleton3() {
		
	}
	
	private static Singleton3 instance;
	//给get方法加同步锁，可以避免多线程访问时，重复初始化的问题
	public static synchronized Singleton3 getInstace() {
		if(instance == null) {
			instance = new Singleton3();
		}
		return instance;
	}
}

优点：使用synchronized关键字避免多线程访问时，出现多个实例。

缺点：每调用一次方法都会访问同步块，会降低运行效率。

方法四（优化方法三）

public class Singleton4 {
	
	private Singleton4() {
		
	}
	
	private static Singleton4 instance;
	//同步锁没有加在get方法上，可以提高运行效率
	public static Singleton4 getInstance() {
		if(instance == null) {//这里可能会有多个线程进来
			synchronized(Singleton4.class) {//给进来的线程加锁
				if(instance == null) {
					instance = new Singleton4();
				}
			}
		}
		
		return instance;
	}
}

单例模式的最佳实现方式：线程安全，占用内存低，效率高。

注意：通过Java的反射机制可以访问private类型的构造方法，此时所有的单例都会失效。