云顶集团娱4118-4118ccm云顶集团
做最好的网站

进度和线程之由来,代理进程深入分析

日期:2019-10-04编辑作者:云顶集团

Vector、ArrayList在迭代的时候假设还要对其举行修改就能够抛出ConcurrentModificationException非常。下边我们就来谈谈以下那些那多少个出现的来头以及化解办法。

new無语 转发请注明原创下处,感激!

Spring Security学习目录

设计格局的3大类:

@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Import(AspectJAutoProxyRegistrar.class)public @interface EnableAspectJAutoProxy { // 使用CGLIB代理 boolean proxyTargetClass() default false; // 是否暴露代理对象 boolean exposeProxy() default false;}

操作系统中缘何会现出进度

谈起进程的案由,大家必要从操作系统的迈入历史提及。

或许在今天,大家力所不及想像在不少年在此以前Computer是什么样体统。大家今后能够用计算机来做过多作业:办公、娱乐、上网,不过在微型Computer刚面世的时候,是为着减轻数学总计的主题素材,因为好些个气势恢宏的计量通过人工去完毕是很耗费时间间和人力耗费的。在中期的时候,Computer只可以接受部分特定的一声令下,顾客输入二个发令,Computer就做多个操作。当客商在思虑可能输入数据时,Computer就在等候。分明那样效用和比非常低下,因为众多时候,Computer处于等候客商输入的气象。

那么能或无法把一多种需求操作的吩咐预先写下去,产生一个清单,然后贰次性交给电脑,电脑不断地去读取指令来打开相应的操作?就这么,批管理操作系统诞生了。客商可以将急需进行的多个程序写在磁带上,然后交由计算机去读取并逐个地施行这一个程序,并将出口结果写到另三个磁带上。

纵然批管理操作系统的落地十分的大地进步了任务管理的便捷性,不过还是存在二个异常的大的标题:

举例有多个义务A和B,职责A在实行到二分之一的经过中,需求读取大批量的数据输入,而此时CPU只可以静静地伺机任务A读取完数据工夫继续实行,那样就白白浪费了CPU能源。大家于是想,能不能够在任务A读取数据的进程中,让职务B去实践,当任务A读取完数据未来,让职责B暂停,然后让职责A继续奉行?

唯独那样就有八个标题,原来每便都是三个主次在Computer里面运转,也就说内部存款和储蓄器中始终唯有一个顺序的运营数据。而一旦想要职分A实践I/O操作的时候,让职务B去实施,必然内部存款和储蓄器中要装入多个程序,那么怎么着管理呢?多个程序采纳的多寡怎么样进展识别呢?何况当三个程序运维暂停后,前边什么回复到它前边实行的情景呢?

这一年大家就发明了经过,用经过来对号入座三个前后相继,每种进程对应一定的内部存款和储蓄器地址空间,并且不得不利用它自身的内部存款和储蓄器空间,种种进度间互不干扰。况且经过保存了前后相继每一个时刻的运涨势况,那样就为经过切换提供了恐怕。当进程暂停时,它会保留当前进程的动静(比方进程标记、进度的应用的能源等),在下三回重复切换回来时,便依据在此以前封存的图景进行回复,然后继续推行。

那便是出新,能够让操作系统从微观上看起来同贰个时间段有多个职责在实践。换句话说,进度让操作系统的产出成为了大概。

只顾,就算现身从宏观上看有多个职务在试行,然则实际,任多个现实的每一天,只有多个职责在挤占CPU财富(当然是对此单核CPU来讲的)。

不论是直接迭代仍然在Java5.0引进的for-each循环语法中,对容器类实行迭代的专门的学问方法都以采取Iterator。不过,假使有别的线程并发地修改容器,那么即正是行使迭代器也力不从心制止在迭代之内对容器加锁。在规划同步容器类的迭代器时并不曾设想到出现修改的难点,而且它们展现出的一颦一笑是“及时退步”(fail-fast)的。那意味,当它们发现容器在迭代历程中被改造时,就能抛出三个ConcurrentModificationException分外。

OAuth 2.0 Provider机制负担揭发OAuth 2.0受保险的财富。配置包蕴创立独立OAuth 2.0客户端能够访谈受保证能源。提供者通过管住和验证OAuth 2.0令牌用于访谈受保险的财富。在适用意况下,提供者必需提供贰个接口,让客商确认客户端有权力访问受保证的能源。

  • 创设型方式建造者形式,单例情势,工厂方法形式,抽象工厂情势,原型格局。
  • 结构性形式适配器方式,装饰格局,代理格局,外观情势,桥接格局,组合形式,享元方式。
  • 行为型格局战略情势,模板方法形式,观看者方式,迭代器格局,权利链形式,命令情势,备忘录情势,状态格局,访谈者方式,中介者形式,解释器方式。

在那一个表明中引入AspectJAutoProxyRegistrar,它是ImportBeanDefinitionRegistrar接口的达成。ImportBeanDefinitionRegistrar接口和ImportSelector接口是Spring中多个扩充接口,分别通过registerBeanDefinitions方法和selectImports方法向容器注入Bean。AspectJAutoProxyRegistrar的registerBeanDefinitions方法:

怎会出现线程

在产出了经过之后,操作系统的品质得到了大大的升高。固然进程的面世解决了操作系统的出现难点,可是大家照旧不知足,大家稳步对实时性有了供给。因为叁个历程在贰个时光段内只好做一件工作,假设贰个进度有七个子任务,只好各个地去实施这么些子任务。比方对于一个监督检查体系来说,它不光要把图像数据显示在镜头上,还要与服务端实行通讯获取图像数据,还要管理大家的并行操作。要是某二个时时该系列正在与服务器通讯获取图像数据,而顾客又在监督体系上点击了某些按键,那么该系统将要等待获取完图像数据之后才具管理客户的操作,假诺获得图像数据须求费用10s,那么客商就独有向来在等候。鲜明,对于如此的系统,大家是心余力绌知足的。

那么行不行将这几个子职责分别试行呢?即在系统获得图像数据的同时,若是客商点击了有些开关,则会一曝十寒获取图像数据,而先去响应客户的操作(因为客商的操作往往实施时间非常短),在拍卖完顾客操作之后,再持续猎取图像数据。人们就表达了线程,让二个线程去实践一个子职务,那样五个历程就回顾了几个线程,每一种线程担任多个独自的子任务,那样在客户点击开关的时候,就足以暂停获取图像数据的线程,让UI线程响应客户的操作,响应完以往再切换回来,让获得图像的线程获得CPU财富。进而让客商感觉系统是还要在做多件事情的,满意了顾客对实时性的须求。

换句话说,进程让操作系统的并发性成为恐怕,而线程让进度的当中现身成为只怕。

不过要留意,一个进程就算富含四个线程,不过这么些线程是联合享有进度占领的财富和地址空间的。进度是操作系统举办能源分配的为主单位,而线程是操作系统实行调解的中央单位。

这种“及时退步”的迭代器并非一种完备的管理体制,而只是“善意地”捕获并发错误,因而只好当做并发难题的预先警告提示器。它们接纳的完成模式是,将计数器的扭转与容器关联起来:假若在迭代时期计数器被改造,那么hasNext或next将抛出ConcurrentModificationException。可是,这种检讨是在未曾同步的情事下开展的,由此恐怕会看见失效的计数值,而迭代器大概并未察觉到已经发生了修改。那是一种设计上的度量,进而收缩并发修改操作的检查实验代码对程序品质带来的熏陶。

OAuth 2.0提供者角色其实是分别授权服务和能源服务,固然一时会在同多少个应用程序中,可是选取Spring Security OAuth,您可以选拔将它们拆分为八个应用程序,还是能有三个分享的能源服务授权服务。对令牌的央求由Spring MVC Controller端点管理,受保险财富的拜望由职业的Spring Security央浼过滤器管理。为了落实OAuth 2.0授权服务器,Spring Security过滤器链中须求以下端点:

建造者方式是一个成立复杂对象的创造型格局,其将营造复杂对象的进程和它的构件解耦,使得塑造进度和部件的代表分离开来。

public void registerBeanDefinitions( AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { // 注册AnnotationAwareAspectJAutoProxyCreator AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary; AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class); // proxyTargetClass:true强制使用CGLIB代理 if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) { AopConfigUtils.forceAutoProxyCreatorToUseClassProxying; } // 是否暴露代理对象 if (enableAspectJAutoProxy.getBoolean("exposeProxy")) { AopConfigUtils.forceAutoProxyCreatorToExposeProxy; }}

二十多线程并发

由于八个线程是一路占领所属进度的财富和地点空间的,那么就能够存在一个主题素材:

假使四个线程要同期做客某些能源,怎么管理?

那几个主题素材正是后序小说中要入眼陈说的同步难点。

那么只怕有心上人会问,未来游人如织时候都采纳四线程编制程序,那么是或不是八线程的性质一定就优化单线程呢?

不自然,要看现实的天职以及计算机的布署。比如说:

对此单核CPU,若是是CPU密集型职务,如解压文件,四线程的性质反而比不上单线程质量,因为解压文件须要一贯攻下CPU能源,假如使用二十四线程,线程切换导致的支付反而会让质量缩小。

不过对于诸如交互类型的职责,断定是急需使用二十四线程的。

而对此多核CPU,对于解压文件来说,二十四线程分明优于单线程,因为四个线程能够更上一层楼充裕利用各种核的能源。

虽说八线程能够提高程序质量,可是相对于单线程来讲,它的编制程序要复杂地多,要思虑线程安全主题素材。因而,在实际编制程序进度中,要依据实际意况具体采用。

ConcurrentModificationException相当出现的由来

先看下边这段代码:

public class Test { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<Integer>(); list.add; Iterator<Integer> iterator = list.iterator(); while (iterator.hasNext { Integer integer = iterator.next(); if (integer == 2) list.remove; } }}

试行结果:

Exception in thread "main" java.util.ConcurrentModificationExceptionat java.util.ArrayList$Itr.checkForComodification(Unknown Source)at java.util.ArrayList$Itr.next(Unknown Source)at Test.main(Test.java:9)

从十一分音讯方可窥见,非凡现身在checkForComodification()方法中。

我们不忙看checkForComodification()方法的切实可行落到实处,大家先依据程序的代码一步一步看ArrayList源码的落实:

先是看ArrayList的iterator()方法的现实性实现,查看源码开采在ArrayList的源码中并不曾iterator()这么些艺术,那么很明朗这一个艺术应该是其父类或许达成的接口中的方法,大家在其父类AbstractList中找到了iterator()方法的切实落到实处,下边是其促成代码:

public Iterator<E> iterator() { return new Itr();}

从这段代码能够看出重返的是一个针对性Itr类型对象的援用,大家随后看Itr的实际贯彻,在AbstractList类中找到了Itr类的现实贯彻,它是AbstractList的两个成员内部类,上边这段代码是Itr类的具备完毕:

private class Itr implements Iterator<E> { int cursor = 0; int lastRet = -1; int expectedModCount = modCount; public boolean hasNext() { return cursor != size(); } public E next() { checkForComodification(); try { E next = get; lastRet = cursor++; return next; } catch (IndexOutOfBoundsException e) { checkForComodification(); throw new NoSuchElementException(); } } public void remove() { if (lastRet == -1) throw new IllegalStateException(); checkForComodification(); try { AbstractList.this.remove; if (lastRet < cursor) cursor--; lastRet = -1; expectedModCount = modCount; } catch (IndexOutOfBoundsException e) { throw new ConcurrentModificationException(); } } final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); }}

第一大家看一下它的多少个分子变量:

1)cursor:表示下七个要访谈的要素的目录,从next()方法的切实实现就可看出;

2)lastRet:表示上贰个拜望的因素的目录;

3)expectedModCount:表示对ArrayList修改次数的指望值,它的开始值为modCount;

4)modCount是AbstractList类中的叁个成员变量。

protected transient int modCount = 0;

该值表示对List的修改次数,查看ArrayList的add()和remove()方法就足以窥见,每一次调用add()方法大概remove()方法就能够对modCount实行加1操作。

好了,到此处大家再看看下边包车型客车程序:

当调用list.iterator()再次回到三个Iterator之后,通过Iterator的hashNext()方法判断是或不是还应该有成分未被访问,我们看一下hasNext()方法,hashNext()方法的落到实处很简短:

public boolean hasNext() { return cursor != size();}

若是下一个访谈的因素下标不等于ArrayList的大小,就代表有成分需求拜会,那个很轻松掌握,如若下贰个做客成分的下标等于ArrayList的分寸,则肯定达到最后了。

接下来经过Iterator的next()方法获得到下标为0的因素,我们看一下next()方法的现实贯彻:

public E next() { checkForComodification(); try { E next = get; lastRet = cursor++; return next; } catch (IndexOutOfBoundsException e) { checkForComodification(); throw new NoSuchElementException(); }}

那边是老大重要的地点:首先在next()方法中会调用checkForComodification()方法,然后依照cursor的值获取到成分,接着将cursor的值赋给lastRet,并对cursor的值进行加1操作。开始时,cursor为0,lastRet为-1,那么调用三回以往,cursor的值为1,lastRet的值为0。注意:此时modCount为1,expectedModCount也为1(因为调用了三遍ArrayList的add方法)。

随着往下看,程序中推断当前成分的值是不是为2,若为2,则调用list.remove()方法来删除该因素。

我们看一下在ArrayList中的remove()方法做了怎么着:

public boolean remove { if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { fastRemove; return true; } } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove; return true; } } return false;} private void fastRemove(int index) { modCount++; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // Let gc do its work}

因此remove方法删除成分最后是调用的fastRemove()方法,在fastRemove()方法中,首先对modCount举行加1操作(因为对聚焦修改了一遍),然后接下去便是去除元素的操作,最终将size进行减1操作,并将引用置为null以利于垃圾搜聚器进行回收职业。

那么留意此时逐个变量的值:对于iterator,其expectedModCount为1,cursor的值为1,lastRet的值为0。

对于list,其modCount为2,size为0。

继而看程序代码,推行完删除操作后,继续while循环,调用hasNext()方法判别,由于此时cursor为1,而size为0,那么重回true,所以继续实施while循环,然后继续调用iterator的next()方法。

在乎,此时要留意next()方法中的第一句:checkForComodification()。

在checkForComodification方法中实行的操作是:

final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException();}

如果modCount不等于expectedModCount,则抛出ConcurrentModificationException异常。

很扎眼,此时modCount为2,而expectedModCount为1,由以前后相继就抛出了ConcurrentModificationException格外。

到这里,想必我们应该清楚为何上述代码会抛出ConcurrentModificationException十分了。关键点就在于:调用list.remove()方法导致modCount和expectedModCount的值不均等。

  • AuthorizationEndpoint用认为授权乞求提供劳务。私下认可网站:/oauth/authorize
  • TokenEndpoint用以服务拜候令牌的伏乞。私下认可网站:/oauth/token

比如大家要DIY一台台式机。大家找到DIY商家。那时大家得以要求那一个台式机的CPU,显卡或然别的部件是什么样品牌的,什么布置的,那一个部件能够依据大家精诚团结的供给来扭转。可是这几个部件组装成Computer的长河是同等的,我们没有必要清楚那么些部件是怎么组装成Computer的,大家只供给提供相关部件的品牌和配置就足以了。

1、进入AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary方法会开掘这一个主意将二个类AnnotationAwareAspectJAutoProxyCreator注册到了容器中。2、proxyTargetClass=true则强制行使CGLIB代理,不然会依据指标类是还是不是达成了接口,自动选取是JDK代理或许是CGLIB代理。3、有时候指标对象内部的自家调用不可能试行切面中加强exposeProxy=true会将代理对象暴漏到AopContext中,此时使用AopContext.currentProxy就可以。

在单线程意况下的化解办法

既是知道原因了,那么怎么样减轻吧?

实际上一点也不细略,留意的情侣大概发掘在Itr类中也交给了一个remove()方法:

public void remove() { if (lastRet == -1) throw new IllegalStateException(); checkForComodification(); try { AbstractList.this.remove; if (lastRet < cursor) cursor--; lastRet = -1; expectedModCount = modCount; } catch (IndexOutOfBoundsException e) { throw new ConcurrentModificationException(); }}

在这几个法子中,删除成分实际上调用的正是list.remove()方法,不过它多了二个操作:

expectedModCount = modCount;

故此,在迭代器中只要要删减成分的话,必要调用Itr类的remove方法。

将上述代码改为上边那样就不会报错了:

public class Test { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<Integer>(); list.add; Iterator<Integer> iterator = list.iterator(); while (iterator.hasNext { Integer integer = iterator.next(); if (integer == 2) iterator.remove(); } }}

以下过滤器是兑现OAuth 2.0能源服务器所不能缺少的:

对此这种景观,大家就足以采纳建造者形式,将部件与组装进程分别,使得创设进度和部件都足以Infiniti制扩充,两个之间的耦合度也降到最低。

AnnotationAwareAspectJAutoProxyCreator类的一连关系为:

在多线程情况下的消除办法

上边的化解办法在单线程景况下适用,可是在二十多线程下适用吗?看下边二个例证:

public class Test { static ArrayList<Integer> list = new ArrayList<Integer>(); public static void main(String[] args) { list.add; list.add; list.add; list.add; list.add; Thread thread1 = new Thread() { public void run() { Iterator<Integer> iterator = list.iterator(); while (iterator.hasNext { Integer integer = iterator.next(); System.out.println; try { Thread.sleep; } catch (InterruptedException e) { e.printStackTrace(); } } }; }; Thread thread2 = new Thread() { public void run() { Iterator<Integer> iterator = list.iterator(); while (iterator.hasNext { Integer integer = iterator.next(); if (integer == 2) iterator.remove(); } }; }; thread1.start(); thread2.start(); }}

运作结果:

1 Exception in thread "Thread-0" java.util.ConcurrentModificationExceptionat java.util.ArrayList$Itr.checkForComodification(Unknown Source)at java.util.ArrayList$Itr.next(Unknown Source)at Test$1.run(Test.java:15)

有一点都不小或许有心上人说ArrayList是非线程安全的器皿,换到Vector就没难点了,实际上换到Vector依旧会师世这种漏洞非常多。

原因在于,固然Vector的不二法门运用了synchronized举办了伙同,不过出于Vector是持续的AbstarctList,因而通过Iterator来访谈容器的话,事实上是无需获得锁就可以访谈。那么鲜明,由于应用iterator对容器实行拜会无需获得锁,在多线程中就能促成当一个线程删除了成分,由于modCount是AbstarctList的成员变量,因而恐怕会导致在别的线程中modCount和expectedModCount值不等。

就譬喻下边包车型大巴代码中,很理解iterator是线程私有的,

初始时,线程1和线程2中的modCount、expectedModCount都为0,

当线程2通过iterator.remove()删除成分时,会修改modCount值为1,何况会修改线程第22中学的expectedModCount的值为1,

而此刻线程第11中学的expectedModCount值为0,即便modCount不是volatile变量,不保险线程1自然看收获线程2改变后的modCount的值,不过也是有非常的大也许看获得线程2对modCount的修改,那样就有相当的大希望变成线程第11中学相比较expectedModCount和modCount不等,进而抛出十分。

于是常常有2种消除办法:

1)在动用iterator迭代的时候使用synchronized也许Lock实行联合;

2)使用并发容器CopyOnWriteArrayList庖代ArrayList和Vector。

  • OAuth2AuthenticationProcessingFilter用以加载给定的表明访谈令牌央浼的表明。

在建造者形式中貌似有上边二个剧中人物:

BeanPostProcessor|SmartInstantiationAwareB|AbstractAutoProxyCreator|AnnotationAwareAspectJAutoProxyCreator

掩饰迭代器

尽管加锁可避防卫迭代器抛出ConcurrentModificationException,但您不可能不要牢记在具有对分享容器进行迭代的地方都急需加锁。实际境况要更为眼花缭乱,因为在少数情况下,迭代器会掩饰起来。

看上边包车型大巴这段代码:

public class HiddenIterator { private final Set<Integer> set = new HashSet<Integer>(); public synchronized void add(Integer i) { set.add; } public synchronized void remove(Integer i) { set.remove; } public void addTenThing() { Random r = new Random(); for (int i=0; i<10; i++) add(r.nextInt; System.out.println("DEBUG: added ten elements to " + set); }}

进度和线程之由来,代理进程深入分析。在HiddenIterator中绝非显式的迭代操作,但在System.out.println("DEBUG: added ten elements to " + set);那句代码中校实施迭代操作。编写翻译器将字符串的连日操作转变为调用StringBuilder.append,而以此点子又会调用容器的toString方法,规范容器的toString方法将迭代容器,并在要素上调用toString来生成容器内容的格式化表示。

在布局授权服务器时,必需思索客户端用来从顾客得到访谈令牌(举例,授权码,顾客凭据,刷新令牌)的赋予类型。服务器的布置用于提供顾客端详细音信服务和令牌服务的完结。该@EnableAuthorizationServer申明用于配置的OAuth 2.0授权服务器机制,与另外一同@Beans实现AuthorizationServerConfigurer。以下职能委托给由Spring创制并分配到的配置器AuthorizationServerConfigurer

  • Product:产品类。
  • Builder:抽象Buidler类,规范产品的组装,日常由子类完成。
  • ConcreteBuilder:具体建造者,达成抽象Builder类定义的具有办法,并赶回三个建立好的目的。
  • Director:出品人类,担当已有模块的排序,然后文告Builder开头建造。

AnnotationAwareAspectJAutoProxyCreator是BeanPostProcessor接口的兑现。BeanPostProcessor那些接口Spring中二个奇异且首要的接口,会在容器实例化Bean的时候调用,调用不仅一回,比方会在实例化前,实例化后,属性填充后等等适合的机会调用BeanPostProcessor的兑现。具体参见spring容器加载剖析一容器构造。

  • ClientDetailsServiceConfigurer:定义客商端详细音讯服务的配置器。客商详细新闻可以开始化,只怕您能够引用现成的store。
  • AuthorizationServerSecurityConfigurer:定义令牌端点上的哈密约束。
  • AuthorizationServerEndpointsConfigurer:定义授权和令牌端点以及令牌服务。
  1. 始建产品类要创设一台Computer,计算机被架空为Computer类,,他有2个部件:CPU、主板,并在其间提供了八个办法用来安装CPU和主板。

大概梳理下Bean的实例化进度:

提供程序配置的四个第一方面是将授权代码提供给OAuth客商端的不二等秘书籍。OAuth客户端通过将最终顾客导向授权页面来博取授权码,在那之中客户能够输入其证据,再从授权服务器重定向到独具授权码的OAuth顾客端。

在AbstractAutowireCapableBeanFactory类中有具体的Bean实例化方法doCreateBean:protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) 1: 实例化Bean instanceWrapper = createBeanInstance(beanName, mbd, args); 2: 是否需要提早曝光:单例&允许循环依赖&当前bean增在创建中,检查循环依赖 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation); 3: 对bean的各种属性进行填充,有可能依赖其他bean,递归初始化 step4.2.3 4: 调用初始化方法init-method、此处也有机会返回Bean的代理对象 exposedObject = initializeBean(beanName, exposedObject, mbd); 5: 解决循环依赖 return exposedObject;}进入initializeBean方法:protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) { 1:如果Bean有InitMethod开始调用 invokeInitMethods(beanName, wrappedBean, mbd); 2: 调用BeanPostProcessors的postProcessBeforeInitialization方法 if (mbd == null || !mbd.isSynthetic { wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } 3: 调用BeanPostProcessors的postProcessAfterInitialization方法 if (mbd == null || !mbd.isSynthetic { wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } // 如果启用了AOP此处应该返回了代理对象,也就是说原来初始化的bean被替换了。 return wrappedBean;}

本文由云顶集团娱4118发布于云顶集团,转载请注明出处:进度和线程之由来,代理进程深入分析

关键词:

死锁与活跃度,阻塞队列之LinkedBlockingQueue

前方谈了不计其数产出的表征和工具,不过相当多都是和锁有关的。大家应用锁来确定保障线程安全,可是那也会孳...

详细>>

CAS原理深度解析,原子变量类

DelayQueue是一种无界的隔断队列,队列里只同意放入能够"延期"的成分,队列中列头的因素是最早"到期"的要素。尽管队...

详细>>