Kotlin 中单例模式和 Java 的对比浅析
Kotlin 中单例模式是指在应用程序中确保某个类仅有一个实例，并提供一个全局访问点的机制。单例模式是一种常用的设计模式，在 Java 和 Kotlin 中都有多种实现方式。下面我们将对比 Kotlin 中单例模式和 Java 中单例模式的实现方式。
一、懒人写法（恶汉式）
在 Java 中，懒人写法是最简单的单例模式实现方式，代码如下：
```java
public class Singleton{
public static final Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
}
```
在 Kotlin 中，懒人写法可以用 object 声明实现，代码如下：
```kotlin
object Singleton
```
二、基本懒加载（未实现线程同步）
在 Java 中，基本懒加载可以实现懒加载，但是不是线程安全的，代码如下：
```java
public class Singleton {
public static Singleton instance = null;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
```
在 Kotlin 中，可以使用 lazy 函数实现懒加载，代码如下：
```kotlin
class Singleton private constructor() {
companion object {
val instance by lazy(LazyThreadSafetyMode.NONE) { Singleton() }
}
}
```
三、线程同步单例
在 Java 中，可以使用 synchronized 关键字实现线程同步单例，代码如下：
```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 中，可以使用 @Synchronized 注解实现线程同步单例，代码如下：
```kotlin
class Singleton private constructor() {
companion object {
lateinit var instance: Singleton
@Synchronized
fun get(): Singleton {
if (instance == null) {
instance = Singleton()
}
return instance!!
}
}
}
```
四、线程同步单例 2
在 Java 中，可以使用双检锁单例实现线程同步懒加载，代码如下：
```java
public class Singleton {
private static Singleton instance = null;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
```
在 Kotlin 中，可以使用 lazy 函数和 LazyThreadSafetyMode.SYNCHRONIZED 模式实现线程同步懒加载，代码如下：
```kotlin
class Singleton private constructor() {
companion object {
val instance by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { Singleton() }
}
}
```
五、静态内部类单例
在 Java 中，可以使用静态内部类单例实现单例模式，代码如下：
```java
public class Singleton {
private Singleton (){}
private static class SingletonHolder {
public static final Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
}
```
在 Kotlin 中，可以使用 companion object 实现静态内部类单例，代码如下：
```kotlin
class Singleton private constructor() {
companion object {
val instance = Singleton()
}
}
```
Kotlin 中单例模式和 Java 中单例模式的实现方式有所不同，但都是为了实现单例模式的目的。Kotlin 中的单例模式实现方式更加简洁和优雅，使用 object 声明和 lazy 函数可以实现懒加载和线程同步单例。
