单例模式特点:
- 只允许有一个实例
- 单例类必须创建自己的唯一的实例
- 单例类必须向其他对象提供获取这一实例的方法(getInstance())
饿汉式
package lin.single;
//饿汉式单例
public class Hungry {
// 可能会浪费空间
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
//构造器私有,别人就无法去new这个对象,保证内存中只有一个对象
private Hungry(){
}
private final static Hungry HUNGRY = new Hungry();
public static Hungry getInstance(){
return HUNGRY;
}
}
懒汉式
package lin.single;
//懒汉式单例
public class LazyMan {
private LazyMan(){
System.out.println(Thread.currentThread().getName()+" ok!");
}
private static LazyMan lazyMan;
public static LazyMan getInstance(){
if (lazyMan == null) {
lazyMan = new LazyMan();
}
return lazyMan;
}
//单线程下确实单例可以,多线程并发就没用了
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
LazyMan.getInstance();
}).start();
}
}
}
解决多线程并发的情况:双重检测锁模式的 懒汉式单例(DCL懒汉式)
package lin.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(); //不是原子性操作
/*
* 1、分配内存空间
* 2、执行构造方法,初始化对象
* 3、把这个对象指向这个空间
* */
}
}
}
return lazyMan;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
LazyMan.getInstance();
}).start();
}
}
}
单例不安全(因为有反射)-----枚举解决
举例:
package lin.single;
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 Exception {
EnumSingle enumSingle1 = EnumSingle.INSTANCE;
// EnumSingle enumSingle2 = EnumSingle.INSTANCE;
Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
EnumSingle enumSingle2 = declaredConstructor.newInstance();
System.out.println(enumSingle1);
System.out.println(enumSingle2);
}
}
结果: 这时候想要用反射去破坏,就会报错(不能反射创建枚举类)
枚举没有无参构造,只有有参构造(两个参数)
枚举类型的最终反编译源码: