单例模式概述
- 单例模式实现方式
- 为什么要使用单例模式
单例模式实现方式
饿汉式
类加载后就会将对象加载到内存中，保证对象唯一
- 优点：由于是类加载后就创建到内存，故不存在线程安全问题
- 缺点：用或者不用，都会直接创建对象，会导致浪费内存问题
// java实现
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return instance;
}
}
//kotlin实现
object Singleton{
}
懒汉式
懒汉模式在调用的时候才会创建对象，延迟创建，多线程可能会创建多个实例对象
- 优点：调用的时候才创建，节省空间
- 缺点：多线程下可能会创建多个实例对象
// java：
public class Singleton{
private static Singleton instance = null;
private Singleton() {}
public static Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
// kotlin：
class Singleton private constructor() {
companion object {
private var instance: Singleton? = null
get() {
if(field == null) {
field = Singleton()
}
return field
}
fun get() {
return instance!!
}
}
}
线程安全
线程安全是懒汉式的扩展，并解决多线程下，仍然保持只创建单个实例，在创建对象的方法加synchronized关键字修饰，这样就可以保证实例对象只会创建一个。
- 优点：不存在多线程风险，并且延迟创建
- 缺点：在多线程下会导致bloc情况，如：有多个线程同时调用方法，其中一个抢占资源执行创建实例对象，如果当前创建比较耗时，则其他线程会被bloc
// java：
public class Singleton{
private static Singleton instance = null;
private Singleton() {}
public static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
// kotlin：
class Singleton private constructor() {
companion object {
private var instance: Singleton? = null
get() {
if(field == null) {
field = Singleton()
}
return field
}
@Synchronized
fun get() {
return instance!!
}
}
}
双重检索
双重检索是线程安全方式的进阶版，第一次判空是为了判断当前对象是否被创建，第二次判断在synchronized后，是为了判断多个线程同时进入的情况下，对象是否已经创建，这样就保证了实例对象创建了一次。如：同时有两个对象同时进入bloc到synchronized这，这个时候，线程A抢到资源，就会进入到synchronized的代码块内，这个时候就会执行创建实例对象，完成之后线程B才会进入，这个时候再判断是否为空的时候就会为false，可以直接返回对象。
-
优点：
- 提升了效率，避免了线程安全时多个线程同时bloc在synchroized外面。
- 保证唯一，同一时刻只有一个线程能创建对象
缺点：代码比较多（_）
-
双重检索会遇到空指针的问题，需要使用volatile关键字，在多线程并发的情况出现java指令重排序的问题，导致对象创建成功之后，未及时同步到主存中，导致其他线程认为主存对象还为null，导致空指针。
- volatile关键字：保证可见性
// java：
public class Singleton{
private volatile static Singleton instance = null;
private Singleton() {}
public static Singleton getInstance() {
if(instance == null) {
synchronized() {
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
// kotlin：
// 无参数情况
class Singleton private constructor() {
companion object {
val INSTANCE: Singleton by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
Singleton()
}
}
}
// 有参数情况
class Singleton private constructor(v1: Int) {
companion object {
@Volatile
private var instance: Singleton? = null
fun getInstance(property: Int) =
instance ?: synchronized(this) {
instance ?: Singleton(property).also {
instance = it
}
}
}
}
静态内部类
静态内部类能保证线程唯一也是线程安全的，也能延迟加载，主要是类加载机制，当类被加载的时候，内部类并不会被加载，只有使用的时候才会创建实例加载到内存中，所以能保证实例对象唯一，也能延迟加载
- 优点： 保证唯一，延迟加载，代码简洁
// java：
public class Singleton {
private Singleton() {}
private static class SingletonProvider {
private static Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonProvider.instance;
}
}
// kotlin：
class Singleton private constructor(){
companion object {
val instance = SingletonProvider.holder
}
private object SingletonProvider {
val holder = Singleton()
}
}
为什么要使用单例模式
- 减少对象创建，避免频繁调用GC带来的性能问题
- 用时创建，减少内存消耗
- 多线程中数据不一致导致的问题
项目中常见的单例模式
- 使用网络请求，如：OKHttp全局可以使用一个OKHttpClient实例对象
