单例模式
-
提供了一种创建对象的最佳方式
-
这种模式涉及到一个单一的类, 该类负责创建自己的对象, 同时确保只有单个对象被创建. 这个类提供类一种访问唯一对象的方式, 可以直接访问, 不需要实例化该类的对象
单例模式的实现
饿汉式: 类加载就会导致该单实例对象被创建
懒汉式: 类加载不会导致该实例对象被创建, 而是首次使用该对象的时候被创建
饿汉式 - 方式1（静态变量）
public class Singleton {
//km 1、私有构造方法
private Singleton() {
}
//kf 2、在本类中创建本类对象
private static Singleton instance = new Singleton();
//km 3、提供一个公共的访问方式, 让外界获取该对象
public static Singleton getInstance() {
return instance;
}
}该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。
饿汉式 - 方式2（静态代码块）
public class Singleton {
//km 1、私有构造方法
private Singleton() {
}
//kf 2、声明Singleton类型的变量
private static Singleton instance; //null
//km 3、在静态代码块中赋值
static {
instance = new Singleton();
}
//km 4、对外提供获取该类的方法
public static Singleton getInstance() {
return instance;
}
}该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。
懒汉式 - 方式1（线程不安全）
public class Singleton {
//km 1、私有构造方法
private Singleton() {
}
//kf 2、声明Singleton类型的变量instance
private static Singleton instance;
//km 3、对外提供访问方式
public static Singleton getInstance() {
//kp 判断instance是否为null, 如果为null, 说明还没有创建Singleton类的对象, 如果没有, 创建并返回, 如果有直接返回
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作，那么什么时候赋值的呢？当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题。
懒汉式 - 方式2（线程安全）
public class Singleton {
//私有构造方法
private Singleton() {}
//在成员位置创建该类的对象
private static Singleton instance;
//对外提供静态方法获取该对象
public static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。
懒汉式 - 方式3（双检锁）
再来讨论一下懒汉模式中加锁的问题，对于 getInstance() 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。由此也产生了一种新的实现模式：双重检查锁模式
public class Singleton {
//km 1、私有构造方法
private Singleton() {
}
//kf 2、声明Singleton类型的变量instance, 使用volatile关键字修饰, 禁止指令重排, 以杜绝可能出现空指针的问题
private static volatile Singleton instance;
//km 3、对外提供访问方式
public static Singleton getInstance() {
//kp 第一次判断, 如果instance的值不为null, 不需要抢占锁, 直接返回对象
if (instance == null) {
synchronized (Singleton.class) {
//kp 第二次判断
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。
要解决双重检查锁模式带来空指针异常的问题，只需要使用
volatile关键字,volatile关键字可以保证可见性和有序性。
懒汉式 - 方式4（静态内部类）
静态内部类单利模式中实例由内部类创建, 由于JVM在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性、方法被调用时才会被加载, 并初始化其静态属性. 静态属性由于被 static 修饰, 保证只被实例化一次, 并且严格保证实例化顺序
在静态内部类里 创建 并 初始化 外部类的实例， 只会初始化一次
public class Singleton {
/**
* km 私有构造方法
*/
private Singleton() {
}
/**
* kc 静态内部类
*/
private static class SingletonHolder {
//kp 在内部类中声明并初始化外部类的对象
private static final Singleton INSTANCE = new Singleton();
}
/**
* km 提供公共的访问方式
*
* @return
*/
public static Singleton getInstance(){
return SingletonHolder.INSTANCE;
}
}
第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance，虚拟机加载SingletonHolder
并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。
静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。
懒汉式 - 方式4（枚举）
枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。
/**
* 枚举方式
*/
public enum Singleton {
INSTANCE;
}不考虑浪费内存空间的情况下, 首选枚举方式
存在的问题
破坏单例模式：
使上面定义的单例类（Singleton）可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。
序列化反序列化
Singleton类：
public class Singleton implements Serializable {
//私有构造方法
private Singleton() {}
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
//对外提供静态方法获取该对象
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}Test类：
public class Test {
public static void main(String[] args) throws Exception {
//往文件中写对象
//writeObject2File();
//从文件中读取对象
Singleton s1 = readObjectFromFile();
Singleton s2 = readObjectFromFile();
//判断两个反序列化后的对象是否是同一个对象
System.out.println(s1 == s2);
}
private static Singleton readObjectFromFile() throws Exception {
//创建对象输入流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\a.txt"));
//第一个读取Singleton对象
Singleton instance = (Singleton) ois.readObject();
return instance;
}
public static void writeObject2File() throws Exception {
//获取Singleton类的对象
Singleton instance = Singleton.getInstance();
//创建对象输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\a.txt"));
//将instance对象写出到文件中
oos.writeObject(instance);
}
}上面代码运行结果是
false，表明序列化和反序列化已经破坏了单例设计模式。
反射
Singleton类：
public class Singleton {
//私有构造方法
private Singleton() {}
private static volatile Singleton instance;
//对外提供静态方法获取该对象
public static Singleton getInstance() {
if(instance != null) {
return instance;
}
synchronized (Singleton.class) {
if(instance != null) {
return instance;
}
instance = new Singleton();
return instance;
}
}
}Test类：
public class Test {
public static void main(String[] args) throws Exception {
//获取Singleton类的字节码对象
Class clazz = Singleton.class;
//获取Singleton类的私有无参构造方法对象
Constructor constructor = clazz.getDeclaredConstructor();
//取消访问检查
constructor.setAccessible(true);
//创建Singleton类的对象s1
Singleton s1 = (Singleton) constructor.newInstance();
//创建Singleton类的对象s2
Singleton s2 = (Singleton) constructor.newInstance();
//判断通过反射创建的两个Singleton对象是否是同一个对象
System.out.println(s1 == s2);
}
}上面代码运行结果是
false，表明序列化和反序列化已经破坏了单例设计模式
注意：枚举方式不会出现这两个问题。
问题的解决
序列化、反序列化的解决方式
在Singleton类中添加readResolve()方法, 在序列化时候被反射调用, 如果定义了这个方法, 就返回这个方法的值, 如果没有定义, 则返回新new出来的对象
-
当进行反序列化时候, 会自动调用该方法, 将该方法的返回值直接返回
public class Singleton implements Serializable {
//私有构造方法
private Singleton() {}
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
//对外提供静态方法获取该对象
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
/**
* 下面是为了解决序列化反序列化破解单例模式
*/
private Object readResolve() {
return SingletonHolder.INSTANCE;
}
}底层源码 - ObjectInputStream类
public final Object readObject() throws IOException, ClassNotFoundException{
...
// if nested read, passHandle contains handle of enclosing object
int outerHandle = passHandle;
try {
Object obj = readObject0(false);//重点查看readObject0方法
.....
}
private Object readObject0(boolean unshared) throws IOException {
...
try {
switch (tc) {
...
case TC_OBJECT:
return checkResolve(readOrdinaryObject(unshared));//重点查看readOrdinaryObject方法
...
}
} finally {
depth--;
bin.setBlockDataMode(oldMode);
}
}
private Object readOrdinaryObject(boolean unshared) throws IOException {
...
//isInstantiable 返回true，执行 desc.newInstance()，通过反射创建新的单例类，
obj = desc.isInstantiable() ? desc.newInstance() : null;
...
// 在Singleton类中添加 readResolve 方法后 desc.hasReadResolveMethod() 方法执行结果为true
if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
// 通过反射调用 Singleton 类中的 readResolve 方法，将返回值赋值给rep变量
// 这样多次调用ObjectInputStream类中的readObject方法，继而就会调用我们定义的readResolve方法，所以返回的是同一个对象。
Object rep = desc.invokeReadResolve(obj);
...
}
return obj;
}反射破解解决方法
判断当前这个单例的实例对象是否真的存在, 如果真的存在就直接, 如果不存在则抛出一个运行时异常
public class Singleton {
//kf 判断是否是第二次进入单例
private static boolean flag = false;
//km 私有构造方法
private Singleton() {
synchronized (com.itheima.pattern.singleton.demo3.Singleton.class){
// ks 判断flag的值是否为true, 如果是true, 不是第一次访问 - 直接抛一个异常
// 如果是false说明第一次访问, 向下执行, 并将flag值设置为true
if(flag){
throw new RuntimeException("不能创建多个对象");
}
//将flag的值设置为true
flag = true;
}
}
/**
* kc 静态内部类
*/
private static class SingletonHolder {
//kp 在内部类中声明并初始化外部类的对象
private static final Singleton INSTANCE = new Singleton();
}
/**
* km 提供公共的访问方式
*
* @return
*/
public static Singleton getInstance(){
return SingletonHolder.INSTANCE;
}
}DK源码解析-Runtime类
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() {} ... }从上面源代码中可以看出Runtime类使用的是恶汉式（静态属性）方式来实现单例模式的。
-
使用Runtime类中的方法
public class RuntimeDemo { public static void main(String[] args) throws IOException { //获取Runtime类对象 Runtime runtime = Runtime.getRuntime(); //返回 Java 虚拟机中的内存总量。 System.out.println(runtime.totalMemory()); //返回 Java 虚拟机试图使用的最大内存量。 System.out.println(runtime.maxMemory()); //创建一个新的进程执行指定的字符串命令，返回进程对象 Process process = runtime.exec("ipconfig"); //获取命令执行后的结果，通过输入流获取 InputStream inputStream = process.getInputStream(); byte[] arr = new byte[1024 * 1024* 100]; int b = inputStream.read(arr); System.out.println(new String(arr,0,b,"gbk")); } }