单例模式
有如下五中方式可以实现单例模式
饿汉
概念
恶汉模式，在成员变量声明时就会创建对象，也就是类被首次加载时就会创建对象
优劣势
优:
- 不存在线程安全问题
劣:
- 因为首次加载即创建，所以如果对象较大可能会拖慢程序启动速度
代码
public class HungrySingletom implements Print { private HungrySingletom() { } private static HungrySingletom INSTANCE = new HungrySingletom(); public static HungrySingletom getInstance() { return INSTANCE; } @Override public void printSomeThing() { System.out.println("恶汉打印数据"); } } class Client { public static void main(String[] args) { HungrySingletom.getInstance().printSomeThing(); } } 复制代码
懒汉
需要的时候才去创建，缺点是默认线程不安全
线程不安全懒汉
概念
初始变量为空，当我们获取的时候如果静态实例为空则创建一个对象。
如果我们在多线程中去获取单例对象则是线程不安全的，极有可能会创建多个实例
代码
本例中我们给getInstance方法加上了synchronized关键字，这样就可以保证了获取单例方法的线程安全。
在调用的时候我们会for循环创建200个线程打印对象地址，最终结果打印对象地址相同，没有出现线程不安全问题。
public class LazyThreadSafeSingleTon implements Print, Print1 { private static LazyThreadSafeSingleTon instance = null; private LazyThreadSafeSingleTon() { } public static synchronized LazyThreadSafeSingleTon getInstance() { if (instance == null) { instance = new LazyThreadSafeSingleTon(); } return instance; } @Override public void printSomeThing() { System.out.println("线程安全懒汉单例"); } public static void main(String[] args) { for (int i = 0; i < 200; i++) { final int index = i; new Thread(new Runnable() { @Override public void run() { LazyThreadSafeSingleTon myInstance = LazyThreadSafeSingleTon.getInstance(); myInstance.printMsg("索引：" + index + " " + myInstance.toString()); } }).start(); } } @Override public void printMsg(String msg) { System.out.println(msg); } } 复制代码
线程安全懒汉
方法加锁实现线程安全单例
在获取单例的方法上加上synchronized锁，实现线程安全
优劣势
优势: 使用的时候再初始化，可以加快初始化时间
劣势 在方法上加上了synchronized所以每次获取实例的时候都会加锁，当频繁获取实例的时候会明显降低效率。解决办法是使用双检索单例。
代码
public class LazyThreadSafeSingleTon implements Print, Print1 { private static LazyThreadSafeSingleTon instance = null; private LazyThreadSafeSingleTon() { } public static synchronized LazyThreadSafeSingleTon getInstance() { if (instance == null) { instance = new LazyThreadSafeSingleTon(); } return instance; } @Override public void printSomeThing() { System.out.println("线程安全懒汉单例"); } public static void main(String[] args) { for (int i = 0; i < 200; i++) { final int index = i; new Thread(new Runnable() { @Override public void run() { LazyThreadSafeSingleTon myInstance = LazyThreadSafeSingleTon.getInstance(); myInstance.printMsg("索引：" + index + " " + myInstance.toString()); } }).start(); } } @Override public void printMsg(String msg) { System.out.println(msg); } } 复制代码
双检索方式实现单例
双检索代码理解
一下文字是对下面代码的说明
线程1第一次获取实例 线程第一次调用的时候会先进入第一重判断，此时instance为空，进入加锁代码。 然后进入第二重判断，此时instance仍然为空，开始初始化。
线程2在线程1初始化过程中获取实例 因为实例尚没有初始化，所以线程2第一重判断instance为空，二此时线程1正在初始化所以线程2要等待锁。延迟后线程1释放锁，线程1进入锁内并进行第二重判断。因为线程1已经初始化了，所以此时instance不为空，所以不进入第二重判断。直接跳到返回实例的代码
线程3在线程1、2完成后进入 线程3进入第一重判断，此时instance不为空，直接跳到返回instance部分
为什么一定要加volatie关键字
将我很久以前写的列举发一下吧，目前我仍然觉得写的没问题
代码
public class DoubleLockThreadSafeSingleTon implements Print1 { private static volatile DoubleLockThreadSafeSingleTon instance;//volatie是必须的 private DoubleLockThreadSafeSingleTon(){} public static DoubleLockThreadSafeSingleTon getInstance() { if(instance==null){//第一重判断 synchronized (DoubleLockThreadSafeSingleTon.class){//加锁 if (instance==null){//第二重判断 instance=new DoubleLockThreadSafeSingleTon(); } } } return instance; } public static void main(String[] args) { for (int i=0;i<200;i++){ System.out.println(DoubleLockThreadSafeSingleTon.getInstance().toString()); } } @Override public void printMsg(String msg) { System.out.println(msg); } } 复制代码
静态内部类
理解
本例代码中StaticClassSingleton实例在StaticClassSingletonHolder的静态变量中初始化
优劣势
优势 在不使用锁的情况下实现了单例模式
劣势 需要多创建一个内部类
代码
public class StaticClassSingleton implements Print { private StaticClassSingleton() { } public static StaticClassSingleton getInstance() { return StaticClassSingletonHolder.instance; } static class StaticClassSingletonHolder { static StaticClassSingleton instance = new StaticClassSingleton(); } @Override public void printSomeThing() { System.out.println("静态内部类实现单例"); } public static void main(String[] args) { StaticClassSingleton.getInstance().printSomeThing(); } } 复制代码
枚举
很多人可能是不知道的，枚举实例中是可以编写方法代码的，根据这种方式我们可以巧妙的实现单例模式。
优劣势
优势 不需要锁就可以实现单例劣势 暂未想到
代码
public enum EnumSingleton implements Print { INSTANCE,DEFAULT; @Override public void printSomeThing() { System.out.println(name()); } public static void main(String[] args) { EnumSingleton.INSTANCE.printSomeThing(); EnumSingleton.DEFAULT.printSomeThing(); } } 复制代码
扩展 枚举代码变种实现路由
我们可以在枚举中定义方法，然后再实例中重写该方法，从而实现不同的枚举实例有自己的行为
public enum EnumSingleton implements Print { INSTANCE{ @Override public void action(){ System.out.println("INSTANCE单例方法"); } },DEFAULT{ @Override public void action(){ System.out.println("DEFAULT单例方法"); } }; @Override public void printSomeThing() { System.out.println(name()); } public static void main(String[] args) { EnumSingleton.INSTANCE.printSomeThing(); EnumSingleton.DEFAULT.printSomeThing(); EnumSingleton.INSTANCE.action(); EnumSingleton.DEFAULT.action(); } public void action() { } }
