设计模式总结

采用字节重组，重新生成对象来替代原始对象，以达到动态代理的目的

1.获取被代理对象的引用，并且反射获取它所有的接口

2.jdk动态代理类重新生成一个新的类，同时新的类要实现被代理类实现的所有接口

3.动态生成java代码，根据新加的业务方法生成

4.编译新生成的class文件，重新运行

JDK代理的目标对象必须要实现接口，因为JDK代理是根据被代理对象的所有接口去生成新的方法！但是Proxy.newProxyInstance返回的是接口类，而非实现，所以JDK只能代理接口！！

CGLib代理的目标对象不需要实现任何接口，它是通过动态继承目标对象实现动态代理的

1. 创建被代理的类及方法；

2. 创建一个实现接口 MethodInterceptor 的代理类，重写 intercept 方法；

3. 创建获取被代理类的方法 getInstance(Object target);

4. 获取代理类，调用代理类方法。

CGLib代理不需要被代理对象实现任何接口，它会重写被代理类的所有方法，所以不能代理final修饰
的方法或者类，因为被final修饰后，表明这个类不能被继承

private static final HungrySingleton hungrySingleton = new HungrySingleton();

private HungrySingleton(){}

public static HungrySingleton getInstance() {
        return instance;
}

private static final HungryStaticSingleton hungrySingleton;

static {
        hungrySingleton = new HungryStaticSingleton();
 }

private HungryStaticSingleton(){}

public static HungryStaticSingleton getInstance(){
        return  hungrySingleton;
 }

private static LazySimpleSingletion instance;

private LazySimpleSingletion(){}

public static LazySimpleSingletion getInstance(){
        //有线程安全问题,可以使用
        if(instance == null){
              instance = new LazySimpleSingletion();
        }
       return instance;
}

private static LazySimpleSingletion instance;

private LazySimpleSingletion(){}

public synchronized static LazySimpleSingleton getInstance() {
        if (instance == null) {
            instance = new LazySimpleSingleton();
        }
        return instance;
    }

private volatile static LazyDoubleCheckSingleton instance;

private LazyDoubleCheckSingleton(){}

public static LazyDoubleCheckSingleton getInstance(){
      //检查是否要阻塞,如果已经创建过，就不需要再进入加锁代码块拉低性能，大大的提升性能，如果
没有该检查，每次都会去竞争锁
     if (instance == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
            //检查是否要重新创建实例
           //如果没有该判断，2个线程在第一个if都判断为null,那么就会创建2个实例
                  if (instance == null) {
                      instance = new LazyDoubleCheckSingleton();
                  }
             }
        }
        return instance;
}

为什么要加volatile？

概念：双重检查锁有一定性能问题，那么我们还可以采用静态内部类的方式，该方式同样也是利用了类的加载机制，它与饿汉模式不同的是，它是在内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全。

private LazyStaticInnerClassSingleton(){
      //解决反射破坏，因为反射可以调用私有的构造器
      if(LazyHolder.INSTANCE != null){
           throw new RuntimeException("不允许非法访问");
     }
}

private static LazyStaticInnerClassSingleton getInstance(){
      return LazyHolder.INSTANCE;
}

private static class LazyHolder{
      private static final LazyStaticInnerClassSingleton INSTANCE = new LazyStaticInnerClassSingleton();
}

解决办法

解决办法