创建型模式的主要关注点事"怎样创建对象"，它的主要特点是将对象的创建与使用分离，这样可以降低系统的耦合度，使用者不需要关注对象的创建细节
单例设计模式
单例设计模式是java中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种设计模式涉及到一个单一的类，该类负责创建自己的对象，同时保证只有单个对象被创建，这个类提供了一种访问其唯一的对象方式，可以直接访问，不需要实例化该类的对象。
单例模式的结构
- 单例类：只能创建一个实例的类
- 访问类：使用单例的类。
单例模式的实现
- 饿汉式：类加载就会导致该单实例对象被创建
- 饿汉式-方式1（静态变量方式）
/**
* 饿汉式-静态变量创建类的对象
*/
public class Singleton {
// 私有的构造方法
private Singleton(){}
// 在成员位置创建该类的对象
private static Singleton instance = new Singleton();
// 对外提供静态方法获取对象
public static Singleton getInstance(){
return instance;
}
}
- 饿汉式-方式2（静态代码块方式）
/**
* 饿汉式-静态代码块中创建该类对象
*/
public class Singleton {
// 私有的构造方法
private Singleton(){}
//声明Singleton成员变量
private static Singleton instance;
// 在静态代码块中赋值
static{
instance = new Singleton();
}
// 对外提供静态方法获取对象
public static Singleton getInstance(){
return instance;
}
}
- 懒汉式：类加载不会导致该单实例对象创建，而是首次使用该对象时才会创建
- 懒汉式-方式1（线程不安全）
/**
* 懒汉式-线程不安全
*/
public class Singleton {
// 私有的构造方法
private Singleton(){}
//声明Singleton成员变量
private static Singleton instance;// 只是声明了该类型的变量，并没有进行赋值
//对外提供静态方法来获取该对象
public static Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
2.懒汉式-方式2（线程安全）
/**
* 懒汉式-线程安全
*/
public class Singleton {
// 私有的构造方法
private Singleton(){}
//声明Singleton成员变量
private static Singleton instance;// 只是声明了该类型的变量，并没有进行赋值
//对外提供静态方法来获取该对象
public static synchronized Singleton getInstance(){
if(instance == null){
// 线程1等待，线程2获取cpu执行权，也会进入到该判断里面
instance = new Singleton();
}
return instance;
}
}
3.懒汉式-方式3（双重检查锁）
对于上面的getInstance方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没有必要让每个线程必须只有锁才能调用该方法，我们需要调整加锁的时机。由此产生一个一个新的实现方式
/**
* 懒汉式-双重检查锁方式
*/
public class Singleton {
// 私有的构造方法
private Singleton(){}
//声明Singleton成员变量
private static Singleton instance;// 只是声明了该类型的变量，并没有进行赋值
//对外提供静态方法来获取该对象
public static Singleton getInstance(){
// 第一次判断，如果instance的值不为null，不需要抢占锁，直接返回对象
if(instance == null){
synchronized (Singleton.class){
// 第二次判断
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}
双重检查锁模式是一种非常好的单例实现模式，解决了单例，性能，线程安全问题，上面的双重检查锁模式看上去完美无缺，其实是存在多线程问题的，在多线程下可能出现空指针问题，出现该问题的原因是jvm在实例化对象的时候会进行优化和指令重排序操作。要解决双重检查锁模式带来的空指针的问题，需要使用volatile关键字，volitatile 关键字可以保证可见性和有序性
优化版-双重检查锁方式
/**
* 懒汉式-双重检查锁方式
*/
public class Singleton {
// 私有的构造方法
private Singleton(){}
//声明Singleton成员变量
private static volatile Singleton instance;// 只是声明了该类型的变量，并没有进行赋值
//对外提供静态方法来获取该对象
public static Singleton getInstance(){
// 第一次判断，如果instance的值不为null，不需要抢占锁，直接返回对象
if(instance == null){
synchronized (Singleton.class){
// 第二次判断
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}
4.懒汉式-方式4（静态内部类方式）
静态内部类单例模式中实例由内部类创建，由于jvm在加载外部类的过程中，是不会加载静态内部类的，只有内部类的属性，方法被调用的时候才会被加载，并初始化其静态属性，静态属性由于被static修饰，保证只被实例化一次，并且严格保证实例化顺序（解决了指令重排序）
/**
* 静态内部类方式
*/
public class Singleton {
// 私有构造方法
private Singleton(){}
// 定义一个静态的内部类
private static class SingletonHolder{
//在内部类中声明并初始化外部类对象
private static final Singleton SINGLETON = new Singleton();
}
// 对外提供静态方法获取该对象
public static Singleton getInstance(){
return SingletonHolder.SINGLETON;
}
}
5.枚举方式
枚举方式实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装在一次，设计者充分利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所有单例实现中唯一一种不会被破坏的单例实现模式
/**
* 枚举方式
*/
public enum Singleton {
INSTANCE;
}
单例模式存在的问题
破坏单例模式：使用上面定义的到单例类（Singleton）可以创建多个对象，枚举方式除外，有两种方式分别是序列化和反射
- 序列化反序列化
/**
* 测试序列化和反序列化破坏单例模式
*/
public class Client {
public static void main(String[] args) throws Exception{
//writeObject2File();
readObjectFromFile();
readObjectFromFile();
}
// 从文件中读取数据（对象）
public static void readObjectFromFile()throws Exception{
//1,创建对象输入流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
//2，读取对象
Singleton instance = (Singleton) ois.readObject();
System.out.println(instance);
// 3，释放资源
ois.close();
}
//向文件中写数据（对象）
public static void writeObject2File()throws Exception{
//1. 获取Singleton对象
Singleton instance = Singleton.getInstance();
//2.创建对象输出流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
//3. 写对象
oos.writeObject(instance);
//4.释放资源
oos.close();
}
}
输出结果(表明不是同一个对象)：
com.netty.desigin.Singleton@27716f4
com.netty.desigin.Singleton@8efb846
- 反射模式破坏单例
/**
* 测试反射破坏单例模式
*/
public class Client {
public static void main(String[] args) throws Exception{
//1.获取Singleton的字节码对象
Class<Singleton> clazz = Singleton.class;
//2.获取无参构造方法对象
Constructor<Singleton> cons = clazz.getDeclaredConstructor();
//3.需取消访问检查
cons.setAccessible(true);
//4.创建Singleton对象
Singleton singleton = cons.newInstance();
Singleton singleton1 = cons.newInstance();
System.out.println(singleton == singleton1);
}
}
输出结果
false
问题解决方案
- 序列化反序列化方式破坏单例模式的解决方法
在Singleton类中添加readResolve()方法，在反序列化时候被反射调用，如果定义了这个方法，就返回这份方法的值，如果没有定义，则返回新new 出来的对象
public class Singleton implements Serializable {
// 私有的构造方法
private Singleton(){}
//声明Singleton成员变量
private static Singleton instance;
// 在静态代码块中赋值
static{
instance = new Singleton();
}
// 对外提供静态方法获取对象
public static Singleton getInstance(){
return instance;
}
// 当进行反序列化时，会自动调用该方法，将该方法的返回值直接返回
public Object readResolve(){
return instance;
}
}
输出结果：
com.netty.desigin.Singleton@27716f4
com.netty.desigin.Singleton@27716f4
- 反射方式破解单例的解决方法(不允许多次调用构造方法)
// 私有的构造方法
private Singleton(){
/**
* 反射破坏单例需要添加代码
*/
if(instance != null){
throw new RuntimeException();
}
}
JDK源码解析 - Runtime 类
public class Runtime {
private static Runtime currentRuntime = new Runtime();
/**
* Returns the runtime object associated with the current Java application.
* Most of the methods of class <code>Runtime</code> are instance
* methods and must be invoked with respect to the current runtime object.
*
* @return the <code>Runtime</code> object associated with the current
* Java application.
*/
public static Runtime getRuntime() {
return currentRuntime;
}
/** Don't let anyone else instantiate this class */
private Runtime() {}
