一、单例模式的特点
1、单例类只能有一个实例
2、单例类必须创建自己的唯一实例
3、单例类必须给所有其他对象提供这一实例
5、单例模式保证了全局对象的唯一性
二、线程安全问题
在获取单例对象时，要保证不能产生多个实例对象，由于使用单例对象时，单例对象内的实例变量是会被多线程共享的，所以为了避免这种问题的出现我们需要使用无状态对象，其不会因为多个线程的调度而破坏自身的状态导致线程安全问题
三、单例模式的实现
1、饿汉式（静态常量） 可用
public class Singleton {
private final static Singleton INSTANCE = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return INSTANCE;
}
}
优点：写法简单，在类装载时就完成了初始化，避免了线程同步问题
缺点：在类装载的时候就完成初始化，没有达到Lazy loading的效果 ，如果没有用过这个实例，则会造成内存的浪费
2、饿汉式（静态代码块） 可用
public class Singleton1{
private static Singleton1 instance;
static {
instance = new Singleton1();
}
private Singleton1(){}
public static Singleton1 getInstance(){
return instance;
}
}
其优缺点与上面那种方式是一样的 只是写法不同
如果使用kotlin书写饿汉式单例如下:
object SingletonKT {
}
只需使用 object 进行对象声明即可
3、懒汉式（线程不安全） 不可用
Java实现
public class Singleton2{
private static Singleton2 instance;
private Singleton2(){}
public static Singleton2 getInstance(){
if (instance == null){
instance = new Singleton2();
}
return instance;
}
}
Kotlin实现
class SingletonDemo private constructor(){
companion object{
private var instance:SingletonDemo ?= null
get(){
if (field == null){
field = SingletonDemo()
}
return field
}
fun get():SingletonDemo{
//这里不用getInstance作为为方法名，是因为在伴生对象声明时
// ，内部已有getInstance方法，所以只能取其他名字
return instance!!
}
}
}
优点：这种写法起到了Lazy Loading的效果
缺点：只能在单线程中使用，在多线程下有一定几率会出现多个实例
4、懒汉式（线程安全，同步方法） 不推荐用
Java实现
public class Singleton3{
private static Singleton3 instance;
private Singleton3(){}
public static synchronized Singleton3 getInstance(){
if (instance == null){
instance = new Singleton3();
}
return instance;
}
}
Kotlin实现
class SingletonDemo private constructor(){
companion object{
private var instance:SingletonDemo ?= null
get(){
if (field == null){
field = SingletonDemo()
}
return field
}
@Synchronized
fun get():SingletonDemo{
//这里不用getInstance作为为方法名，是因为在伴生对象声明时
// ，内部已有getInstance方法，所以只能取其他名字
return instance!!
}
}
}
优点：线程同步
缺点：加锁效率太低
5、懒汉式（线程安全，同步代码块） 不可用
Java实现
public class Singleton4{
private static Singleton4 instance;
private Singleton4(){}
public static Singleton4 getInstance(){
if (instance == null){
synchronized(Singleton4.class){
instance = new Singleton4();
}
}
return instance;
}
}
优点：效率较同步方法来说，效率提高了
缺点：并没有起到同步效果，会出现多个实例
6、双重检查 推荐使用
Java实现
public class Singleton5{
private static volatile Singleton5 instance;
private Singleton5(){}
public static Singleton5 getInstance(){
if (instance == null){
synchronized (Singleton5.class){
if (instance == null){
instance = new Singleton5();
}
}
}
return instance;
}
}
Kotlin实现
class SingletonDemo1 private constructor(){
companion object{
val instance:SingletonDemo1 by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED){
SingletonDemo1()
}
}
}
优点：线程安全，延迟加载，效率较高
7、静态内部类 推荐使用
Java实现
public class Singleton6{
private Singleton6(){}
private static class SingletonInstance{
private static final Singleton6 INSTANCE = new Singleton6();
}
public static Singleton6 getInstance(){
return SingletonInstance.INSTANCE;
}
}
Kotlin实现
class Singleton6{
private Singleton6(){}
private static class SingletonInstance{
private static final Singleton6 INSTANCE = new Singleton6();
}
public static Singleton6 getInstance(){
return SingletonInstance.INSTANCE;
}
}
优点：避免了线程不安全，延迟加载，效率高
8、枚举 推荐使用
Java实现
enum Singleton7{
INSTANCE;
}
优点：避免多线程同步，还能反序列化重新创建新的对象
四、单例对象使用场景
• 需要频繁的进行创建和销毁的对象
• 创建对象时耗时过多或耗费资源过多，但又经常用到的对象
• 工具类对象
• 频繁访问数据库或文件的对象
五、单例与静态方法的区别
单例模式：可以实例化，方法可以重写，因此灵活性较大
静态方法:不需要实例化，因此不会在堆空间占用空间
选择:如果不需要依赖于其他类或资源时，用静态方法，这时就是一个面向过程的函数而已，如果需要依赖其他类的实例，或者需要某些资源时，用单例