浅谈设计模式 - 单例模式（一）
# 什么是单例模式？
## 介绍
保证一个类仅有一个实例，并提供一个全局访问点
## 单例模式的几个应用场景
1. SpringBean 默认就是单例的，不过用的是动态代{过}{滤}理生成代{过}{滤}理对象
2. 工具类里面，由一个单例保存
3. 其他需要唯一对象的场景
## 如何实现单例模式
## 饿汉式
解释：和名字一般，很饿，所以在使用之前就做好了准备
### 优点：
1. 保证单例对象不会重复
2. 永远不会有重复创建的隐患
### 缺点：
1. 如果对象较大比较占用jvm内存空间
2. 影响性能，带来没有必要的对象创建。
### 实现代码：
```java
/**
*
* 单例模式 - 饿汉式
* @AuThor zhaoxudong
* @version 1.0
* @date 2020/10/27 21:45
*/
public class Hungry {
private static final Hungry instance = new Hungry();
public static Hungry getInstance(){
return instance;
}
public static void main(String[] args) {
Hungry instance = Hungry.getInstance();
System.err.println(instance);
}
}
```
非常简单，在创建之前，旧对对象进行了初始化，其实对于比较小的对象，这种方式在实际的使用过程中最多
## 懒汉式
解释：犹如一个懒汉，只有在使用到的时候，才进行初始化。
### 优点：
1. 可以节省系统资源只有真正使用的时候，才会进行获取
2. 对于
### 缺点：
1. 如果多线程并发访问会出现多?***奈侍?
### 实现代码：
```java
package com.zxd.interview.desginpattern.single;
import com.zxd.interview.util.ExecuteUtil;
/**
* 单例模式 - 懒汉式
*
* @author zhaoxudong
* @version 1.0
* @date 2020/10/27 21:45
*/
public class Lazy {
public static void main(String[] args) {
// 常规多线程
// for (int i = 0; i < 100; i++) {
// new TestRunThread().start();
// }
try {
ExecuteUtil.startTaskAllInOnce(50000, new TestRunThread());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 模拟异步请求
* 模拟十组数据
*/
class TestRunThread extends Thread {
@Override
public void run() {
// 懒汉式第一版
// int i = LazyVersion1.getInstance().hashCode();
// 懒汉式第二版
// int i = LazyVersion2.getInstance1().hashCode();
// 懒汉式第三版
int i = LazyVersion2.getInstance2().hashCode();
System.err.println(i);
}
}
/**
* 饿汉式的第一版本
*/
class LazyVersion1 {
private static LazyVersion1 lazyVersion1;
public static LazyVersion1 getInstance() {
if (lazyVersion1 == null) {
// 验证是否创建多个对象
try {
// 模拟在创建对象之前做一些准备工作
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
lazyVersion1 = new LazyVersion1();
}
return lazyVersion1;
}
}
/**
* 懒汉式的第二版本
* 1. 直接对整个方法加锁
* 2. 在局部代码块加锁
*/
class LazyVersion2 {
/**
非常重要的点： volatile 避免cpu指令重排序
*/
private static volatile LazyVersion2 lazyVersion2;
/**
* 在方法的整体加入 synchronized
*
* @return
*/
public synchronized static LazyVersion2 getInstance1() {
if (lazyVersion2 == null) {
// 验证是否创建多个对象
try {
// 模拟在创建对象之前做一些准备工作
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
lazyVersion2 = new LazyVersion2();
}
return lazyVersion2;
}
/**
* 在局部代码快加入 synchronized
*
* @return
*/
public static LazyVersion2 getInstance2() {
if (lazyVersion2 == null) {
// 验证是否创建多个对象
try {
// 模拟在创建对象之前做一些准备工作
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (LazyVersion2.class) {
if (lazyVersion2 == null) {
lazyVersion2 = new LazyVersion2();
}
}
}
return lazyVersion2;
}
}
```
### 注意点：
1. `volatile` 关键字是JDK1.5之后的JMM为了防止CPU指令重排序的问题而加入的一种具体机制
2. 虽然发生的几率非常小的，但是指令重排序是JVM的本身特点
```java
private static volatile LazyVersion2 lazyVersion2;
```
## 静态代码块
和饿汉式差不多，这里不在过多赘述，直接上代码：
### 实现代码：
```java
/**
* 静态代码块的形式，实现单例
*
* @Author zhaoxudong
* @Date 2020/10/28 13:28
**/
public class StaticBlock {
private static final StaticBlock staticBlock;
static {
staticBlock = new StaticBlock();
}
public static StaticBlock getInstance() {
return staticBlock;
}
}
```
## 静态内部类：
### 优点：
1. 既可以保证一次加载，又可以保证不出现重复的初始化
2. 可以用一个大类管理所有的内部类
### 缺点：
1. 额外需要多一个内部类
2. 破坏代码设计模式
### 实现代码：
```java
package com.zxd.interview.desginpattern.single;
import com.zxd.interview.util.ExecuteUtil;
/**
* 单例模式 - 静态内部类实现
*
* @Author zhaoxudong
* @Date 2020/10/28 13:35
**/
public class SingleStaticInner {
/**
* 使用内部类来进行后续的构造
*/
public static class Instatnce {
private static Instatnce instatnce = new Instatnce();
public static Instatnce getInstatnce() {
try {
// 模拟在创建对象之前做一些准备工作
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return instatnce;
}
}
public static void main(String[] args) throws InterruptedException {
ExecuteUtil.startTaskAllInOnce(250, new ThreadTest());
}
}
/**
* 测试多线程获取对象
*/
class ThreadTest extends Thread {
@Override
public void run() {
System.err.println(SingleStaticInner.Instatnce.getInstatnce());
}
}
```
## 序列化/反序列化的问题：
解释：序列化和反序列化的情况下，会出现问题，因为JAVA的序列化从磁盘读取的时候，会生成新的实例对象，但是这样就会违背单例模式的方式
### 实现代码：
```java
package com.zxd.interview.desginpattern.single;
import java.io.*;
/**
* 单例模式 - 序列化与反序列化的问题和解决办法
* @Author zhaoxudong
* @Date 2020/10/28 13:55
**/
public class SingleSerialize {
public static void main(String[] args) throws IOException, ClassNotFoundException {
SerializeStaticInner instance = SerializeStaticInner.getInstance();
System.err.println(instance.hashCode());
// 序列化
FileOutputStream fileOutputStream = new FileOutputStream("temp");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(instance);
objectOutputStream.close();
fileOutputStream.close();
// 反序列化
FileInputStream fileInputStream = new FileInputStream("temp");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
SerializeStaticInner read = (SerializeStaticInner) objectInputStream.readObject();
objectInputStream.close();
fileInputStream.close();
System.err.println(read.hashCode());
}
static class SerializeStaticInner implements Serializable{
private staticSerializeStaticInner serializeStaticInner = new SerializeStaticInner();
public static SerializeStaticInner getInstance(){
return serializeStaticInner;
}
/**
* 序列化当中的一个钩子方法
* 避免序列化和反序列化的对象为新实例破坏单例模式的规则
*/
// protected Object readResolve(){
// System.err.println("调用特定的序列化方法");
// return SerializeStaticInner.serializeStaticInner;
// }
}
}
```
1. 如果没有`readResolve()`，那么序列化之后反序列化是会变为一个新的实例，这样会破坏单例模式
2. 如果存在`readResolve()`，那么序列化之后的对象就不会出现多个实例
## 扩展：为什么加入`readResolve()` 方法就可以避免序列化的问题
下面是关于《effective Java》的解释
关于此方法的访问权注意事项
## 扩展：序列化必知：
+ 所有需要网络传输的对象都需要实现序列化接口，通过建议所有的javaBean都实现Serializable接口。
+ 对象的类名、实例变量（包括基本类型，数组，对其他对象的引用）都会被序列化；方法、类变量、transient实例变量都不会被序列化。
+ 如果想让某个变量不被序列化，使用transient修饰。
+ 序列化对象的引用类型成员变量，也必须是可序列化的，否则，会报错。
+ 反序列化时必须有序列化对象的class文件。
+ 当通过文件、网络来读取序列化后的对象时，必须按照实际写入的顺序读取。
+ 单例类序列化，需要重写readResolve()方法；否则会破坏单例原则。
+ 同一对象序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化编号，不会重复序列化。
+ 建议所有可序列化的类加上serialVersionUID 版本号，方便项目升级。
### 来源：
我不会去拾人牙慧，所以这里记录一下
(https://juejin.im/post/6844903848167866375#heading-11)
# 其他优质文章：
(https://blog.csdn.net/u014672511/article/details/79774847) 我又想了这玩意，玩到代{过}{滤}理就没学了，没有啥学习精神了 本帖最后由 四十九画 于 2020-10-29 11:34 编辑
静态代码块也可以归置为饿汉式吧 一开始学这东西就觉得头疼，比数据结构还头疼 枚举也是单例的，可以使用枚举 还可以使用枚举啊
页:
[1]