1.Java并发源码concurrent包
2.CVS使用好处
3.ç®å说说ConcurrentSkipListMap
4.concurrenthashmap1.8源码如何详细解析?源码
5.Kafka源码分析(五) - Server端 - 基于时间轮的延时组件
6.死磕 java集合之ConcurrentLinkedQueue源码分析
Java并发源码concurrent包
深入JAVA杨京京:Java并发源码concurrent包
在JDK1.5之前,Java并发设计复杂且对程序员负担重,源码需考虑性能、源码死锁、源码公平性等。源码JDK1.5后,源码网校源码网易引入了java.util.concurrent工具包简化并发,源码提供多种并发模型,源码减轻开发负担。源码
Java并发工具包java.util.concurrent源自JSR-,源码包含用于并发程序的源码通用功能。该包由Doug Lea开发,源码旨在提供线程安全的源码容器、同步类、源码原子对象等工具,源码减少并发编程的复杂性。
并发容器如阻塞队列、非阻塞队列和转移队列等,实现线程安全功能,不使用同步关键字,为并发操作提供便利。
同步类如Lock等,提供线程之间的同步机制,确保数据一致性。原子对象类如AtomicInteger、AtomicLong等,电话通讯源码提供高效的原子操作,避免同步锁,实现线程安全。
原子操作类在多线程环境中实现数据同步和互斥,确保数据一致性。实际应用场景包括线程安全的数据结构和算法实现。
java.util.concurrent.atomic包中的原子操作类,使用硬件支持的原子操作实现数据的原子性,提高并发程序的效率和性能。
值得一提的是,Java并发工具包还包含了Fork-Join框架,通过分解和合并任务,实现高效并行处理,减少等待其他线程完成时间,并利用工作偷取技术优化线程执行效率。
Java线程池如ThreadLocalRandom类,提供高性能随机数生成,通过种子内部生成和不共享随机对象减少资源争用和消耗,提高并发程序的性能。
CVS使用好处
cvs,全称为Concurrent Versions System,是一种功能强大的版本控制系统。它提供了一系列工具,帮助开发者追踪、管理和回滚代码变更。运动网页源码在软件开发过程中,错误和bug的引入往往在不经意间,而cvs能够帮助开发者轻松恢复到先前的稳定版本,通过比较差异来定位问题的根源。 在使用cvs时,每个文件的全部版本都被保存在一个文件中,仅记录不同版本间的差异,这种高效的方式节省了存储空间,同时也使得版本对比变得简单直观。 cvs的历程始于年,由Dick Grune以shell脚本的形式发布,随后Brian Berliner负责设计和编码,Jeff Polk则贡献了模块设计和销售商分支支持,共同推动了cvs的发展。 cvs的主要功能在于存储和恢复文件版本,但不负责指导代码构造或决定如何管理磁盘空间。开发者需要额外的脚本、Makefile等工具来支持特定的构建系统,尤其是在模块化开发和共享文件的场景中,合理的磁盘规划尤为重要。 当外部变化影响文件系统时,开发者需要考虑哪些文件需要重新构建。传统方法通常依赖于make工具,并借助自动化工具生成所需的make文件。因此,茄子app源码合理的工具支持和构建流程设计对于利用cvs进行高效版本管理至关重要。扩展资料
CVS是一个C/S系统,多个开发人员通过一个中心版本控制系统来记录文件版本,从而达到保证文件同步的目的。CVS版本控制系统是一种GNU软件包,主要用于在多人开发环境下的源码的维护。ç®å说说ConcurrentSkipListMap
åºæ¬ä»ç»
è·³è·è¡¨çæ§è´¨å¦ä¸ï¼
æåºå±çæ°æ®èç¹æç §å ³é®åkeyååºæåï¼
å å«å¤çº§ç´¢å¼ï¼æ¯ä¸ªçº§å«çç´¢å¼èç¹æç §å ¶å ³èçæ°æ®èç¹çå ³é®åkeyååºæåï¼
é«çº§å«ç´¢å¼æ¯å ¶ä½çº§å«ç´¢å¼çåéï¼
å¦æå ³é®åkeyå¨çº§å«level=içç´¢å¼ä¸åºç°ï¼å级å«level<=içææç´¢å¼é½å å«è¯¥keyã
è·³è·è¡¨ConcurrentSkipListMapçæ°æ®ç»æå¦ä¸å¾æ示ï¼ä¸å¾ä¸å ±æä¸å±ç´¢å¼ï¼æåºä¸ä¸ºæ°æ®èç¹ï¼åä¸å±ç´¢å¼ä¸ï¼ç´¢å¼èç¹ä¹é´ä½¿ç¨rightæéç¸è¿ï¼ä¸å±ç´¢å¼èç¹çdownæéæåä¸å±çç´¢å¼èç¹ã
æºç åææ ¸å¿å段åæhead æå node(BASE_HEADER) ç顶å±ç´¢å¼ã
/***Thetopmostheadindexoftheskiplist.*/privatetransientvolatileHeadIndex<K,V>head;BASE_HEADER 头ç»ç¹ï¼å³æ顶å±ç´¢å¼ç头èç¹çvalueå¼
/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()Node éæå é¨ç±»ï¼å³æ°æ®èç¹
/***æ°æ®èç¹*/staticfinalclassNode<K,V>{ finalKkey;//æ°æ®èç¹çkeyvolatileObjectvalue;//æ°æ®èç¹çvaluevolatileNode<K,V>next;//æåä¸ä¸ä¸ªæ°æ®èç¹/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}Index éæå é¨ç±»ï¼å³æ®éç´¢å¼èç¹
/***æ®éç´¢å¼èç¹*/staticclassIndex<K,V>{ finalNode<K,V>node;//ç´¢å¼èç¹æåçæ°æ®èç¹finalIndex<K,V>down;//å½åç´¢å¼èç¹çæ£ä¸æ¹ç´¢å¼èç¹volatileIndex<K,V>right;//å½åç´¢å¼èç¹çå³ç´¢å¼èç¹/***Createsindexnodewithgivenvalues.*/Index(Node<K,V>node,Index<K,V>down,Index<K,V>right){ this.node=node;this.down=down;this.right=right;}}HeadIndex éæå é¨ç±»ï¼å³å½å级å«ç´¢å¼ç头èç¹
/***å½å级å«ç´¢å¼ç头èç¹*/staticfinalclassHeadIndex<K,V>extendsIndex<K,V>{ finalintlevel;//æå¤ç´¢å¼çº§å«/***nodeï¼å½åç´¢å¼æåçæ°æ®èç¹*downï¼å½åç´¢å¼èç¹çæ£ä¸æ¹ç´¢å¼èç¹*rightï¼å½åç´¢å¼èç¹çå³ç´¢å¼èç¹*levelï¼å½åç´¢å¼å¤´èç¹æå¤çç´¢å¼çº§å«*/HeadIndex(Node<K,V>node,Index<K,V>down,Index<K,V>right,intlevel){ super(node,down,right);this.level=level;}}æ¥è¯¢æ ¹æ®æå®çkeyæ¥è¯¢èç¹ï¼æºç å¦ä¸ï¼
publicVget(Objectkey){ //è°ç¨doGetæ¹æ³returndoGet(key);}/***çæ£å®ç°æ¥è¯¢æ¹æ³*/privateVdoGet(Objectkey){ if(key==null)thrownewNullPointerException();Comparator<?superK>cmp=comparator;outer:for(;;){ for(Node<K,V>b=findPredecessor(key,cmp),n=b.next;;){ Objectv;intc;if(n==null)breakouter;Node<K,V>f=n.next;if(n!=b.next)//inconsistentreadbreak;if((v=n.value)==null){ //nisdeletedn.helpDelete(b,f);break;}if(b.value==null||v==n)//bisdeletedbreak;if((c=cpr(cmp,key,n.key))==0){ @SuppressWarnings("unchecked")Vvv=(V)v;returnvv;}if(c<0)breakouter;b=n;n=f;}}returnnull;}å¨ä¸è¿°ä»£ç ä¸ï¼outerå¤çforèªæä¸ï¼é¦å æ¥çfindPredecessorï¼æ¥è¯¢æå®keyèç¹çå驱èç¹ã该æ¹æ³å¨ä¸é¢ç好å¤å°æ¹ä¼è°ç¨ï¼ä¾å¦æå ¥å ç´ ï¼å é¤å ç´ ä»¥åå é¤å ç´ å¯¹åºçç´¢å¼æ¶é½ä¼è°ç¨ã
findPredecessoræ¹æ³æºç å¦ä¸ï¼
/***ä½ç¨1ï¼æ¾å°key对åºèç¹çå驱èç¹ï¼ä¸ä¸å®çççå驱èç¹ï¼ä¹å¯è½æ¯å驱ç»ç¹çå驱èç¹*ä½ç¨2ï¼å é¤æ æçç´¢å¼ï¼å³è¦å é¤èç¹æ¶ï¼å°èç¹çç´¢å¼ä¹å é¤æ*/privateNode<K,V>findPredecessor(Objectkey,Comparator<?superK>cmp){ if(key==null)thrownewNullPointerException();//don'tpostponeerrorsfor(;;){ //r为qèç¹çå³æéæåçèç¹ï¼r为å½åæ¯è¾èç¹,æ¯æ¬¡é½æ¯è¾rèç¹çkeyè·æ¥æ¾çkeyç大å°å ³ç³»for(Index<K,V>q=head,r=q.right,d;;){ if(r!=null){ Node<K,V>n=r.node;Kk=n.key;//该èç¹å·²ç»å é¤ï¼éè¦å é¤å ¶å¯¹åºçç´¢å¼if(n.value==null){ //该èç¹å·²ç»å é¤ï¼éè¦å é¤å ¶å¯¹åºçç´¢å¼if(!q.unlink(r))break;//restartr=q.right;//rereadrcontinue;}//å½åæ¥æ¾çkeyæ¯rèç¹çkey大ï¼æ以rãqèç¹é½åå³ç§»å¨if(cpr(cmp,key,k)>0){ q=r;r=r.right;continue;}}//å½qçä¸æ¹ç´¢å¼èç¹ä¸ºç©ºï¼å说æå·²ç»å°æ°æ®èç¹å±äºï¼éè¦éåºè¿è¡åç»æ¥æ¾å¤çif((d=q.down)==null)returnq.node;/***æ¤æ¶å½åæ¥æ¾çkeyå°äºrèç¹çkeyï¼éè¦å¾ä¸ä¸çº§ç´¢å¼æ¥æ¾*dèç¹èµå¼ä¸ºä¸ºqèç¹ä¸ºæ£ä¸æ¹èç¹ï¼å³ä¸ä¸çº§ç´¢å¼çæ£ä¸æ¹èç¹*/q=d;r=d.right;}}}findPredecessoræ¹æ³çæ¥æ¾è¿ç¨å¾ç¤ºå¦ä¸ï¼å设è¦æ¥æ¾èç¹6
ç±äºå½årèç¹çkeyæ¯æ¥è¯¢çkeyå°ï¼æ以ï¼rãqèç¹é½åå³ç§»å¨ï¼å³æ§è¡å¦ä¸ä»£ç ï¼
//å½åæ¥æ¾çkeyæ¯rèç¹çkey大ï¼æ以rãqèç¹é½åå³ç§»å¨if(cpr(cmp,key,k)>0){ q=r;r=r.right;continue;}æ¤æ¶rèç¹æåçæ°æ®èç¹ä¸ºï¼èç¹çkeyæ¯6èç¹çkey大ï¼æ¤æ¶éè¦æ§è¡å¦ä¸ä»£ç ï¼
/***æ¤æ¶å½åæ¥æ¾çkeyå°äºrèç¹çkeyï¼éè¦å¾ä¸ä¸çº§ç´¢å¼æ¥æ¾*dèç¹èµå¼ä¸ºä¸ºqèç¹ä¸ºæ£ä¸æ¹èç¹ï¼å³ä¸ä¸çº§ç´¢å¼çæ£ä¸æ¹èç¹*/q=d;r=d.right;æ¤æ¶rèç¹æåçæ°æ®èç¹ä¸º5ï¼5èç¹çkeyæ¯6èç¹çkeyå°ï¼qãrèç¹åå³ç§»å¨ï¼å¦ä¸å¾æ示
æ¤æ¶rèç¹æåçæ°æ®èç¹ä¸ºï¼èç¹çkeyæ¯6èç¹çkey大ï¼åçéè¦å¾ä¸çº§ç´¢å¼èµ°ï¼å¦ä¸å¾æ示ï¼
æ¤æ¶rèç¹æåçæ°æ®èç¹ä¸ºï¼èç¹çkeyæ¯6èç¹çkey大ï¼åçéè¦å¾ä¸çº§ç´¢å¼èµ°ï¼ä½æ¯æ¤æ¶ä¸ä¸çº§ç´¢å¼ä¸ºç©ºäºï¼å³(d = q.down) == nulläºï¼æ¤æ¶æ§è¡ç代ç å¦ä¸ï¼ è¿åqç´¢å¼æåçèç¹ï¼å³è¿åèç¹5.
//å½qçä¸æ¹ç´¢å¼èç¹ä¸ºç©ºï¼å说æå·²ç»å°æ°æ®èç¹å±äºï¼éè¦éåºè¿è¡åç»æ¥æ¾å¤çif((d=q.down)==null)returnq.node;以ä¸å°±æ¯æ¹æ³findPredecessorçæ¥æ¾æµç¨ï¼å±ä»¬æ¥ç继ç»çä¸é¢çdoGetæ¹æ³
/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()0é¦å åå§åbãnãfä¸ä¸ªèç¹ï¼å¦ä¸å¾æ示
åç°æ¤æ¶nèç¹æåçèç¹å°±æ¯è¦æ¥è¯¢çèç¹ï¼äºæ¯æ§è¡å¦ä¸ä»£ç ï¼
/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()1ç´æ¥è¿ånèç¹çvalueå¼ãæ¥è¯¢æä½å®æã
æå ¥è·³è·è¡¨çæå ¥æä½å以ä¸åç§æ åµï¼
æ åµ1ï¼è·³è·è¡¨å åå¨keyä¸è´å ç´ ï¼åæ¿æ¢
æ åµ2ï¼æå ¥æ°å ç´ ï¼æ é¡»ç»æ°å ç´ çæç´¢å¼èç¹
æ åµ3ï¼æå ¥æ°å ç´ ï¼éè¦ç»æ°å ç´ çæç´¢å¼èç¹ï¼ä¸ç´¢å¼é«åº¦ < maxLevel
æ åµ4ï¼æå ¥æ°å ç´ ï¼éè¦ç»æ°å ç´ çæç´¢å¼èç¹ï¼ä¸ç´¢å¼é«åº¦ > maxLevel
æºç å¦ä¸ï¼
/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()2é¦å è¿æ¯è·æ¥è¯¢æä½ç±»ä¼¼ï¼è°ç¨findPredecessoræ¹æ³å æ¥æ¾å°å¾ æå ¥keyçå驱èç¹ï¼ä¸¾ä¸ªä¾åï¼ä¾å¦æ们æ³è¦æå ¥èç¹7ï¼å¦ä¸å¾æ示ï¼
æ¥çè·æ¥è¯¢æä½ä¸æ ·çæ¥éª¤å¦ä¸ï¼ç´æ¥çå¾ï¼
æ¤æ¶rèç¹æåæ°æ®èç¹1ï¼èç¹1çkeyå°äºå¾ æå ¥çèç¹7çkeyï¼äºæ¯èç¹qãråæ¶åå³ç§»å¨ã
æ¤æ¶rèç¹æåæ°æ®èç¹ï¼èç¹çkey大äºå¾ æå ¥èç¹7çkeyï¼äºæ¯å¾ä¸ä¸å±ç´¢å¼ç»§ç»æ¥æ¾ï¼æ§è¡ç代ç å¦ä¸ï¼
/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()3åé¢çæä½ç±»ä¼¼
æ¤æ¶rèç¹çkey大äºå¾ æå ¥çèç¹6çkeyï¼ä½æ¯qèç¹çdownæé已为空ï¼æ¤æ¶ç´æ¥è¿åqèç¹æåçèç¹5ã
æ¥çåå°doPutæ¹æ³ï¼å æ¥æ¥çouter循ç¯ï¼å¦ä¸ï¼
/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()4é¦å åå§åä¸ä¸ªèç¹bãnãfï¼nèç¹ä¸ºbèç¹çä¸ä¸ä¸ªèç¹ï¼èfèç¹ä¸ºnèç¹çä¸ä¸ä¸ªèç¹ï¼å¦ä¸å¾æ示
æ¥çæ¯è¾èç¹nä¸å¾ æå ¥çkeyç大å°ï¼æ¤æ¶nèç¹çkeyå°äºå¾ æå ¥èç¹çkeyï¼äºæ¯bãnãfä¸ä¸ªèç¹ååä¸ç§»å¨å¦ä¸å¾æ示
æ¤æ¶nèç¹çkey大äºå¾ æå ¥çkeyï¼æ¤æ¶æ§è¡å¦ä¸ä»£ç ï¼éè¿casæ¹å¼ä¿®æ¹bèç¹çä¸ä¸ä¸ªèç¹ä¸ºzèç¹ï¼æ¥çè·³åºouter循ç¯ã
/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()5ç¶åæ们ç¥édoPutå©ä¸ç代ç æ éå°±æ¯å¤ææ¯å¦ç»æ°æå ¥çèç¹zå建索å¼ï¼å¦æéè¦å建对åºçç´¢å¼ã
é¦å éè¿int rnd = ThreadLocalRandom.nextSecondarySeed();计ç®åºä¸ä¸ªéæºæ°ï¼æ¥çè¿è¡å¦ä¸å¤æï¼
/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()6å¦ærnd & 0x) == 0å°±ç»æ°æå ¥çzèç¹å建索å¼ï¼æ们ç¥é0x = å³æé«ä½åæåä¸ä½ä¸º1ï¼å ¶ä½å ¨é¨æ¯0ï¼
æ¡ä»¶ï¼(rnd & 0x) == 0ä»ä¹æ¶åæç«ï¼
rndè¿ä¸ªéæºæ°æä½ä½åæé«ä½åæ¶æ¯0çæ¶åï¼æ¡ä»¶æç«ï¼æ¦çæ¯1/4
举个ä¾åï¼ä¾å¦rnd = = 3æ¡ä»¶å°±æç«ã
å¦ææ¡ä»¶æç«çè¯ï¼æ¥ç计ç®å°åºç»zèç¹å建å 级索å¼ï¼ä»£ç å¦ä¸ï¼
/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()7éè¿whileæ¡ä»¶((rnd >>>= 1) & 1) != 0满足å 次就å建å 级索å¼ãä¾å¦ï¼
rnd = 计ç®åºæ¥çlevel => 3
rnd = 计ç®åºæ¥çlevel => 8
ç¶åæ¥çæ¯è¾è®¡ç®åºæ¥çzèç¹çç´¢å¼è·ç°æçè·³è·è¡¨çç´¢å¼çº§å«å¤§å°ã
æ åµä¸ï¼zèç¹è®¡ç®åºæ¥çç´¢å¼levelæ¯è·³è·è¡¨çlevelå°
æ åµäºï¼zèç¹è®¡ç®å¤ççç´¢å¼levelæ¯è·³è·è¡¨çlevel大ãæ¤æ¶ä¼éæ©æç»çlevel为åæ¥çè°è¡¨çlevel + 1
æ åµä¸
ç»zèç¹å建索å¼çæ¥éª¤å¦ä¸å¾æ示ï¼æ¤æ¶zèç¹çç´¢å¼è¿æ²¡æå å ¥è·³è·è¡¨ç°æçç´¢å¼éåä¸
æ¥ç继ç»æ§è¡splice循ç¯ï¼ä»£ç å¦ä¸ï¼
/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()8åå§åqãrèç¹å¦ä¸å¾æ示
æ¤æ¶rèç¹çkeyæ¯æ°æå ¥zèç¹ï¼å³7èç¹å°ï¼äºæ¯ä¸¤ä¸ªèç¹qãté½åå³ç§»å¨å¦ä¸å¾æ示
æ¤æ¶rèç¹çkeyæ¯æ°æå ¥zèç¹ï¼å³7èç¹å¤§ï¼æ§è¡å¦ä¸ä»£ç ï¼
/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()9æ¤æ¶rèç¹çkeyæ¯æ°æå ¥zèç¹ï¼å³7èç¹å°ï¼äºæ¯ä¸¤ä¸ªèç¹qãté½åå³ç§»å¨å¦ä¸å¾æ示
æ¤æ¶rèç¹çkeyæ¯æ°æå ¥zèç¹ï¼å³7èç¹å¤§,åçï¼ç´æ¥çå¾
æ åµäº
è·æ åµä¸ç±»ä¼¼ï¼è¿éå°±ä¸ä¸ä¸ç»å¾äº
å é¤å é¤æ¹æ³å®æçä»»å¡å¦ä¸ï¼
设置æå®å ç´ value为null
å°æå®nodeä»nodeé¾è¡¨ç§»é¤
å°æå®nodeçindexèç¹ ä» å¯¹åºç index é¾è¡¨ç§»é¤
/***æ°æ®èç¹*/staticfinalclassNode<K,V>{ finalKkey;//æ°æ®èç¹çkeyvolatileObjectvalue;//æ°æ®èç¹çvaluevolatileNode<K,V>next;//æåä¸ä¸ä¸ªæ°æ®èç¹/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}0åæ ·ï¼é¦å éè¿findPredecessoræ¹æ³æ¥æ¾å°è¦å é¤keyçå驱èç¹ï¼å°±ä¸ä¸ä¸ç»å¾äºï¼ç´æ¥çæ¾å°çå驱èç¹çå¾ï¼å¦ä¸ï¼
æ¥æ¯è¾nèç¹çkeyä¸å¾ å é¤çkeyç大å°ï¼æ¤æ¶nèç¹çkeyå°äºå¾ å é¤çkeyï¼å³7èç¹çkeyï¼äºæ¯å°bãnãfä¸ä¸ªèç¹é½åå³ç§»å¨ï¼å¦ä¸å¾ï¼
æ¤æ¶nèç¹çkeyè·å¾ å é¤çkeyä¸æ ·ï¼äºæ¯æ§è¡å¦ä¸ä»£ç ï¼
/***æ°æ®èç¹*/staticfinalclassNode<K,V>{ finalKkey;//æ°æ®èç¹çkeyvolatileObjectvalue;//æ°æ®èç¹çvaluevolatileNode<K,V>next;//æåä¸ä¸ä¸ªæ°æ®èç¹/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}1æååè°ç¨findPredecessoræ¸ æ¥æ æçç´¢å¼ï¼å³ä¸é¢å é¤çèç¹çç´¢å¼ã
/***æ°æ®èç¹*/staticfinalclassNode<K,V>{ finalKkey;//æ°æ®èç¹çkeyvolatileObjectvalue;//æ°æ®èç¹çvaluevolatileNode<K,V>next;//æåä¸ä¸ä¸ªæ°æ®èç¹/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}2éç¹é å¦ä¸ä»£ç åå é¤ç´¢å¼çï¼
/***æ°æ®èç¹*/staticfinalclassNode<K,V>{ finalKkey;//æ°æ®èç¹çkeyvolatileObjectvalue;//æ°æ®èç¹çvaluevolatileNode<K,V>next;//æåä¸ä¸ä¸ªæ°æ®èç¹/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}3æ们ç¥éå¨ä¸é¢å·²ç»å°å¾ å é¤ç7èç¹çvalue置为nulläºï¼ç´æ¥çå¾ï¼
æ¤æ¶rèç¹çkeyå°äºå¾ å é¤èç¹çkeyï¼äºæ¯rãqèç¹é½åå³ç§»å¨ã
æ¤æ¶r,nèç¹æåçæ°æ®èç¹çvalueå¼ä¸ºnulläºæ¯æ§è¡ä¸é¢çq.unlink(r)代ç ï¼å°qçå³æéæårçå³æéæåçèç¹ï¼å³å°±æ¯å é¤äºè¯¥levelä¸ç7èç¹çç´¢å¼èç¹ï¼å¦ä¸å¾æ示
æ¤æ¶rèç¹çkey大äºå¾ å é¤èç¹çkeyï¼äºæ¯å¾ä¸ä¸ç´¢å¼èµ°ï¼å¦ä¸å¾æ示
æ¤æ¶rèç¹çkeyå°äºå¾ å é¤èç¹çkeyï¼äºæ¯rãqèç¹é½åå³ç§»å¨ã
æ¤æ¶r,nèç¹æåçæ°æ®èç¹çvalueå¼ä¸ºnulläºæ¯æ§è¡ä¸é¢çq.unlink(r)代ç ï¼å°qçå³æéæårçå³æéæåçèç¹ï¼å³å°±æ¯å é¤äºè¯¥levelä¸ç7èç¹çç´¢å¼èç¹ï¼å¦ä¸å¾æ示
åç»æä½åçï¼æç»å°7èç¹çç´¢å¼ä¸ä¸å é¤å®ï¼æç»çå¾ä¸æ示
concurrenthashmap1.8源码如何详细解析?
ConcurrentHashMap在JDK1.8的线程安全机制基于CAS+synchronized实现,而非早期版本的分段锁。
在JDK1.7版本中,ConcurrentHashMap采用分段锁机制,包含一个Segment数组,每个Segment继承自ReentrantLock,并包含HashEntry数组,每个HashEntry相当于链表节点,用于存储key、value。默认支持个线程并发,每个Segment独立,互不影响。
对于put流程,与普通HashMap相似,首先定位至特定的Segment,然后使用ReentrantLock进行操作,后续过程与HashMap基本相同。
get流程简单,通常采用源码通过hash值定位至segment,再遍历链表找到对应元素。需要注意的是,value是volatile的,因此get操作无需加锁。
在JDK1.8版本中,线程安全的关键在于优化了put流程。首先计算hash值,遍历node数组。若位置为空,则通过CAS+自旋方式初始化。
若数组位置为空,尝试使用CAS自旋写入数据;若hash值为MOVED,表示需执行扩容操作;若满足上述条件均不成立,则使用synchronized块写入数据,同时判断链表或转换为红黑树进行插入。链表操作与HashMap相同,链表长度超过8时转换为红黑树。
get查询流程与HashMap基本一致,通过key计算位置,若table对应位置的key相同则返回结果;如为红黑树结构,则按照红黑树规则获取;否则遍历链表获取数据。
Kafka源码分析(五) - Server端 - 基于时间轮的延时组件
Kafka内部处理大量的延时操作,例如,在接收到PRODUCE请求后,副本可以等待一个timeout的时间再响应客户端。下面我们来探讨一个问题:为什么Kafka要自己实现一个延时任务组件,而不是直接使用Java的java.util.concurrent.DelayQueue呢?我们可以从以下两个方面来分析这个问题。
1.1 DelayQueue的能力
DelayQueue相关的接口/类如下所示:
相应地,DelayQueue提供的能力如下:
1.2 Kafka的业务场景
Kafka的业务背景具有以下特点:
相应地,Kafka对延时任务组件有以下两点要求:
这两点要求都无法通过直接应用DelayQueue的方式得到满足。
二. 组件接口
让我们来看看Kafka的延时任务组件对外提供的接口,从而了解其提供的能力和使用方式。
如下所示:
左边的两个类定义了"延时操作",右边的DelayedOperationPurgatory类定义了一个维护DelayOperaton的容器,其核心操作如下:
三. 实现
以下是关于"延时"实现方式的介绍。
3.1 业务模型
时间轮延时组件的思路如下:
接下来,通过一个具体的例子来说明这种映射逻辑:
首先关注上图中①号时间轮。圆环中的每一个单元格表示一个TimerTaskList。单元格有其关联的时间跨度;下方的"1s x "表示时间轮上共有个单元格,每个单元格的时间跨度为1秒。有一个指针指向了"当前时间"所对应的单元格。顺时针方向为时间流动方向。
当收到一个延迟时间在0-1s的TimerTask时,会将其追加到①号时间轮的橙色单元格中。当收到一个延迟时间在3-4s的TimerTask时,会将其追加到①号时间轮的**单元格中。以此类推。
现在有一个问题:①号时间轮能表示的最大延迟时间是秒,那如果收到了延迟秒的任务该怎么办?这时该用到②号时间轮了,我们称②号为①号的"溢出时间轮"。②号时间轮的特点如下:
如此,延迟时间在-s的TimerTask会被追加到②号的紫色单元格,延迟时间在-s的TimerTask会被追加到②号的绿色单元格中。③号时间轮同理。
刚刚是按①->②->③的顺序来分析时间轮的逻辑,反过来也可以得到有用的想象手里有一个"放大镜",其实③号时间轮的蓝色单元格"放大"后是②号时间轮;②号时间轮的蓝色单元格"放大"后是①号时间轮;蓝色单元格并不实际存储TimerTask。
3.2 数据结构
DelayedOperationPurgatory有一个Timer类型的timeoutTimer属性,用于维护延时任务。实际使用的是Timer的实现类:SystemTimer。该类用于维护延时任务的核心属性有两个:delayQueue和timingWheel。TimingWheel表示单个时间轮,接下来我们来看看其类图:
各属性含义如下:
3.3 算法
3.3.1 添加任务
添加任务的入口是DelayedOperationPurgatory.tryCompleteElseWatch,其核心逻辑分为如下两步:
SystemTimer.add直接调用了addTimerTaskEntry方法,后者逻辑如下:
TimingWheel.add的逻辑也很清晰,分如下4种场景处理:
3.3.2 尝试提前触发任务
入口是DelayedOperationPurgatory.checkAndComplete:
接下来看Watchers.tryCompleteWatched方法的内容:
DelayedOperation.maybeTryComplete方法最终调用了DelayedOperation.tryComplete;
DelayedOperation的子类需要在后者中实现自己的"触发条件"检查逻辑;若满足了提前触发的条件,则调用forceComplete方法执行事件触发场景下的业务逻辑。
3.3.3 任务到期自动执行
DelayedOperationPurgatory中维护了一个expirationReaper线程,其职责就是循环调用kafka.utils.timer.SystemTimer#advanceClock来从时间轮中获取已超时的任务,并更新时间轮的"当前时间"指针。
四. 总结
才疏学浅,未能窥其十之一二,随时欢迎各位交流补充。若文章质量还算及格,可以点赞收藏加以鼓励,后续我继续更新。
另外,也可以在目录中找到同系列的其他文章:
感谢阅读。
死磕 java集合之ConcurrentLinkedQueue源码分析
ConcurrentLinkedQueue
(1)不是阻塞队列
(2)通过CAS+自旋保证并发安全
(3)可用于多线程环境,但不能用在线程池中
简介
主要属性
两个属性:头节点与尾节点
主要内部类
典型单链表结构
主要构造方法
构造简单,实现无界单链表队列
入队
add(e)与offer(e)方法
无异常抛出,流程清晰
出队
remove()与poll()方法
逻辑清晰,不阻塞线程
总结
非阻塞队列,不适用于线程池
彩蛋
与LinkedBlockingQueue对比
线程安全与返回null特性相似
效率与锁机制差异显著
无法实现等待元素与用在线程池中的限制
OpenJDK-JVM 源码阅读 - ZGC - 并发标记 | 京东物流技术团队
ZGC简介:
ZGC是Java垃圾回收器的前沿技术,支持低延迟、大容量堆、染色指针、读屏障等特性,自JDK起作为试验特性,JDK起支持Windows,JDK正式投入生产使用。在JDK中已实现分代收集,预计不久将发布,性能将更优秀。
ZGC特征:
1. 低延迟
2. 大容量堆
3. 染色指针
4. 读屏障
并发标记过程:
ZGC并发标记主要分为三个阶段:初始标记、并发标记/重映射、重分配。本篇主要分析并发标记/重映射部分源代码。
入口与并发标记:
整个ZGC源码入口是ZDriver::gc函数,其中concurrent()是一个宏定义。并发标记函数是concurrent_mark。
并发标记流程:
从ZHeap::heap()进入mark函数,使用任务框架执行任务逻辑在ZMarkTask里,具体执行函数是work。工作逻辑循环从标记条带中取出数据,直到取完或时间到。此循环即为ZGC三色标记主循环。之后进入drain函数,从栈中取出指针进行标记,直到栈排空。标记过程包括从栈取数据,标记和递归标记。
标记与迭代:
标记过程涉及对象迭代遍历。标记流程中,ZGC通过map存储对象地址的finalizable和inc_live信息。map大小约为堆中对象对齐大小的二分之一。接着通过oop_iterate函数对对象中的指针进行迭代,使用ZMarkBarrierOopClosure作为读屏障,实现了指针自愈和防止漏标。
读屏障细节:
ZMarkBarrierOopClosure函数在标记非静态成员变量的指针时触发读屏障。慢路径处理和指针自愈是核心逻辑,慢路径标记指针,快速路径通过cas操作修复坏指针,并重新标记。
重映射过程:
读屏障触发标记后,对象被推入栈中,下次标记循环时取出。ZGC并发标记流程至此结束。
问题回顾:
本文解答了ZGC如何标记指针、三色标记过程、如何防止漏标、指针自愈和并发重映射过程的问题。
扩展思考:
ZGC在指针上标记,当回收某个region时,如何得知对象是否存活?答案需要结合标记阶段和重分配阶段的代码。
结束语:
本文深入分析了ZGC并发标记的源码细节,对您有启发或帮助的话,请多多点赞支持。作者:京东物流 刘家存,来源:京东云开发者社区 自猿其说 Tech。转载请注明来源。