浅谈单例模式

简介

单例模式是一种常见的软件设计模式，其定义是：确保某一个类只有一个实例，且自行实例化并向整个系统提供这个实例。
单例模式的通用类图如下：

基本实现思路：

1. 定义该类的构造方法为私有(private)，这样在其他代码中就无法通过new来生成该类的实例。
2. 在类中向系统暴露一个静态方法，该静态方法的作用是判断引用是否存在且返回一个引用。

使用场景

在一个系统中，要求一个类有且仅有一个对象，可以使用单例模式，常见的应用场景如下：

• 要求生成唯一序列号的环境
• 在整个项目中需要一个共享访问点或共享数据
• 创建一个对象需要消耗的资源过多
• 需要定义大量的静态常量和静态方法的环境

代码实现

单例模式的实现常分为“懒汉式”和“饿汉式”，在此其上还有其他一些写法。
饿汉式

//饿汉式
public class Singleton {

	private static Singleton singleton = new Singleton();
	private Singleton() {
		//通过private私有关键字限制多个对象的生成
	}
	
	public static Singleton getSingleton() {
		return singleton;
	}
	public void say() {
		System.out.println("test...");
	}
	
}

public class Client {

	public static void main(String[] args) {
		Singleton singleton = Singleton.getSingleton();
		singleton.say();
	}
}

单例模式的优缺点

优点

• 减少了内存开销
  
• 减少系统开销
  
• 避免对资源的多重占用
  
• 设置全局访问点

缺点

• 单例模式一般没有接口，扩展很困难
  
• 对测试不利
  
• 和单一职责原则有冲突

注意事项

• 注意高并发下的单例模式的实现方式，基础的“懒汉式”写法在多线程环境中可能会存在多个对象（在此不演示了）
• 需要考虑对象的复制情况，所以在单例类中最好不要实现Cloneable接口

单例模式的扩展（要求单例类只能存在有上限的对象）

import java.util.ArrayList;
import java.util.Random;

public class Emperor {
	//定义最多能产生的示例数量
	private static int maxNumOfEmperor = 2;
	
	//存储每个皇帝的名字
	private static ArrayList<String> namelist = new ArrayList<String>();
	
	//存储所有皇帝的实例
	private static ArrayList<Emperor> emperorList = new ArrayList<Emperor>();
	
	//当前皇帝的序列号
	private static int countNumOfEmperor = 0;
	
	//产生所有的对象
	static {
		for(int i = 0; i < maxNumOfEmperor; i++) {
			emperorList.add(new Emperor("皇" + (i + 1) + "帝"));
		}
	}
	
	private Emperor() {
		//通过private限制生成对象
	}
	
	private Emperor(String name) {
		namelist.add(name);
	}
	
	//随机获得一个皇帝对象
	public static Emperor getInstance() {
		Random random = new Random();
		countNumOfEmperor = random.nextInt(maxNumOfEmperor);
		return emperorList.get(countNumOfEmperor);
	}
	
	//皇帝说话了
	public static void say() {
		System.out.println(namelist.get(countNumOfEmperor));
	}
}


public class Minister {

	public static void main(String[] args) {
		int ministerNum = 5;
		for (int i = 0; i < ministerNum; i++) {
			Emperor emperor = Emperor.getInstance();
			System.out.print("第" + (i + 1) + "个大臣参拜的是：");
			emperor.say();
		}
	}
}

其他常见的写法

ps: 这里我总结的不全

懒汉式（高并发不安全）

/**
 * 懒汉式
 * 高并发多线程下不安全
 * @author lishanlei
 *
 */
public class Singleton1 {

	private static Singleton1 singleton;
	
	private Singleton1() {
		
	}
	
	public static Singleton1 getInstance() {
		if(singleton == null) {
			singleton = new Singleton1();
		}
		return singleton;
	}
}

懒汉式（高并发安全 不推荐）

/**
 * 懒汉式
 * 同步方法
 * 线程安全
 * @author lishanlei
 *
 */
public class Singleton2 {

	private static Singleton2 singleton;
	
	private Singleton2() {
		
	}
	
	public static synchronized Singleton2 getInstance() {
		if(singleton == null) {
			singleton = new Singleton2();
		}
		return singleton;
	}
}

双重检查

/**
 * 懒汉式
 * 同步
 * 线程安全
 * @author lishanlei
 *
 */
public class Singleton3 {

    private static volatile Singleton3 singleton;

    private Singleton3() {}

    public static Singleton3 getInstance() {
        if (singleton == null) {
            synchronized (Singleton3.class) {
                if (singleton == null) {
                    singleton = new Singleton3();
                }
            }
        }
        return singleton;
    }
}