设计模式之~单例模式
概念：
单例模式可以说是大多数开发人员在实际中使用最多的，单例模式有很多好处，比如可节约系统内存空间，控制资源的使用。
单例模式最重要的是确保对象只有一个。简单来说，保证一个类在内存中的对象就一个。
开发步骤：
-
私有化构造方法
-
在类的内部创建好对象
-
对外界提供一个公共的get()，返回一个已经准备好的对象
单例的八种实现方式
（1）饿汉式
-
类加载到内存后，就实例化一个单例，JVM保证线程安全
-
简单实用，推荐使用！
-
唯一缺点：不管用到与否，类装载时就完成实例化
public class Mgr01 {
private static final Mgr01 INSTANCE = new Mgr01();
private Mgr01() {};
public static Mgr01 getInstance() {
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
Mgr01 m1 = Mgr01.getInstance();
Mgr01 m2 = Mgr01.getInstance();
System.out.println(m1 == m2);
}
}优点：
-
由于使用了static关键字，保证了在引用这个变量时，关于这个变量的所以写入操作都完成，所以保证了JVM层面的线程安全
-
缺点：
-
不能实现懒加载，造成空间浪费，如果一个类比较大，我们在初始化的时就加载了这个类，但是我们长时间没有使用这个类，这就导致了内存空间的浪费。
（2）静态代码块【类似（1）饿汉式】
/**跟01是一个意思**/
public class Mgr02 {
private static final Mgr02 INSTANCE;
static {
INSTANCE = new Mgr02();
}
private Mgr02() {};
public static Mgr02 getInstance() {
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
Mgr02 m1 = Mgr02.getInstance();
Mgr02 m2 = Mgr02.getInstance();
System.out.println(m1 == m2);
}
}（3）懒汉式（线程不安全）
懒汉模式是一种偷懒的模式，在程序初始化时不会创建实例，只有在使用实例的时候才会创建实例。
-
所以懒汉模式解决了饿汉模式带来的空间浪费问题
-
同时也引入了其他的问题（线程不安全），我们先来看看下面这个懒汉模式
public class Mgr03 {
private static Mgr03 INSTANCE;
private Mgr03() {
}
public static Mgr03 getInstance() {
if (INSTANCE == null) {
INSTANCE = new Mgr03();
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->
System.out.println(Mgr03.getInstance().hashCode())
).start();
}
}
}优点：
实现了懒加载，节约了内存空间
缺点：
-
在不加锁的情况下，线程不安全，可能出现多份实例
-
在加锁的情况下，会是程序串行化，使系统有严重的性能问题。
（4）懒汉式 (方法上加锁)
/**
* lazy loading
* 也称懒汉式
* 虽然达到了按需初始化的目的，但却带来线程不安全的问题
* 可以通过synchronized解决，但也带来效率下降
*/
public class Mgr04 {
private static Mgr04 INSTANCE;
private Mgr04() {
}
public static synchronized Mgr04 getInstance() {
if (INSTANCE == null) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr04();
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr04.getInstance().hashCode());
}).start();
}
}
}（5）懒汉式 (同步代码块加锁)
public class Mgr05 {
private static Mgr05 INSTANCE;
private Mgr05() {
}
public static Mgr05 getInstance() {
if (INSTANCE == null) {
//妄图通过减小同步代码块的方式提高效率，然后不可行
synchronized (Mgr05.class) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr05();
}
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr05.getInstance().hashCode());
}).start();
}
}
}（6）懒汉式 (双重校验)
public class Mgr06 {
private static volatile Mgr06 INSTANCE; // volatile最关键的作用是防止指令重排
private Mgr06() {
}
public static Mgr06 getInstance() {
if (INSTANCE == null) {
//双重检查
synchronized (Mgr06.class) {
if(INSTANCE == null) {
INSTANCE = new Mgr06();
}
}
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr06.getInstance().hashCode());
}).start();
}
}
}这里采用了双重校验的方式，对懒汉式单例模式做了线程安全处理。通过加锁，可以保证同时只有一个线程走到第二个判空代码中去，这样保证了只创建一个实例。
（7）静态内部类方式
静态内部类单例模式也称单例持有者模式，实例由内部类创建。
由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载，并初始化其静态属性。静态属性由static修饰，保证只被实例化一次，并且严格保证实例化顺序。
/**
* 静态内部类方式
* JVM保证单例加载外部类时不会加载内部类，这样可以实现懒加载
*/
public class Mgr07 {
private Mgr07() {
}
private static class Mgr07Holder {
private final static Mgr07 INSTANCE = new Mgr07();
}
public static Mgr07 getInstance() {
return Mgr07Holder.INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr07.getInstance().hashCode());
}).start();
}
}
}似乎静态内部类看起来已经是最完美的方法了，其实不是，可能还存在反射攻击或者反序列化攻击。
（8）枚举实现
枚举类实现单例模式是 effective java 作者极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式。枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。
/**不仅可以解决线程同步，还可以防止反序列化**/
public enum Mgr08 {
INSTANCE;
public void m() {}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr08.INSTANCE.hashCode());
}).start();
}
}
}单例使用场景：
单例模式只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等。
-
需要频繁实例化然后销毁的对象。
-
创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
-
有状态的工具类对象。
-
频繁访问数据库或文件的对象。
优点:
-
在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就防止其它对象对自己的实例化，确保所有的对象都访问一个实例
-
单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
-
提供了对唯一实例的受控访问。
-
由于在系统内存中只存在一个对象，因此可以节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。
-
允许可变数目的实例。
-
避免对共享资源的多重占用。
缺点:
-
不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。
-
由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。
-
单例类的职责过重，在一定程度上违背了“单一职责原则”。
-
滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。
使用注意事项:
-
使用时不能用反射模式创建单例，否则会实例化一个新的对象。？
-
使用懒单例模式时注意线程安全问题
-
饿单例模式和懒单例模式构造方法都是私有的，因而是不能被继承的，有些单例模式可以被继承（如登记式模式）
拓展：
反射攻击或者反序列化攻击