单例模式
饿汉式
package com.zkw.single;
// 饿汉式单例
public class Hungry {
// 可能会浪费资源
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
private byte[] data3 = new byte[1024*1024];
private byte[] data4 = new byte[1024*1024];
private Hungry(){
}
private final static Hungry HUNGRY = new Hungry();
public static Hungry getInstance(){
return HUNGRY;
}
}
懒汉式 DCL
多线程下单例不唯一
package com.zkw.single;
//懒汉式单例
public class LazyMan {
private LazyMan(){
System.out.println(Thread.currentThread().getName()+" ok");
}
private volatile static LazyMan lazyMan;
//双重检测锁模式 懒汉式单例 DCL懒汉式
public static LazyMan getInstance(){
//加锁
if (lazyMan == null){
synchronized (LazyMan.class){
if(lazyMan==null){
lazyMan = new LazyMan();//不是一个原子性操作
}
}
}
return lazyMan;
}
/**
* lazyMan = new LazyMan()的三步
* 1、分配内存空间
* 2、执行方法,初始化对象
* 3、把这个对象指向这个空间
*
* 正常,我们的期望执行顺序123
* 在指令重排的时候
*可能会把这三步变成132
* 当成132的时候,而且在多线程的情况下,线程A为132
* 则线程B直接return了,但是此时LazyMan还没有完成构造
*
* 解决方法: private static LazyMan lazyMan;
* 加上Volatile就可以了 private volatile static LazyMan lazyMan;
*/
// 多线程并发
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
new Thread(()->{
LazyMan.getInstance();
}).start();
}
}
}
package com.zkw.single;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
public class LazyMan2 {
private static boolean flag = false;
private LazyMan2(){
synchronized (LazyMan2.class){
if (flag == false){
flag = true;
} else {
throw new RuntimeException("不要试图用反射破坏异常");
}
}
}
private volatile static LazyMan2 lazyMan2;
//双重检测锁模式 懒汉式单例 DCL懒汉式
public static LazyMan2 Instance(){
//加锁
if (lazyMan2 == null){
synchronized (LazyMan.class){
if(lazyMan2==null){
lazyMan2 = new LazyMan2();//不是一个原子性操作
}
}
}
return lazyMan2;
}
//使用反射破坏单例模式
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
Field flag1 = LazyMan2.class.getDeclaredField("flag");
flag1.setAccessible(true);
Constructor<LazyMan2> declaredConstructor = LazyMan2.class.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true);
LazyMan2 lazyMan21 = declaredConstructor.newInstance();
flag1.set(lazyMan21,false);
LazyMan2 lazyMan2 = declaredConstructor.newInstance();
System.out.println(lazyMan21);
System.out.println(lazyMan2);
}
}
枚举
枚举当中没有无参构造,只有两个参数的有参构造
package com.zkw.single;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
//enum(枚举) 是什么? 本身也是一个Class类
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance(){
return INSTANCE;
}
}
class Test{
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
EnumSingle instance = EnumSingle.INSTANCE;
Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
EnumSingle instance1 = declaredConstructor.newInstance();
System.out.println(instance);
System.out.println(instance1);
}
}