单例模式
为什么要使用单例模式?
- 保证一个类只有一个实例。为啥要保证一个类只有一个实例呢?因为这样可以控制某些共享资源的访问权限。
- 提供一个全局访问节点。全局变量也可以提供这种功能,但是全局变量很不安全,任何人在任何位置都能对这些全局变量进行覆盖。
单例模式的特点
- 构造函数私有化。防止其他人随便就“new”出一个实例来。
- 通过一个静态方法获取实例。这个静态方法会在首次被调用的时候,调用该类的私有构造函数生成实例对象并缓存。以后被调用的时候直接返回缓存中的实例对象。
单线程/多线程问题(代码展示):
单例模式比较好理解,唯一的难点可能就是和多线程相关的问题,直接上码吧。代码的运行结果写在注释里了。
- 单线程下的单例模式。
/**
* 懒汉式单例,线程不安全
*/
public class Singleton {
private static Singleton singleton;
public String name;
private Singleton(String name){
this.name = name;
}
public static Singleton getInstance(String name){
if(null == singleton){
singleton = new Singleton(name);
}
return singleton;
}
}
/**
* 线程不安全单例模式,客户端测试代码
*/
public class client {
public static void main(String[] args) {
// 单线程测试
// Singleton singleton1 = Singleton.getInstance("singleton1");
// Singleton singleton2 = Singleton.getInstance("singleton2");
// System.out.println(singleton1.name); // "singleton1"
// System.out.println(singleton2.name); // "singleton1"
// 多线程测试
Thread thread1 = new Thread(new thread1());
Thread thread2 = new Thread(new thread2());
thread1.start(); // "singleton1"
thread2.start(); // "singleton2"
}
static class thread1 implements Runnable { // 内部的有static方法,这里类前不加static会报错
@Override
public void run() {
Singleton singleton3 = Singleton.getInstance("singleton1");
}
}
static class thread2 implements Runnable {
@Override
public void run() {
Singleton singleton4 = Singleton.getInstance("singleton2");
}
}
}
- 多线程下的单例模式。
/**
1. DCL+懒汉式单例,线程安全
*/
public class Singleton {
private static volatile Singleton singleton;
public String name;
private Singleton(String name){
this.name = name;
}
/**
* 使用DCL(double-checked locking,双重检验锁)的懒汉式获取单例对象
*/
public static Singleton getInstance(String name){
// first-check: 提高性能,避免每个线程都执行synchronized
if(null == singleton){
synchronized (Singleton.class){
// second-check: 可能多个线程通过第一层检验,没有第二层检验会生成多个实例
if(null == singleton){
singleton = new Singleton(name);
}
}
}
return singleton;
}
}
/**
* 线程安全单例模式,客户端测试代码
*/
public class client {
public static void main(String[] args){
// 多线程测试
Thread thread1 = new Thread(new CreationalPatterns.SingletonPattern.ThreadSafe.client.thread1());
Thread thread2 = new Thread(new CreationalPatterns.SingletonPattern.ThreadSafe.client.thread2());
thread1.start(); // "singleton1"
thread2.start(); // "singleton1"
}
static class thread1 implements Runnable { // 内部的有static方法,这里类前不加static会报错
@Override
public void run() {
CreationalPatterns.SingletonPattern.NotThreadSafe.Singleton singleton3 = CreationalPatterns.SingletonPattern.NotThreadSafe.Singleton.getInstance("singleton1");
System.out.println(singleton3.name);
}
}
static class thread2 implements Runnable {
@Override
public void run() {
CreationalPatterns.SingletonPattern.NotThreadSafe.Singleton singleton4 = Singleton.getInstance("singleton2");
System.out.println(singleton4.name);
}
}
}
单例模式总结
- 单例模式分为“饿汉式”和“懒汉式”两种,“懒汉式”更为普遍。二者的区别并不难理解,因此本文也就不过多讨论了。
- 多线程下单例模式存在线程不安全的问题,代码展示1的client测试类清楚地展示了这一点:不同的线程获取了不同的单例(“singleton1”和“singleton2”)。通过双重检验锁(DCL)可以较为完美地解决线程安全问题,从代码展示2的client测试类看到,不同的线程获取到了同一个单例(“singleton1”)。
- 线程安全的实现:DCL+ synchronized + volatile。
synchronized关键字 :用来控制线程同步。当synchronized关键字修饰一个代码块的时候(例如代码展示2的singleton类),这个代码块不能被多个线程同时访问,不同线程想要访问只能排队一个访问结束后下一个再访问。
volatile关键字:这个关键字修饰的是singleton类的实例。volatile关键字在生成实例的时候禁止了重排序(简单来说,重排序是cpu为了提高效率采取的一种手段,可自行百度)。如果不使用这个关键字,在使用DCL的时候可能会出现程序报错的隐患(参考这里)。
DCL:双重检验锁的原理是什么?顾名思义是检查了两次,检查了两次啥呢?检查了两次singleton实例是否存在:if(null == singleton){}。第一重检查(first check)目的是节省资源,因为synchronized是个很耗资源的操作。first check可以在已经有线程生成了一个实例的情况下,其它线程可以绕过synchronized;第二重检查(second check)目的是保证只生成一个实例。结合代码展示2中的DCL部分,可能存在多个线程同时通过first check的情况,假如没有second check,那么有多少个线程就会生成多少个实例(synchronized失去意义,大家轮流排队生成新实例)。
共同学习,欢迎交流!
这里是源码