Cglib 动态代理

最新推荐文章于 2020-09-19 15:17:59 发布
最新推荐文章于 2020-09-19 15:17:59 发布
阅读量133 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32924343/article/details/80277196
版权

JDK的动态代理需要被代理类要实现接口，但是Cglib不需要，Cglib会生成代理类的子类，并在代理类中对代理方法进行增强，CGlib的底层是采用的ASM字节码技术。

一切的学习从例子开始：

一、测试用例

1. 需要被代理的目标类

public class PersonC {

    public void doSomething(){

        System.out.println("doing");

    }

    public void doOtherthing(){
        
        System.out.println("doing other");

    }
}

2.增强方法

public class CglibProxy implements MethodInterceptor {

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before...");
        methodProxy.invokeSuper(o, objects);
        System.out.println("end...");
        return null;
    }
}

3.测试类

public class TestCg {

    public static void main(String[] args) {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\");
        CglibProxy cglibProxy = new CglibProxy();
        Enhancer e = new Enhancer();
        e.setSuperclass(PersonC.class);
        e.setCallback(cglibProxy);
        PersonC target = (PersonC) e.create();
        target.doSomething();
        target.doOtherthing();
    }
}

4.输出

before...
doing
end...
before...
doing other
end...
二、代理对象的生成：

2.1 代理对象是通过Enhancer类创建的。它是Cglib的字节码增强器。

2.2 创建关键步骤：

    2.2.1 生成代理类的二进制字节码。

    2.2.2 加载字节码，生成Class对象。

    2.2.3 通过反射创建代理类对象。

2.3 抢先欣赏一下生成的代理类，便于后续理解。截取的是我本地能展示出来的Java代码（注意不是使用反编译工具打开的，使用IDE打开的，好像反编译工具有些代码编译不了）。

public class PersonC$$EnhancerByCGLIB$$2b07307e extends PersonC implements Factory {
    private boolean CGLIB$BOUND;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static final Method CGLIB$doSomething$0$Method;
    private static final MethodProxy CGLIB$doSomething$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$doOtherthing$1$Method;
    private static final MethodProxy CGLIB$doOtherthing$1$Proxy;
    private static final Method CGLIB$finalize$2$Method;
    private static final MethodProxy CGLIB$finalize$2$Proxy;
    private static final Method CGLIB$equals$3$Method;
    private static final MethodProxy CGLIB$equals$3$Proxy;
    private static final Method CGLIB$toString$4$Method;
    private static final MethodProxy CGLIB$toString$4$Proxy;
    private static final Method CGLIB$hashCode$5$Method;
    private static final MethodProxy CGLIB$hashCode$5$Proxy;
    private static final Method CGLIB$clone$6$Method;
    private static final MethodProxy CGLIB$clone$6$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("PersonC$$EnhancerByCGLIB$$2b07307e");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$finalize$2$Method = var10000[0];
        CGLIB$finalize$2$Proxy = MethodProxy.create(var1, var0, "()V", "finalize", "CGLIB$finalize$2");
        CGLIB$equals$3$Method = var10000[1];
        CGLIB$equals$3$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$3");
        CGLIB$toString$4$Method = var10000[2];
        CGLIB$toString$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$4");
        CGLIB$hashCode$5$Method = var10000[3];
        CGLIB$hashCode$5$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$5");
        CGLIB$clone$6$Method = var10000[4];
        CGLIB$clone$6$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$6");
        var10000 = ReflectUtils.findMethods(new String[]{"doSomething", "()V", "doOtherthing", "()V"}, (var1 = Class.forName("PersonC")).getDeclaredMethods());
        CGLIB$doSomething$0$Method = var10000[0];
        CGLIB$doSomething$0$Proxy = MethodProxy.create(var1, var0, "()V", "doSomething", "CGLIB$doSomething$0");
        CGLIB$doOtherthing$1$Method = var10000[1];
        CGLIB$doOtherthing$1$Proxy = MethodProxy.create(var1, var0, "()V", "doOtherthing", "CGLIB$doOtherthing$1");
    }

    final void CGLIB$doSomething$0() {
        super.doSomething();
    }

    public final void doSomething() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$doSomething$0$Method, CGLIB$emptyArgs, CGLIB$doSomething$0$Proxy);
        } else {
            super.doSomething();
        }
    }

    final void CGLIB$doOtherthing$1() {
        super.doOtherthing();
    }

    public final void doOtherthing() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$doOtherthing$1$Method, CGLIB$emptyArgs, CGLIB$doOtherthing$1$Proxy);
        } else {
            super.doOtherthing();
        }
    }

    final void CGLIB$finalize$2() throws Throwable {
        super.finalize();
    }

    protected final void finalize() throws Throwable {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$finalize$2$Method, CGLIB$emptyArgs, CGLIB$finalize$2$Proxy);
        } else {
            super.finalize();
        }
    }

    final boolean CGLIB$equals$3(Object var1) {
        return super.equals(var1);
    }

    public final boolean equals(Object var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var2 = var10000.intercept(this, CGLIB$equals$3$Method, new Object[]{var1}, CGLIB$equals$3$Proxy);
            return var2 == null ? false : ((Boolean)var2).booleanValue();
        } else {
            return super.equals(var1);
        }
    }

    final String CGLIB$toString$4() {
        return super.toString();
    }

    public final String toString() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$4$Method, CGLIB$emptyArgs, CGLIB$toString$4$Proxy) : super.toString();
    }

    final int CGLIB$hashCode$5() {
        return super.hashCode();
    }

    public final int hashCode() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var1 = var10000.intercept(this, CGLIB$hashCode$5$Method, CGLIB$emptyArgs, CGLIB$hashCode$5$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }

    final Object CGLIB$clone$6() throws CloneNotSupportedException {
        return super.clone();
    }

    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? var10000.intercept(this, CGLIB$clone$6$Method, CGLIB$emptyArgs, CGLIB$clone$6$Proxy) : super.clone();
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -1574182249:
            if (var10000.equals("finalize()V")) {
                return CGLIB$finalize$2$Proxy;
            }
            break;
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$6$Proxy;
            }
            break;
        case 1294226444:
            if (var10000.equals("doOtherthing()V")) {
                return CGLIB$doOtherthing$1$Proxy;
            }
            break;
        case 1826985398:
            if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                return CGLIB$equals$3$Proxy;
            }
            break;
        case 1913648695:
            if (var10000.equals("toString()Ljava/lang/String;")) {
                return CGLIB$toString$4$Proxy;
            }
            break;
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return CGLIB$hashCode$5$Proxy;
            }
            break;
        case 2121560294:
            if (var10000.equals("doSomething()V")) {
                return CGLIB$doSomething$0$Proxy;
            }
        }

        return null;
    }

    public PersonC$$EnhancerByCGLIB$$2b07307e() {
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        PersonC$$EnhancerByCGLIB$$2b07307e var1 = (PersonC$$EnhancerByCGLIB$$2b07307e)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (CGLIB$STATIC_CALLBACKS == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        PersonC$$EnhancerByCGLIB$$2b07307e var10000 = new PersonC$$EnhancerByCGLIB$$2b07307e();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
        PersonC$$EnhancerByCGLIB$$2b07307e var10000 = new PersonC$$EnhancerByCGLIB$$2b07307e();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        PersonC$$EnhancerByCGLIB$$2b07307e var10000 = new PersonC$$EnhancerByCGLIB$$2b07307e;
        switch(var1.length) {
        case 0:
            var10000.<init>();
            CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
            return var10000;
        default:
            throw new IllegalArgumentException("Constructor not found");
        }
    }

    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        MethodInterceptor var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        default:
            var10000 = null;
        }

        return var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
        default:
        }
    }

    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
    }

    static {
        CGLIB$STATICHOOK1();
    }
}

根据代理类的源码，可以总结几点心得：

1.生成的代理类PersonC$$EnhancerByCGLIB$$2b07307e继承了PersonC（目标类），注意的是如果是被final的修饰的类或者方法是不能被代理的。

2.代理类会生成2个方法，一个是重写的doSomething方法，另一个是CGLIB$doSomething$0方法，在这个方法里其实也是直接调用了父类的方法。

3.当我们调用代理类的方法target.doSomething()时，首先会判断下是否实现了MethodInterceptor接口，如果实现的话就调用拦截器内的增强方法。

二、代理对象的调用过程分析：

public final void doSomething() {

            MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
            if (this.CGLIB$CALLBACK_0 == null) {
                CGLIB$BIND_CALLBACKS(this);
                var10000 = this.CGLIB$CALLBACK_0;
            }
            //如果有实现MethodInterceptor，就调用MethodInterceptor中的拦截器方法
            if (var10000 != null) {
                //参数列表：
                //this: 当前代理对象
                //CGLIB$doSomething$0$Method  需要执行的方法
                //CGLIB$emptyArgs : 执行方法的参数
                //CGLIB$doSomething$0$Proxy 代理方法的MethodProxy对象
                var10000.intercept(this, CGLIB$doSomething$0$Method, CGLIB$emptyArgs, CGLIB$doSomething$0$Proxy);
            } else {
                super.doSomething();
            }
        }

1. intercept方法内执行的就是我们自定义的拦截器方法，具体执行过程如下：内部调用的是invokeSuper方法

retValFromSuper = proxy.invokeSuper(obj, args);

2.具体的MethodProxy方法详情如下：但是看到这里，莫名的有点懵逼了，JDK动态代理内部最终的调用是使用的反射的方式来的，这个地方是怎么调用的？fastClass是什么东西？大致看样子是调用的fastClass内的某一个方法。

   public Object invokeSuper(Object obj, Object[] args) throws Throwable {
        try {
            this.init();
            MethodProxy.FastClassInfo fci = this.fastClassInfo;
            return fci.f2.invoke(fci.i2, obj, args);
        } catch (InvocationTargetException var4) {
            throw var4.getTargetException();
        }
    }

3.稍微看下fastClass是什么玩意，通过debug了一下，我感觉它做的一件事就是映射（可能说的不是很准确）。

3.1 先来看看它的初始化操作：

    private void init() {
        if (this.fastClassInfo == null) {
            Object var1 = this.initLock;
            synchronized(this.initLock) {
                if (this.fastClassInfo == null) {
                    //CreateInfo对象内存储了目标类和代理类两个Class对象
                    MethodProxy.CreateInfo ci = this.createInfo;
                    //代构建fci实例
                    MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo();
                    //获取目标类Class
                    fci.f1 = helper(ci, ci.c1);
                    //获取代理类Class
                    fci.f2 = helper(ci, ci.c2);
                    //根据方法(doSomething)的签名sig1获取方法在目标类中的地址
                    fci.i1 = fci.f1.getIndex(this.sig1);
                    //根据方法(doSomething)的签名sig2获取方法在代理类中的地址
                    fci.i2 = fci.f2.getIndex(this.sig2);
                    this.fastClassInfo = fci; //构建fastClass
                    this.createInfo = null;
                }
            }
        }
    }


3.2初始化完成之后的调用：

    public Object invokeSuper(Object obj, Object[] args) throws Throwable {
        try {
            this.init();
            MethodProxy.FastClassInfo fci = this.fastClassInfo;
            //获取到代理对象f2，执行对应方法（CGLIB$doSomething$0()V），最终其实是直接调用了父类方法。
            return fci.f2.invoke(fci.i2, obj, args);
        } catch (InvocationTargetException var4) {
            throw var4.getTargetException();
        }
    }
通过跟踪源码，我们发现Cglib在执行具体方法时， 调用目标类的方法时不是使用的反射，而是直接调用，怪不得别人说Cglib的效率要比JDK动态代理要高呢。


最后的比较：


刘二郎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CGLIB动态代理
Unwisdom的博客
03-23 257
与JDK动态代理相比，使用CGLIB动态代理不需要使用代理的类提供接口 大部分说明在提供的代码里边方便观察 而CGBLIB是第三方的包 使用时需要导入相关的jar包如下 asm-2.2.3, asm-commons-2.2.3, asm-util-2.2.3, cglib-nodep-2.1_3 我刚开始导入的是cglib-3.2.9的jar包 会出现Enhancer创建失败 点到上面的类...
jdk 代理 和 cglib 代理深度分析
只为曾经的执着
04-03 247
参考 http://lrd.ele.me/2017/01/09/dynamic_proxy/jdk 代理 rem target 实例化的对象 --&gt; Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); --&gt; Class&lt;?&...
Java两种动态代理JDK动态代理和CGLIB动态代理
热门推荐
Java相关领域
08-07 14万+
目录 代理模式 JDK动态代理 cglib动态代理 测试 代理模式 代理模式是23种设计模式的一种，他是指一个对象A通过持有另一个对象B，可以具有B同样的行为的模式。为了对外开放协议，B往往实现了一个接口，A也会去实现接口。但是B是“真正”实现类，A则比较“虚”，他借用了B的方法去实现接口的方法。A虽然是“伪军”，但它可以增强B，在调用B的方法前后都做些其他的事情。Spring AOP...
cglib动态代理
weixin_44121703的博客
09-19 541
cgLib动态代理 导包（练习可以不用创建maven，取maven仓库中下载jar放入项目中就行） maven官方仓库：maven <!-- asm包 --> <dependency> <groupId>org.ow2.asm</groupId> <artifactId>asm</artifactId> <version>9.0-beta</version> </dependency
你必须会的 JDK 动态代理和 CGLIB 动态代理
12-21
CGLIB代理适用于不依赖接口的目标类。 总结来说，静态代理简单直观，但灵活性差；JDK动态代理基于接口，适用于接口众多的情况，但不支持非接口类；CGLIB则弥补了JDK动态代理的这一不足，适用于没有接口或接口较少的...
基于MAVEN项目的CGLib动态代理原理及实现
01-15
本文将深入探讨如何在基于Maven的项目中利用CGLib库实现动态代理。CGLib（Code Generation Library）是Java中一个高性能的代码生成库，它在运行期通过字节码技术为类创建子类，以此实现动态代理。 1. Maven项目配置...
cglib动态代理介绍
04-19
CGlib则是Java动态代理的一种实现方式，尤其是在不提供接口的情况下，它通过生成目标类的子类来实现动态代理。 在Java中，JDK自带的动态代理机制是基于接口的，如果被代理的类没有实现任何接口，那么就无法使用JDK...
CGLIB动态代理+CGLIB动态代理完整代码
最新发布
05-13
我们最终是通过一个代理对象去调用方法的，那我们就要获取一个代理对象，cglib代理，是通过Enhancer这个类里面对应的一个create()方法，去生成一个代理对象的。 Enhancer创建一个被代理对象的子类并且拦截所有的方法...
synchronize的原理分析
lwgzj的博客
03-20 1万+
synchronize是平时用的比较多的多线程问题的解决方案，一般说存在多线程问题，加个锁，就用synchronize吧，简单，方便。用lock你还要自己去lock，unlock，没经验的人使用起来没那么溜。今天，就来看看synchronize背后的一些详细知识点，尽量做到广而深。这样的学习才有意思。对于synchronize的学习，我是准备先实践，再分析，再总结。情况1：同一个对象在两个线程中分...
分布式锁的3种实现方式
lwgzj的博客
04-04 8896
说起分布式的概念，首当其冲就是CAP理论，即满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance）。但是CAP理论告诉我们，任何系统只能满足其中两个，所以都要求去做取舍。那么人们常说的一般都是，需要牺牲一致性来保证系统的高可用性，只要保证系统的最终一致性，并且允许的时间差值能够被接受就行。对于这个，本人的体会就是订单系统，对于...
红黑树的删除全过程图化
lwgzj的博客
07-05 7889
本篇是在之前的学习删除时的补充篇幅。目标时从头图化出一个完整的红黑树的删除过程。理论参考随意构造了一个红黑树如下：图1-1：删除514：这种场景最简单，因为被删除节点没有子节点。删除11（满足Case1和Case4）：比较复杂，因为它是黑节点。删除383：更加复杂，因为它有孩子节点。而且删除383的时候的逻辑是走的完全相反的，和插入一样，分成A，B两个场景，但是A，B场景下的操作都是完全相反的，要...
红黑树的插入全过程图化
lwgzj的博客
07-03 4878
本篇是在之前的学习插入时的补充篇幅。目标时从头图化出一个完整的红黑树的构造过程。 理论参考 构建过程中随机生成一个数字作为红黑树的域。 Case场景分为两种，一种是CaseA1,2,3系列，一种是CaseB1,2,3系列，具体参见理论参考中的修正操作伪代码。 插入节点275。 没啥好说的，根节点了，黑色。 插入节点711。 插入节点260。 插入节点515（满足Case...
Java--独占锁/共享锁
lwgzj的博客
03-23 4413
独享锁和共享锁在你去读C.U.T包下的ReeReentrantLock和ReentrantReadWriteLock你就会发现，它俩一个是独享一个是共享锁。独享锁：该锁每一次只能被一个线程所持有。共享锁：该锁可被多个线程共有，典型的就是ReentrantReadWriteLock里的读锁，它的读锁是可以被共享的，但是它的写锁确每次只能被独占。对于独享和共享，基于的点在于AQS，AQS的学习在以前就...
long和double的线程安全问题
lwgzj的博客
01-17 3188
java规范规定了对基本数据类型的操作必须是原子性的，但是long和double除外。 但是对于volatile 修饰的long和double，读写必须为原子的。 但是规范没有规定怎么去实现，现今的虚拟机都是把32位作为原子性操作。但是对于64位确没有，因此64位虚拟机操作long和double时，会出现两次写操作，这就造成了错位可能，因此在64位上操作共享的long和
线程wait和notify深入学习和分析
lwgzj的博客
04-13 2168
我们都知道简单的生产者和消费者的实现就是通过Object内的wait和notify实现的。至于例子暂时不写了。一、前言常见面试题：为什么wait和notify方法是Object类中的方法，而不是在Thread里，毕竟通常我们都是在多线程的时候在使用wait和notify方法。解释：1.首先我们知道生产者和消费者模型里，我们使用的是一个Object lock = new Object()。然后在新起...
红黑树原理，算法，和构建过程的分析和学习
lwgzj的博客
07-05 2161
参考文章：红黑树原理：此篇逻辑清晰，但是红黑树的配图不行，没法根据图来进行实际的操作理解，本文的意图就是根据作者的思路进行图片的重新分析。《算法导论》中文版，中文版翻译的马马虎虎，但是有些概念翻译的有点烂，在学习过程中会产生一些疑惑，需要及时更新自己的认知。红黑树特性：（1）每个节点要么红要么黑。（2）根节点黑色。（3）每个叶子节点是黑色。【叶子节点指的是NIL或者NULL的叶子节点】。（4）如果...
锁的消除和粗化
lwgzj的博客
04-10 1937
锁的消除出现的时机：虚拟机即时编译期运行时。出现的原因：主要判断依据就是来源于逃逸分析的数据支持，如果判断在一段代码中，堆上的所有数据都不会逃逸出去从而被其他线程访问到，那就可以把它们当做栈上的数据对待，认为它们是线程私有，同步锁无须进行。出现的典型例子：本身对于String的连接操作JVM会转化成StringBudiler进行连接，既然转化成了sb，那么其实sb是一个局部变量，对于append操...
Java--偏向锁/轻量级锁/重量级锁
lwgzj的博客
04-10 1423
首先要解释清楚这几种锁的特征和区别，以及运行时候的变化，需要了解Java对象头的一些知识，在Java对象头的Mark Word内就记录着这些不同锁的状态位。另外偏向锁---轻量级锁---重量级锁本文都需要依托synchronize进行理解和分析。另外也要参照网络上很多的资料。1.对象头：关于对象头的具体记录，可以参考这边：对象头2.同步的原理：关于JVM规范对于同步的解释，可以参考这边：monit...
cglib动态代理intercept
04-18
CGLIB动态代理是CGLIB库的一个重要特性，它通过生成目标类的子类来实现代理。 在CGLIB动态代理中，我们可以使用`MethodInterceptor`接口来定义代理逻辑。`MethodInterceptor`接口有一个`intercept`方法，该方法在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值