单利模式：只允许创建一个实例
单利模式的几种实现方式:
-
饿汉式
/**
* 饿汉式
* 优点：避免了多线程并发问题
* 缺点: 创建好的对象不是及时的调用会浪费内存空间
*/
public class Hungry {
private static Hungry hungry = new Hungry();
private Hungry(){}
public static Hungry INSTANCE(){
return hungry;
}
}
image.gif
/**
* 饿汉式的变种 优缺点跟饿汉式一样
*/
public class Hungry1 {
private static Hungry1 hungry1;
static {
hungry1 = new Hungry1();
}
private Hungry1(){}
public static Hungry1 INSTANCE(){
return hungry1;
}
}
image.gif
-
懒汉式
/**
* 懒汉式
* 优点:只有用到这个实例时才会创建 避免了内存空间的浪费
* 缺点: synchronized 使多线程变成了串行 多线程并发的情况下会影响程序效率
*/
public class Lazy {
private static Lazy lazy;
private Lazy() {
}
public synchronized static Lazy INSTANCE() {
if (lazy == null) {
lazy = new Lazy();
}
return lazy;
}
}
image.gif
-
懒汉式:双重检查加锁
/**
* 懒汉式:双重检查加锁
* 优缺点跟经典懒汉式一致
* 加入多层判断 保证了不会创建多个实例
* volatile 关键字 是防止指令重排序
* lazy =new Lazy1(); 这个代码会发生指令重排序 这段代码在底层执行的时候不是原子操作
* 事实上在 JVM 中这句话大概做了下面 3 件事情。
* 1\. 给 lazy 分配内存
* 2\. 调用 Lazy1 的构造函数来初始化成员变量，形成实例
* 3\. 将lazy对象指向分配的内存空间（执行完这步lazy才是非 null了）
* 在JVM的即时编译器中存在指令重排序的优化。
* 也就是说上面的第二步和第三步的顺序是不能保证的，
* 最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，
* 则在 3 执行完毕、2 未执行之前，当前线程停止了，被线程二抢占了，
* 这时 lazy 已经是非 null 了（这个引用已经指向了分配的内存空间,但却没有初始化），
* 所以线程二会直接返回 lazy，然后使用，然后顺理成章地报错。
* 线程的指令重排序:简单的说 就是jvm会对执行的代码指令进行优化处理 有可能会置换两个
* 没有因果关系的代码指令 进行执行 eg：
* 1\. int a =0
* 2\. int b =1
* 这个两个赋值 的先后对代码不会有影响 ，那么就会有可能发生指令重排序
* 执行顺序 有可能 是 1-2 或者 2-1 都是有可能的。
*/
public class Lazy1 {
private static volatile Lazy1 lazy;
private Lazy1() {
}
public static Lazy1 INSTANCE1() {
if (lazy == null) {
synchronized (Lazy1.class) {
if (lazy == null) {
lazy = new Lazy1();
}
}
}
return lazy;
}
}
image.gif
-
静态内部类
/**
*
* 静态内部类
* 在只使用了外部类，但是没有使用内部类的情况下，内部类里面的东西不会被初始化。
* 这种实现单利模式的方式 既不会浪费内存空间 又不会 有并发的问题
*
*/
public class StaticInnerClass {
private StaticInnerClass(){}
private static class SimpleInstance{
private static final StaticInnerClass sic = new StaticInnerClass();
}
public static StaticInnerClass getInstance(){
return SimpleInstance.sic;
}
}
image.gif
-
注册登记式
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
/**
* 注册登记式
* 这种实现单利模式 可以维护一组单利实例 spring中采用的就是这种模式
*
*/
public class RegSingleton implements Serializable{
private static Map<String,Object> singletonMap = new HashMap();
static {
singletonMap.put(RegSingleton.class.getName(),new RegSingleton());
}
protected RegSingleton(){}
public static Object getInstance(String name){
if(name == null){ name = "RegSingleton"; }
if(singletonMap.get(name)==null){
try {
singletonMap.put(name, Class.forName(name).newInstance());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} }
return singletonMap.get(name); }
}
image.gif
-
枚举
/**
* 你可以通过EasySingleton.INSTANCE来访问，也可以实现单利，这比调用getInstance()方法简单多了。
*/
public enum EasySingleton{
INSTANCE;
}
image.gif
-
防止反射破坏单利
/**
* 这种方式可以防止单利被破坏
*/
public class ReflexSingleton {
private static ReflexSingleton reflexSingleton = new ReflexSingleton();
private ReflexSingleton() {
if (reflexSingleton != null) throw new RuntimeException("单利被破坏");
}
public static ReflexSingleton getInstance() {
return reflexSingleton;
}
public static void main(String[] args) throws IllegalAccessException, InstantiationException {
try {
ReflexSingleton reflexSingleton = ReflexSingleton.class.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
ReflexSingleton instance = ReflexSingleton.getInstance();
}
}
image.gif
-
序列化和反序列化中的单利模式
package com.swh.design.simgle;
import java.io.*;
/**
* 假如单利模式实现了序列化 会对单利模式进行破坏
* 当对象序列化 然后再被反序列化的时候 会创建不同的实体
* 因为反序列化的底层实现也是用的反射来创建对象的
* 反序列化的底层代码实现:
* private Object readOrdinaryObject(boolean unshared) throws IOException {
* Object obj;
* try {
* obj = desc.isInstantiable() ? desc.newInstance() : null; // 此处如果对象实现了序列化Serializable接口，则通过反射创建对象 反射创建对象 会打破封装 创建出新的实例
* } catch (Exception ex) {
* throw (IOException) new InvalidClassException(desc.forClass().getName(),
* "unable to create instance").initCause(ex);
* }
* //此处省略部分代码
* if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()){ // 如果对象实现了readResolve() 方法 会通过上面创建的对象反射调用该方法
* Object rep = desc.invokeReadResolve(obj);
* if (unshared && rep.getClass().isArray()) {
* rep = cloneArray(rep);
* }
* if (rep != obj) {
* handles.setObject(passHandle, obj = rep) // 把从readResolve()方法中拿到的返回结果重新复制给obj对象 进行返回
* }
* }
* return obj;
* }
*
* 由上面的源码得出 只要对象中提供readResolve() 方法就可以防止反序列化创建新的实例
*
*/
public class SerializableSingleton implements Serializable{
private static volatile SerializableSingleton serializableSingleton;
public SerializableSingleton() {
}
public static SerializableSingleton getInstance(){
if(serializableSingleton == null) {
synchronized (SerializableSingleton.class){
if(serializableSingleton == null) {
serializableSingleton = new SerializableSingleton();
}
}
}
return serializableSingleton;
}
private Object readResolve() {
return serializableSingleton;
}
public static void main(String[] args) {
try {
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("serializable"));
objectOutputStream.writeObject(SerializableSingleton.getInstance());
File serializable = new File("serializable");
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(serializable));
SerializableSingleton serializableSingleton = (SerializableSingleton) inputStream.readObject();
System.out.println(serializableSingleton == SerializableSingleton.getInstance());
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
image.gif
