所谓单例就是在系统中只有一个该类的实例。
单例模式的核心分以下三个步骤:
- 构造方法私有化。即不能在类外实例化,只能在类内实例化。
- 在本类中创建本类的实例。
- 在本类中提供给外部获取实例的方式。
单例模式的实现方式有两种:饿汉模式和懒汉模式。
饿汉模式
不管现在需不需要,先创建实例。关键在于“饿”,饿了就要立即吃。
静态常量
这里将类的构造器私有化,就不能在外部通过new关键字创建该类的实例,然后定义了一个该类的常量,用static修饰,以便外部能够获得该类实例(通过HungryStaticConstantSingleton.INSTANCE 获得)。也可以不加final关键字,具体看自己的需求。
/**
* 恶汉模式-静态常量,简洁直观
*/
public class HungryStaticConstantSingleton{
//构造器私有化
private HungryStaticConstantSingleton() {
}
//静态变量保存实例变量 并提供给外部实例
public final static HungryStaticConstantSingleton INSTANCE = new HungryStaticConstantSingleton();
}
枚举
这种方式是最简洁的,不需要考虑构造方法私有化。值得注意的是枚举类不允许被继承,因为枚举类编译后默认为final class,可防止被子类修改。常量类可被继承修改、增加字段等,容易导致父类的不兼容。
/**
* 恶汉-枚举形式,最简洁
*/
public enum HungryEnumSingleton{
INSTANCE;
public void print(){
System.out.println("这是通过枚举获得的实例");
System.out.println("HungryEnumSingleton.pring()");
}
}
Test,打印实例直接输出了【INSTANCE】,是因为枚举帮我们实现了toString,默认打印名称。
public class EnumSingleton2Test{
public static void main(String[] args) {
HungryEnumSingleton singleton2 = HungryEnumSingleton.INSTANCE;
System.out.println(singleton2);
singleton2.print();
}
}
输出结果
静态代码块
这种方式和上面的静态常量/变量类似,只不过把new放到了静态代码块里,从简洁程度上比不过第一种。但是把new放在static代码块有别的好处,那就是可以做一些别的操作,如初始化一些变量,从配置文件读一些数据等。
/**
* 恶汉模式-静态代码块
*/
public class HungryStaticBlockSingleton{
//构造器私有化
private HungryStaticBlockSingleton() {
}
//静态变量保存实例变量
public static final HungryStaticBlockSingleton INSTANCE;
static {
INSTANCE = new HungryStaticBlockSingleton();
}
}
如下,在static代码块里读取 info.properties 配置文件动态配置的属性,赋值给 info 字段。
/**
* 恶汉模式-静态代码块
* 这种用于可以在静态代码块进行一些初始化
*/
public class HungryStaticBlockSingleton{
private String info;
private HungryStaticBlockSingleton(String info) {
this.info = info;
}
//构造器私有化
private HungryStaticBlockSingleton() {
}
//静态变量保存实例变量
public static final HungryStaticBlockSingleton INSTANCE;
static {
Properties properties = new Properties();
try {
properties.load(HungryStaticBlockSingleton.class.getClassLoader().getResourceAsStream("info.properties"));
} catch (IOException e) {
e.printStackTrace();
}
INSTANCE = new HungryStaticBlockSingleton(properties.getProperty("info"));
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
Test,
public class HungrySingletonTest{
public static void main(String[] args) {
HungryStaticBlockSingleton hun = HungryStaticBlockSingleton.INSTANCE;
System.out.println(hun.getInfo());
}
}
输出
懒汉模式
需要时再创建,关键在于“懒”,类似懒加载。
非线程安全
同样是构造方法私有化,提供给外部获得实例的方法,getInstance()方法被调用时创建实例。该方式适用于单线程,因为在多线程的情况下可能会发生线程安全问题,导致创建不同实例的情况发生。可以看下面的演示。
/**
* 懒汉模式-线程不安全的,适用于单线程
*/
public class LazyUnsafeSingleton{
private LazyUnsafeSingleton(){
}
private static LazyUnsafeSingleton instance;
public static LazyUnsafeSingleton getInstance(){
if(instance==null){
instance = new LazyUnsafeSingleton();
}
return instance;
}
}
非线程安全演示
public class LazyUnsafeSingletionTest{
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService es = Executors.newFixedThreadPool(2);
Callable<LazyUnsafeSingleton> c1 = new Callable<LazyUnsafeSingleton>(){
@Override
public LazyUnsafeSingleton call() throws Exception {
return LazyUnsafeSingleton.getInstance();
}
};
Callable<LazyUnsafeSingleton> c2 = new Callable<LazyUnsafeSingleton>(){
@Override
public LazyUnsafeSingleton call() throws Exception {
return LazyUnsafeSingleton.getInstance();
}
};
Future<LazyUnsafeSingleton> submit = es.submit(c1);
Future<LazyUnsafeSingleton> submit1 = es.submit(c2);
LazyUnsafeSingleton lazyUnsafeSingleton = submit.get();
LazyUnsafeSingleton lazyUnsafeSingleton1 = submit1.get();
es.shutdown();
System.out.println(lazyUnsafeSingleton);
System.out.println(lazyUnsafeSingleton);
System.out.println(lazyUnsafeSingleton1==lazyUnsafeSingleton);
}
}
输出 大概运行三次就会出现一次,我们可以在 LazyUnsafeSingleton 中判断 if(instance==null) 之后增加线程休眠以获得更好的效果。
线程安全的
该方式是懒汉模式中线程安全的创建方式。通过同步代码块控制并发创建实例。并且采用双重检验,当两个线程同时执行第一个判空时,都满足的情况下,都会进来,然后去争锁,假设线程1拿到了锁,执行同步代码块的内容,创建了实例并返回,此时线程2又获得锁,执行同步代码块内的代码,因为此时线程1已经创建了,所以线程2虽然拿到锁了,如果内部不加判空的话,线程2会再new一次,导致两个线程获得的不是同一个实例。线程安全的控制其实是内部判空在起作用,至于为什么要加外面的判空下面会说。
/**
* 懒汉模式-线程安全,适用于多线程
*/
public class LazySafeSingleton{
private static volatile LazySafeSingleton safeSingleton;//防止指令重排
private LazySafeSingleton() {
}
public static LazySafeSingleton getInstance(){
if(safeSingleton==null){
synchronized (LazySafeSingleton.class){
if(safeSingleton==null){//双重检测
safeSingleton = new LazySafeSingleton();
}
}
}
return safeSingleton;
}
}
当不加内层判空时,会出现不是单例的情况,只不过出现的概率更低了点。
可不可以只加内层判空呢?答案是可以。
那为什么还要加外层判空的呢?内层判空已经可以满足线程安全了,加外层判空的目的是为了提高效率。因为可能存在这样的情况:线程1拿到锁后执行同步代码块,在new之后,还没有释放锁的时候,线程2过来了,它在等待锁(此时线程1已经创建了实例,只不过还没释放锁,线程2就来了),然后线程1释放锁后,线程2拿到锁,进入同步代码块汇总,判空,返回。这种情况线程2是不是不用去等待锁了?所以在外层又加了一个判空就是为了防止这种情况,线程2过来后先判空,不为空就不用去等待锁了,这样提高了效率。
内部类创建外部类实例
该方式天然线程安全,是否final根据自己需要。
/**
* 懒汉模式-线程安全,适用于多线程
* 在内部类被加载和初始化时 才创建实例
* 静态内部类不会自动随着外部类的加载和初始化而初始化,它是要单独加载和初始化的。
* 因为是在内部类加载和初始化时创建的 因此它是线程安全的
*/
public class LazyInnerSingleton{
private LazyInnerSingleton() {
}
private static class Inner{
private static final LazyInnerSingleton INSTANCE = new LazyInnerSingleton();
}
public static LazyInnerSingleton getInstance(){
return Inner.INSTANCE;
}
}
总结
饿汉模式
- 静态常量 简洁直观容易理解
- 枚举 最简洁
- 静态代码块 可以在静态块里做一些初始化的工作
懒汉模式
- 单线程形式 该形式下不适用多线程,存在线程安全问题
- 多线程形式 适用于多线程
- 内部类形式 最简洁