[{"data":1,"prerenderedAt":30506},["ShallowReactive",2],{"java:spring-transaction-failure-scenarios\u002F":3,"java-wiki-navigation":1953},{"id":4,"title":5,"body":6,"commentId":1940,"description":1941,"difficulty":1942,"draft":1943,"extension":1944,"meta":1945,"navigation":206,"order":1946,"path":1947,"section":1948,"seo":1949,"stem":1950,"updated":1951,"__hash__":1952},"java\u002Fjava\u002Fspring-transaction-failure-scenarios.md","Spring 事务在什么情况下会失效？",{"type":7,"value":8,"toc":1910},"minimark",[9,13,17,30,52,55,58,67,70,84,87,91,94,104,110,113,123,126,130,133,174,184,251,254,310,313,317,320,404,419,437,443,449,452,619,630,634,637,642,667,670,674,701,707,711,739,742,746,756,761,765,771,835,838,842,845,859,862,920,927,986,989,1009,1020,1024,1027,1116,1119,1122,1161,1164,1194,1197,1201,1208,1280,1283,1289,1295,1298,1302,1305,1308,1396,1399,1445,1448,1451,1455,1458,1501,1504,1507,1523,1526,1530,1533,1550,1556,1559,1618,1621,1625,1631,1697,1700,1704,1708,1711,1725,1728,1732,1735,1741,1745,1748,1754,1757,1761,1764,1783,1787,1864,1868,1906],[10,11,5],"h1",{"id":12},"spring-事务在什么情况下会失效",[14,15,16],"h2",{"id":16},"面试回答",[18,19,20,21,25,26,29],"p",{},"Spring 声明式事务主要通过 AOP 代理实现：外部调用先进入代理对象，",[22,23,24],"code",{},"TransactionInterceptor"," 根据 ",[22,27,28],{},"@Transactional"," 配置开启事务，再调用目标方法，最后根据方法是否正常返回以及异常是否命中回滚规则决定提交或回滚。",[18,31,32,33,36,37,40,41,44,45,44,48,51],{},"因此，常见的事务失效场景可以分成两类。第一类是调用没有经过事务代理，例如对象不是 Spring Bean、同一个类中使用 ",[22,34,35],{},"this"," 调用、在 ",[22,38,39],{},"@PostConstruct"," 阶段调用事务方法，或者方法是代理无法增强的 ",[22,42,43],{},"private","、",[22,46,47],{},"final",[22,49,50],{},"static"," 方法。第二类是事务已经创建，但行为与预期不同，例如默认不对受检异常回滚、异常被业务代码捕获后没有继续抛出、方法切换到新线程执行、事务传播行为选择不当、多数据源使用了错误的事务管理器，或者底层数据库操作本身不支持事务。",[18,53,54],{},"排查时先确认当前对象是不是代理对象、调用是否从代理外部进入，再确认事务是否真正开启，最后检查异常类型、传播行为、线程边界、事务管理器和数据库能力。",[18,56,57],{},"一句话总结：",[59,60,61],"blockquote",{},[18,62,63],{},[64,65,66],"strong",{},"Spring 事务要生效，必须让调用经过正确的事务代理，并且异常、线程、传播行为、事务管理器和底层存储都处在同一个有效事务边界内。",[14,68,69],{"id":69},"一张图看懂",[18,71,72],{},[73,74,80],"a",{"href":75,"target":76,"rel":77},"\u002Fimages\u002Fwiki\u002Fjava\u002Fspring-transaction-failure-scenarios.svg","_blank",[78,79],"noopener","noreferrer",[81,82],"img",{"src":75,"alt":83},"Spring 事务失效的常见原因和排查顺序",[14,85,86],{"id":86},"详细讲解",[14,88,90],{"id":89},"一先理解-spring-事务为什么能够生效","一、先理解 Spring 事务为什么能够生效",[18,92,93],{},"在默认的代理模式下，Spring 会为符合条件的 Bean 创建事务代理。外部代码调用事务方法时，实际链路是：",[95,96,102],"pre",{"className":97,"code":99,"language":100,"meta":101},[98],"language-text","调用方\n ↓\nSpring 事务代理\n ↓\nTransactionInterceptor\n ├─ 读取 @Transactional 属性\n ├─ 选择 TransactionManager\n ├─ 开启或加入事务\n └─ 调用目标方法\n ↓\n 正常返回：提交\n 命中回滚规则的异常：回滚\n","text","",[22,103,99],{"__ignoreMap":101},[18,105,106,107,109],{},"所以，",[22,108,28],{}," 本身只是事务元数据。只有 Spring 的事务基础设施识别到它，并且方法调用经过代理，事务拦截器才有机会工作。",[18,111,112],{},"本文所说的“事务失效”包含两种不同现象：",[114,115,116,120],"ul",{},[117,118,119],"li",{},"事务根本没有创建，例如同类自调用绕过代理；",[117,121,122],{},"事务已经创建，但没有按照预期回滚或隔离，例如异常被吞掉、切换线程或使用了独立事务。",[18,124,125],{},"排查时必须先区分是哪一种。",[14,127,129],{"id":128},"二对象没有交给-spring-管理","二、对象没有交给 Spring 管理",[18,131,132],{},"下面的对象是手动创建的：",[95,134,138],{"className":135,"code":136,"language":137,"meta":101,"style":101},"language-java shiki shiki-themes github-light github-dark","OrderService orderService = new OrderService();\norderService.createOrder();\n","java",[22,139,140,163],{"__ignoreMap":101},[141,142,145,149,153,156,160],"span",{"class":143,"line":144},"line",1,[141,146,148],{"class":147},"sVt8B","OrderService orderService ",[141,150,152],{"class":151},"szBVR","=",[141,154,155],{"class":151}," new",[141,157,159],{"class":158},"sScJk"," OrderService",[141,161,162],{"class":147},"();\n",[141,164,166,169,172],{"class":143,"line":165},2,[141,167,168],{"class":147},"orderService.",[141,170,171],{"class":158},"createOrder",[141,173,162],{"class":147},[18,175,176,177,180,181,183],{},"即使 ",[22,178,179],{},"createOrder()"," 上有 ",[22,182,28],{},"，这个对象也不是 Spring 容器创建的 Bean，没有对应的事务代理，因此注解不会生效。",[95,185,187],{"className":135,"code":186,"language":137,"meta":101,"style":101},"public class OrderService {\n\n @Transactional\n public void createOrder() {\n \u002F\u002F 数据库操作\n }\n}\n",[22,188,189,202,208,217,232,239,245],{"__ignoreMap":101},[141,190,191,194,197,199],{"class":143,"line":144},[141,192,193],{"class":151},"public",[141,195,196],{"class":151}," class",[141,198,159],{"class":158},[141,200,201],{"class":147}," {\n",[141,203,204],{"class":143,"line":165},[141,205,207],{"emptyLinePlaceholder":206},true,"\n",[141,209,211,214],{"class":143,"line":210},3,[141,212,213],{"class":147}," @",[141,215,216],{"class":151},"Transactional\n",[141,218,220,223,226,229],{"class":143,"line":219},4,[141,221,222],{"class":151}," public",[141,224,225],{"class":151}," void",[141,227,228],{"class":158}," createOrder",[141,230,231],{"class":147},"() {\n",[141,233,235],{"class":143,"line":234},5,[141,236,238],{"class":237},"sJ8bj"," \u002F\u002F 数据库操作\n",[141,240,242],{"class":143,"line":241},6,[141,243,244],{"class":147}," }\n",[141,246,248],{"class":143,"line":247},7,[141,249,250],{"class":147},"}\n",[18,252,253],{},"应当让类成为 Spring Bean，并通过容器注入后调用：",[95,255,257],{"className":135,"code":256,"language":137,"meta":101,"style":101},"@Service\npublic class OrderService {\n\n @Transactional\n public void createOrder() {\n \u002F\u002F 数据库操作\n }\n}\n",[22,258,259,267,277,281,287,297,301,305],{"__ignoreMap":101},[141,260,261,264],{"class":143,"line":144},[141,262,263],{"class":147},"@",[141,265,266],{"class":151},"Service\n",[141,268,269,271,273,275],{"class":143,"line":165},[141,270,193],{"class":151},[141,272,196],{"class":151},[141,274,159],{"class":158},[141,276,201],{"class":147},[141,278,279],{"class":143,"line":210},[141,280,207],{"emptyLinePlaceholder":206},[141,282,283,285],{"class":143,"line":219},[141,284,213],{"class":147},[141,286,216],{"class":151},[141,288,289,291,293,295],{"class":143,"line":234},[141,290,222],{"class":151},[141,292,225],{"class":151},[141,294,228],{"class":158},[141,296,231],{"class":147},[141,298,299],{"class":143,"line":241},[141,300,238],{"class":237},[141,302,303],{"class":143,"line":247},[141,304,244],{"class":147},[141,306,308],{"class":143,"line":307},8,[141,309,250],{"class":147},[18,311,312],{},"同时还要确认应用已经启用事务基础设施。Spring Boot 通常会根据依赖和事务管理器自动配置；非 Boot 项目一般需要显式配置事务管理器并启用注解事务管理。",[14,314,316],{"id":315},"三同一个类中自调用","三、同一个类中自调用",[18,318,319],{},"这是最常见的失效场景之一：",[95,321,323],{"className":135,"code":322,"language":137,"meta":101,"style":101},"@Service\npublic class OrderService {\n\n public void create() {\n saveOrder();\n }\n\n @Transactional\n public void saveOrder() {\n \u002F\u002F 数据库操作\n }\n}\n",[22,324,325,331,341,345,356,363,367,371,377,389,394,399],{"__ignoreMap":101},[141,326,327,329],{"class":143,"line":144},[141,328,263],{"class":147},[141,330,266],{"class":151},[141,332,333,335,337,339],{"class":143,"line":165},[141,334,193],{"class":151},[141,336,196],{"class":151},[141,338,159],{"class":158},[141,340,201],{"class":147},[141,342,343],{"class":143,"line":210},[141,344,207],{"emptyLinePlaceholder":206},[141,346,347,349,351,354],{"class":143,"line":219},[141,348,222],{"class":151},[141,350,225],{"class":151},[141,352,353],{"class":158}," create",[141,355,231],{"class":147},[141,357,358,361],{"class":143,"line":234},[141,359,360],{"class":158}," saveOrder",[141,362,162],{"class":147},[141,364,365],{"class":143,"line":241},[141,366,244],{"class":147},[141,368,369],{"class":143,"line":247},[141,370,207],{"emptyLinePlaceholder":206},[141,372,373,375],{"class":143,"line":307},[141,374,213],{"class":147},[141,376,216],{"class":151},[141,378,380,382,384,387],{"class":143,"line":379},9,[141,381,222],{"class":151},[141,383,225],{"class":151},[141,385,386],{"class":158}," saveOrder",[141,388,231],{"class":147},[141,390,392],{"class":143,"line":391},10,[141,393,238],{"class":237},[141,395,397],{"class":143,"line":396},11,[141,398,244],{"class":147},[141,400,402],{"class":143,"line":401},12,[141,403,250],{"class":147},[18,405,406,407,410,411,414,415,418],{},"外部调用 ",[22,408,409],{},"create()"," 时，代理把调用转交给真实的 ",[22,412,413],{},"OrderService","。进入真实对象后，",[22,416,417],{},"saveOrder()"," 实际相当于：",[95,420,422],{"className":135,"code":421,"language":137,"meta":101,"style":101},"this.saveOrder();\n",[22,423,424],{"__ignoreMap":101},[141,425,426,429,432,435],{"class":143,"line":144},[141,427,35],{"class":428},"sj4cs",[141,430,431],{"class":147},".",[141,433,434],{"class":158},"saveOrder",[141,436,162],{"class":147},[18,438,439,440,442],{},"这次调用直接发生在目标对象内部，没有再次经过事务代理，所以 ",[22,441,417],{}," 上的事务拦截器不会执行。",[95,444,447],{"className":445,"code":446,"language":100,"meta":101},[98],"外部调用 → 代理 → 真实对象.create()\n ↓\n this.saveOrder()\n ↓\n 绕过事务代理\n",[22,448,446],{"__ignoreMap":101},[18,450,451],{},"优先采用的解决方式是拆分职责，让调用跨 Bean 进行：",[95,453,455],{"className":135,"code":454,"language":137,"meta":101,"style":101},"@Service\npublic class OrderService {\n\n private final OrderWriter orderWriter;\n\n public OrderService(OrderWriter orderWriter) {\n this.orderWriter = orderWriter;\n }\n\n public void create() {\n orderWriter.saveOrder();\n }\n}\n\n@Service\npublic class OrderWriter {\n\n @Transactional\n public void saveOrder() {\n \u002F\u002F 数据库操作\n }\n}\n",[22,456,457,463,473,477,488,492,508,521,525,529,539,548,552,557,562,569,581,586,593,604,609,614],{"__ignoreMap":101},[141,458,459,461],{"class":143,"line":144},[141,460,263],{"class":147},[141,462,266],{"class":151},[141,464,465,467,469,471],{"class":143,"line":165},[141,466,193],{"class":151},[141,468,196],{"class":151},[141,470,159],{"class":158},[141,472,201],{"class":147},[141,474,475],{"class":143,"line":210},[141,476,207],{"emptyLinePlaceholder":206},[141,478,479,482,485],{"class":143,"line":219},[141,480,481],{"class":151}," private",[141,483,484],{"class":151}," final",[141,486,487],{"class":147}," OrderWriter orderWriter;\n",[141,489,490],{"class":143,"line":234},[141,491,207],{"emptyLinePlaceholder":206},[141,493,494,496,498,501,505],{"class":143,"line":241},[141,495,222],{"class":151},[141,497,159],{"class":158},[141,499,500],{"class":147},"(OrderWriter ",[141,502,504],{"class":503},"s4XuR","orderWriter",[141,506,507],{"class":147},") {\n",[141,509,510,513,516,518],{"class":143,"line":247},[141,511,512],{"class":428}," this",[141,514,515],{"class":147},".orderWriter ",[141,517,152],{"class":151},[141,519,520],{"class":147}," orderWriter;\n",[141,522,523],{"class":143,"line":307},[141,524,244],{"class":147},[141,526,527],{"class":143,"line":379},[141,528,207],{"emptyLinePlaceholder":206},[141,530,531,533,535,537],{"class":143,"line":391},[141,532,222],{"class":151},[141,534,225],{"class":151},[141,536,353],{"class":158},[141,538,231],{"class":147},[141,540,541,544,546],{"class":143,"line":396},[141,542,543],{"class":147}," orderWriter.",[141,545,434],{"class":158},[141,547,162],{"class":147},[141,549,550],{"class":143,"line":401},[141,551,244],{"class":147},[141,553,555],{"class":143,"line":554},13,[141,556,250],{"class":147},[141,558,560],{"class":143,"line":559},14,[141,561,207],{"emptyLinePlaceholder":206},[141,563,565,567],{"class":143,"line":564},15,[141,566,263],{"class":147},[141,568,266],{"class":151},[141,570,572,574,576,579],{"class":143,"line":571},16,[141,573,193],{"class":151},[141,575,196],{"class":151},[141,577,578],{"class":158}," OrderWriter",[141,580,201],{"class":147},[141,582,584],{"class":143,"line":583},17,[141,585,207],{"emptyLinePlaceholder":206},[141,587,589,591],{"class":143,"line":588},18,[141,590,213],{"class":147},[141,592,216],{"class":151},[141,594,596,598,600,602],{"class":143,"line":595},19,[141,597,222],{"class":151},[141,599,225],{"class":151},[141,601,386],{"class":158},[141,603,231],{"class":147},[141,605,607],{"class":143,"line":606},20,[141,608,238],{"class":237},[141,610,612],{"class":143,"line":611},21,[141,613,244],{"class":147},[141,615,617],{"class":143,"line":616},22,[141,618,250],{"class":147},[18,620,621,622,625,626,629],{},"也可以使用 ",[22,623,624],{},"TransactionTemplate"," 显式划分事务边界。通过注入自身代理或 ",[22,627,628],{},"AopContext.currentProxy()"," 调用虽然能够绕过问题，但会增加类与 Spring AOP 的耦合，通常不是优先方案。",[14,631,633],{"id":632},"四方法无法被代理增强","四、方法无法被代理增强",[18,635,636],{},"在常见的 Spring AOP 代理模式下，以下方法不能作为可靠的事务入口：",[638,639,641],"h3",{"id":640},"_1-private-方法","1. private 方法",[95,643,645],{"className":135,"code":644,"language":137,"meta":101,"style":101},"@Transactional\nprivate void saveOrder() {\n}\n",[22,646,647,653,663],{"__ignoreMap":101},[141,648,649,651],{"class":143,"line":144},[141,650,263],{"class":147},[141,652,216],{"class":151},[141,654,655,657,659,661],{"class":143,"line":165},[141,656,43],{"class":151},[141,658,225],{"class":151},[141,660,386],{"class":158},[141,662,231],{"class":147},[141,664,665],{"class":143,"line":210},[141,666,250],{"class":147},[18,668,669],{},"私有方法不能被子类覆盖，也不会作为接口代理的外部调用入口，因此不能依赖它建立声明式事务。",[638,671,673],{"id":672},"_2-final-方法","2. final 方法",[95,675,677],{"className":135,"code":676,"language":137,"meta":101,"style":101},"@Transactional\npublic final void saveOrder() {\n}\n",[22,678,679,685,697],{"__ignoreMap":101},[141,680,681,683],{"class":143,"line":144},[141,682,263],{"class":147},[141,684,216],{"class":151},[141,686,687,689,691,693,695],{"class":143,"line":165},[141,688,193],{"class":151},[141,690,484],{"class":151},[141,692,225],{"class":151},[141,694,386],{"class":158},[141,696,231],{"class":147},[141,698,699],{"class":143,"line":210},[141,700,250],{"class":147},[18,702,703,704,706],{},"CGLIB 类代理依靠生成子类并覆盖方法完成增强，",[22,705,47],{}," 方法不能被覆盖，所以无法被这种方式增强。",[638,708,710],{"id":709},"_3-static-方法","3. static 方法",[95,712,714],{"className":135,"code":713,"language":137,"meta":101,"style":101},"@Transactional\npublic static void saveOrder() {\n}\n",[22,715,716,722,735],{"__ignoreMap":101},[141,717,718,720],{"class":143,"line":144},[141,719,263],{"class":147},[141,721,216],{"class":151},[141,723,724,726,729,731,733],{"class":143,"line":165},[141,725,193],{"class":151},[141,727,728],{"class":151}," static",[141,730,225],{"class":151},[141,732,386],{"class":158},[141,734,231],{"class":147},[141,736,737],{"class":143,"line":210},[141,738,250],{"class":147},[18,740,741],{},"静态方法属于类，不属于 Spring 管理的 Bean 实例，实例代理无法拦截这种调用。",[638,743,745],{"id":744},"_4-非-public-方法","4. 非 public 方法",[18,747,748,749,752,753,755],{},"Spring Framework 6 以后，基于类的代理可以支持 ",[22,750,751],{},"protected"," 和包可见方法，但接口代理仍然主要面向接口中的 ",[22,754,193],{}," 方法，不同代理方式和版本存在差异。对入门级业务代码而言，最稳妥的规则仍然是：",[59,757,758],{},[18,759,760],{},"把事务边界放在 Spring Bean 的可覆盖 public 方法上，并从其他 Bean 通过代理调用。",[14,762,764],{"id":763},"五在-bean-初始化阶段调用事务方法","五、在 Bean 初始化阶段调用事务方法",[18,766,767,768,770],{},"不要依赖 ",[22,769,39],{}," 中的事务调用：",[95,772,774],{"className":135,"code":773,"language":137,"meta":101,"style":101},"@PostConstruct\npublic void init() {\n loadData();\n}\n\n@Transactional\npublic void loadData() {\n \u002F\u002F 数据库操作\n}\n",[22,775,776,783,794,801,805,809,815,826,831],{"__ignoreMap":101},[141,777,778,780],{"class":143,"line":144},[141,779,263],{"class":147},[141,781,782],{"class":151},"PostConstruct\n",[141,784,785,787,789,792],{"class":143,"line":165},[141,786,193],{"class":151},[141,788,225],{"class":151},[141,790,791],{"class":158}," init",[141,793,231],{"class":147},[141,795,796,799],{"class":143,"line":210},[141,797,798],{"class":158}," loadData",[141,800,162],{"class":147},[141,802,803],{"class":143,"line":219},[141,804,250],{"class":147},[141,806,807],{"class":143,"line":234},[141,808,207],{"emptyLinePlaceholder":206},[141,810,811,813],{"class":143,"line":241},[141,812,263],{"class":147},[141,814,216],{"class":151},[141,816,817,819,821,824],{"class":143,"line":247},[141,818,193],{"class":151},[141,820,225],{"class":151},[141,822,823],{"class":158}," loadData",[141,825,231],{"class":147},[141,827,828],{"class":143,"line":307},[141,829,830],{"class":237}," \u002F\u002F 数据库操作\n",[141,832,833],{"class":143,"line":379},[141,834,250],{"class":147},[18,836,837],{},"一方面它属于同类调用，另一方面 Bean 初始化期间代理可能尚未处于可供业务调用的完整状态。需要在应用启动后执行事务逻辑时，可以监听容器启动完成事件，再调用另一个 Bean 的事务方法。",[14,839,841],{"id":840},"六异常没有命中回滚规则","六、异常没有命中回滚规则",[18,843,844],{},"Spring 默认对以下异常回滚：",[114,846,847,853],{},[117,848,849,852],{},[22,850,851],{},"RuntimeException"," 及其子类；",[117,854,855,858],{},[22,856,857],{},"Error"," 及其子类。",[18,860,861],{},"默认不会因为受检异常自动回滚：",[95,863,865],{"className":135,"code":864,"language":137,"meta":101,"style":101},"@Transactional\npublic void importFile() throws IOException {\n repository.save(data);\n throw new IOException(\"文件读取失败\");\n}\n",[22,866,867,873,885,896,916],{"__ignoreMap":101},[141,868,869,871],{"class":143,"line":144},[141,870,263],{"class":147},[141,872,216],{"class":151},[141,874,875,877,879,882],{"class":143,"line":165},[141,876,193],{"class":151},[141,878,225],{"class":151},[141,880,881],{"class":158}," importFile",[141,883,884],{"class":147},"() throws IOException {\n",[141,886,887,890,893],{"class":143,"line":210},[141,888,889],{"class":147}," repository.",[141,891,892],{"class":158},"save",[141,894,895],{"class":147},"(data);\n",[141,897,898,901,903,906,909,913],{"class":143,"line":219},[141,899,900],{"class":151}," throw",[141,902,155],{"class":151},[141,904,905],{"class":158}," IOException",[141,907,908],{"class":147},"(",[141,910,912],{"class":911},"sZZnC","\"文件读取失败\"",[141,914,915],{"class":147},");\n",[141,917,918],{"class":143,"line":234},[141,919,250],{"class":147},[18,921,922,923,926],{},"如果业务要求 ",[22,924,925],{},"IOException"," 也触发回滚，需要明确配置：",[95,928,930],{"className":135,"code":929,"language":137,"meta":101,"style":101},"@Transactional(rollbackFor = Exception.class)\npublic void importFile() throws IOException {\n repository.save(data);\n throw new IOException(\"文件读取失败\");\n}\n",[22,931,932,950,960,968,982],{"__ignoreMap":101},[141,933,934,936,939,941,944,947],{"class":143,"line":144},[141,935,263],{"class":147},[141,937,938],{"class":151},"Transactional",[141,940,908],{"class":147},[141,942,943],{"class":428},"rollbackFor",[141,945,946],{"class":151}," =",[141,948,949],{"class":147}," Exception.class)\n",[141,951,952,954,956,958],{"class":143,"line":165},[141,953,193],{"class":151},[141,955,225],{"class":151},[141,957,881],{"class":158},[141,959,884],{"class":147},[141,961,962,964,966],{"class":143,"line":210},[141,963,889],{"class":147},[141,965,892],{"class":158},[141,967,895],{"class":147},[141,969,970,972,974,976,978,980],{"class":143,"line":219},[141,971,900],{"class":151},[141,973,155],{"class":151},[141,975,905],{"class":158},[141,977,908],{"class":147},[141,979,912],{"class":911},[141,981,915],{"class":147},[141,983,984],{"class":143,"line":234},[141,985,250],{"class":147},[18,987,988],{},"更精确的写法是只声明真正需要回滚的异常类型：",[95,990,992],{"className":135,"code":991,"language":137,"meta":101,"style":101},"@Transactional(rollbackFor = IOException.class)\n",[22,993,994],{"__ignoreMap":101},[141,995,996,998,1000,1002,1004,1006],{"class":143,"line":144},[141,997,263],{"class":147},[141,999,938],{"class":151},[141,1001,908],{"class":147},[141,1003,943],{"class":428},[141,1005,946],{"class":151},[141,1007,1008],{"class":147}," IOException.class)\n",[18,1010,1011,1014,1015,44,1017,1019],{},[22,1012,1013],{},"noRollbackFor"," 则表示某类异常不触发回滚。排查时要同时检查 ",[22,1016,943],{},[22,1018,1013],{}," 以及异常的实际类型，不能只看方法是否抛出了异常。",[14,1021,1023],{"id":1022},"七异常被捕获后没有继续抛出","七、异常被捕获后没有继续抛出",[18,1025,1026],{},"事务拦截器需要观察目标方法的返回或异常，才能决定提交还是回滚：",[95,1028,1030],{"className":135,"code":1029,"language":137,"meta":101,"style":101},"@Transactional\npublic void createOrder() {\n try {\n orderRepository.save(order);\n inventoryRepository.deduct(stock);\n } catch (RuntimeException exception) {\n log.error(\"创建订单失败\", exception);\n }\n}\n",[22,1031,1032,1038,1048,1055,1065,1076,1092,1108,1112],{"__ignoreMap":101},[141,1033,1034,1036],{"class":143,"line":144},[141,1035,263],{"class":147},[141,1037,216],{"class":151},[141,1039,1040,1042,1044,1046],{"class":143,"line":165},[141,1041,193],{"class":151},[141,1043,225],{"class":151},[141,1045,228],{"class":158},[141,1047,231],{"class":147},[141,1049,1050,1053],{"class":143,"line":210},[141,1051,1052],{"class":151}," try",[141,1054,201],{"class":147},[141,1056,1057,1060,1062],{"class":143,"line":219},[141,1058,1059],{"class":147}," orderRepository.",[141,1061,892],{"class":158},[141,1063,1064],{"class":147},"(order);\n",[141,1066,1067,1070,1073],{"class":143,"line":234},[141,1068,1069],{"class":147}," inventoryRepository.",[141,1071,1072],{"class":158},"deduct",[141,1074,1075],{"class":147},"(stock);\n",[141,1077,1078,1081,1084,1087,1090],{"class":143,"line":241},[141,1079,1080],{"class":147}," } ",[141,1082,1083],{"class":151},"catch",[141,1085,1086],{"class":147}," (RuntimeException ",[141,1088,1089],{"class":503},"exception",[141,1091,507],{"class":147},[141,1093,1094,1097,1100,1102,1105],{"class":143,"line":247},[141,1095,1096],{"class":147}," log.",[141,1098,1099],{"class":158},"error",[141,1101,908],{"class":147},[141,1103,1104],{"class":911},"\"创建订单失败\"",[141,1106,1107],{"class":147},", exception);\n",[141,1109,1110],{"class":143,"line":307},[141,1111,244],{"class":147},[141,1113,1114],{"class":143,"line":379},[141,1115,250],{"class":147},[18,1117,1118],{},"异常在方法内部被捕获后，方法对事务拦截器表现为正常返回，默认结果就是提交。",[18,1120,1121],{},"通常应让异常继续向外抛出：",[95,1123,1125],{"className":135,"code":1124,"language":137,"meta":101,"style":101},"catch (RuntimeException exception) {\n log.error(\"创建订单失败\", exception);\n throw exception;\n}\n",[22,1126,1127,1137,1150,1157],{"__ignoreMap":101},[141,1128,1129,1131,1133,1135],{"class":143,"line":144},[141,1130,1083],{"class":151},[141,1132,1086],{"class":147},[141,1134,1089],{"class":503},[141,1136,507],{"class":147},[141,1138,1139,1142,1144,1146,1148],{"class":143,"line":165},[141,1140,1141],{"class":147}," log.",[141,1143,1099],{"class":158},[141,1145,908],{"class":147},[141,1147,1104],{"class":911},[141,1149,1107],{"class":147},[141,1151,1152,1154],{"class":143,"line":210},[141,1153,900],{"class":151},[141,1155,1156],{"class":147}," exception;\n",[141,1158,1159],{"class":143,"line":219},[141,1160,250],{"class":147},[18,1162,1163],{},"如果业务必须吞掉异常，也可以显式标记当前事务只能回滚：",[95,1165,1167],{"className":135,"code":1166,"language":137,"meta":101,"style":101},"TransactionAspectSupport\n .currentTransactionStatus()\n .setRollbackOnly();\n",[22,1168,1169,1174,1185],{"__ignoreMap":101},[141,1170,1171],{"class":143,"line":144},[141,1172,1173],{"class":147},"TransactionAspectSupport\n",[141,1175,1176,1179,1182],{"class":143,"line":165},[141,1177,1178],{"class":147}," .",[141,1180,1181],{"class":158},"currentTransactionStatus",[141,1183,1184],{"class":147},"()\n",[141,1186,1187,1189,1192],{"class":143,"line":210},[141,1188,1178],{"class":147},[141,1190,1191],{"class":158},"setRollbackOnly",[141,1193,162],{"class":147},[18,1195,1196],{},"不过这种方式让业务代码依赖 Spring 事务 API，能够通过异常和声明式规则表达时，优先使用声明式方式。",[14,1198,1200],{"id":1199},"八切换到异步线程或手动创建线程","八、切换到异步线程或手动创建线程",[18,1202,1203,1204,1207],{},"传统的 ",[22,1205,1206],{},"PlatformTransactionManager"," 通常把事务资源绑定到当前线程。事务方法中启动的新线程，不会自动继承原线程的事务：",[95,1209,1211],{"className":135,"code":1210,"language":137,"meta":101,"style":101},"@Transactional\npublic void createOrder() {\n orderRepository.save(order);\n\n new Thread(() ->\n inventoryRepository.deduct(stock)\n ).start();\n}\n",[22,1212,1213,1219,1229,1238,1242,1256,1266,1276],{"__ignoreMap":101},[141,1214,1215,1217],{"class":143,"line":144},[141,1216,263],{"class":147},[141,1218,216],{"class":151},[141,1220,1221,1223,1225,1227],{"class":143,"line":165},[141,1222,193],{"class":151},[141,1224,225],{"class":151},[141,1226,228],{"class":158},[141,1228,231],{"class":147},[141,1230,1231,1234,1236],{"class":143,"line":210},[141,1232,1233],{"class":147}," orderRepository.",[141,1235,892],{"class":158},[141,1237,1064],{"class":147},[141,1239,1240],{"class":143,"line":219},[141,1241,207],{"emptyLinePlaceholder":206},[141,1243,1244,1247,1250,1253],{"class":143,"line":234},[141,1245,1246],{"class":151}," new",[141,1248,1249],{"class":158}," Thread",[141,1251,1252],{"class":147},"(() ",[141,1254,1255],{"class":151},"->\n",[141,1257,1258,1261,1263],{"class":143,"line":241},[141,1259,1260],{"class":147}," inventoryRepository.",[141,1262,1072],{"class":158},[141,1264,1265],{"class":147},"(stock)\n",[141,1267,1268,1271,1274],{"class":143,"line":247},[141,1269,1270],{"class":147}," ).",[141,1272,1273],{"class":158},"start",[141,1275,162],{"class":147},[141,1277,1278],{"class":143,"line":307},[141,1279,250],{"class":147},[18,1281,1282],{},"这里的订单写入和库存扣减不在同一个本地事务中。即使外层事务回滚，也不能自动回滚新线程已经完成的数据库操作。",[18,1284,1285,1288],{},[22,1286,1287],{},"@Async"," 同样会切换执行线程。可以让异步方法在自己的线程中重新开启一个独立事务，但这仍然不是对调用方事务的继承：",[95,1290,1293],{"className":1291,"code":1292,"language":100,"meta":101},[98],"调用线程事务 A\n ↓ 提交异步任务\n异步线程事务 B\n",[22,1294,1292],{"__ignoreMap":101},[18,1296,1297],{},"跨线程、跨进程的一致性通常需要消息、Outbox、补偿或状态机等方案，而不能依赖一个线程绑定的本地事务自然传播。",[14,1299,1301],{"id":1300},"九事务传播行为与预期不一致","九、事务传播行为与预期不一致",[18,1303,1304],{},"传播行为决定事务方法被调用时，是加入已有事务、创建新事务，还是暂停或拒绝事务。",[18,1306,1307],{},"常见配置包括：",[1309,1310,1311,1327],"table",{},[1312,1313,1314],"thead",{},[1315,1316,1317,1321,1324],"tr",{},[1318,1319,1320],"th",{},"传播行为",[1318,1322,1323],{},"主要语义",[1318,1325,1326],{},"容易产生的误解",[1328,1329,1330,1344,1357,1370,1383],"tbody",{},[1315,1331,1332,1338,1341],{},[1333,1334,1335],"td",{},[22,1336,1337],{},"REQUIRED",[1333,1339,1340],{},"有事务就加入，没有就创建",[1333,1342,1343],{},"内外层通常属于同一个物理事务",[1315,1345,1346,1351,1354],{},[1333,1347,1348],{},[22,1349,1350],{},"REQUIRES_NEW",[1333,1352,1353],{},"暂停外层事务，创建独立事务",[1333,1355,1356],{},"内层提交后，外层回滚不会撤销内层提交",[1315,1358,1359,1364,1367],{},[1333,1360,1361],{},[22,1362,1363],{},"NESTED",[1333,1365,1366],{},"在已有事务中创建保存点",[1333,1368,1369],{},"依赖事务管理器和数据库对保存点的支持",[1315,1371,1372,1377,1380],{},[1333,1373,1374],{},[22,1375,1376],{},"NOT_SUPPORTED",[1333,1378,1379],{},"暂停已有事务，以非事务方式执行",[1333,1381,1382],{},"方法中的操作不会跟随外层事务回滚",[1315,1384,1385,1390,1393],{},[1333,1386,1387],{},[22,1388,1389],{},"NEVER",[1333,1391,1392],{},"存在事务时直接抛出异常",[1333,1394,1395],{},"不是“不开新事务后继续执行”",[18,1397,1398],{},"例如：",[95,1400,1402],{"className":135,"code":1401,"language":137,"meta":101,"style":101},"@Transactional(propagation = Propagation.REQUIRES_NEW)\npublic void writeAuditLog() {\n auditRepository.save(log);\n}\n",[22,1403,1404,1420,1431,1441],{"__ignoreMap":101},[141,1405,1406,1408,1410,1412,1415,1417],{"class":143,"line":144},[141,1407,263],{"class":147},[141,1409,938],{"class":151},[141,1411,908],{"class":147},[141,1413,1414],{"class":428},"propagation",[141,1416,946],{"class":151},[141,1418,1419],{"class":147}," Propagation.REQUIRES_NEW)\n",[141,1421,1422,1424,1426,1429],{"class":143,"line":165},[141,1423,193],{"class":151},[141,1425,225],{"class":151},[141,1427,1428],{"class":158}," writeAuditLog",[141,1430,231],{"class":147},[141,1432,1433,1436,1438],{"class":143,"line":210},[141,1434,1435],{"class":147}," auditRepository.",[141,1437,892],{"class":158},[141,1439,1440],{"class":147},"(log);\n",[141,1442,1443],{"class":143,"line":219},[141,1444,250],{"class":147},[18,1446,1447],{},"如果调用确实经过另一个 Bean 的代理，审计日志使用独立事务。它提交后，即使外层业务事务回滚，日志仍然保留。这是传播行为的正常语义，不是事务失效。",[18,1449,1450],{},"还要注意，同类自调用时，传播配置同样会因为绕过代理而无法生效。",[14,1452,1454],{"id":1453},"十多数据源使用了错误的事务管理器","十、多数据源使用了错误的事务管理器",[18,1456,1457],{},"应用存在多个数据源时，通常也存在多个事务管理器：",[95,1459,1461],{"className":135,"code":1460,"language":137,"meta":101,"style":101},"@Transactional(transactionManager = \"orderTransactionManager\")\npublic void createOrder() {\n \u002F\u002F orderDataSource 操作\n}\n",[22,1462,1463,1482,1492,1497],{"__ignoreMap":101},[141,1464,1465,1467,1469,1471,1474,1476,1479],{"class":143,"line":144},[141,1466,263],{"class":147},[141,1468,938],{"class":151},[141,1470,908],{"class":147},[141,1472,1473],{"class":428},"transactionManager",[141,1475,946],{"class":151},[141,1477,1478],{"class":911}," \"orderTransactionManager\"",[141,1480,1481],{"class":147},")\n",[141,1483,1484,1486,1488,1490],{"class":143,"line":165},[141,1485,193],{"class":151},[141,1487,225],{"class":151},[141,1489,228],{"class":158},[141,1491,231],{"class":147},[141,1493,1494],{"class":143,"line":210},[141,1495,1496],{"class":237}," \u002F\u002F orderDataSource 操作\n",[141,1498,1499],{"class":143,"line":219},[141,1500,250],{"class":147},[18,1502,1503],{},"如果方法实际操作库存数据源，却使用订单数据源对应的事务管理器，库存连接可能没有加入当前事务。常见现象是订单表回滚了，库存表却已经提交。",[18,1505,1506],{},"排查时需要确认：",[114,1508,1509,1514,1517,1520],{},[117,1510,1511,1513],{},[22,1512,28],{}," 选择的是哪个事务管理器；",[117,1515,1516],{},"Repository、Mapper 或 JdbcTemplate 使用的是哪个数据源；",[117,1518,1519],{},"参与操作的连接是否由当前事务管理器管理；",[117,1521,1522],{},"是否误以为一个本地事务能够覆盖多个独立数据库。",[18,1524,1525],{},"一个普通的本地事务管理器只能管理对应资源。多个独立数据库需要根据一致性要求选择分布式事务、消息最终一致性或业务补偿方案。",[14,1527,1529],{"id":1528},"十一底层存储或操作不支持事务","十一、底层存储或操作不支持事务",[18,1531,1532],{},"Spring 能管理事务，不代表所有底层操作都具备事务能力。例如：",[114,1534,1535,1538,1541,1544,1547],{},[117,1536,1537],{},"使用不支持事务的数据库存储引擎；",[117,1539,1540],{},"在事务中调用远程 HTTP 接口；",[117,1542,1543],{},"发送不受当前事务管理器协调的普通消息；",[117,1545,1546],{},"操作另一个没有加入当前事务的连接或数据源；",[117,1548,1549],{},"数据库 DDL 的提交行为与普通 DML 不同。",[18,1551,1552,1553,1555],{},"这些操作即使写在 ",[22,1554,28],{}," 方法中，也不一定能随着数据库事务一起回滚。",[18,1557,1558],{},"例如下面的远程调用不会因为本地数据库回滚而自动撤销：",[95,1560,1562],{"className":135,"code":1561,"language":137,"meta":101,"style":101},"@Transactional\npublic void createOrder() {\n orderRepository.save(order);\n paymentClient.createPayment(order);\n throw new IllegalStateException(\"创建失败\");\n}\n",[22,1563,1564,1570,1580,1588,1598,1614],{"__ignoreMap":101},[141,1565,1566,1568],{"class":143,"line":144},[141,1567,263],{"class":147},[141,1569,216],{"class":151},[141,1571,1572,1574,1576,1578],{"class":143,"line":165},[141,1573,193],{"class":151},[141,1575,225],{"class":151},[141,1577,228],{"class":158},[141,1579,231],{"class":147},[141,1581,1582,1584,1586],{"class":143,"line":210},[141,1583,1233],{"class":147},[141,1585,892],{"class":158},[141,1587,1064],{"class":147},[141,1589,1590,1593,1596],{"class":143,"line":219},[141,1591,1592],{"class":147}," paymentClient.",[141,1594,1595],{"class":158},"createPayment",[141,1597,1064],{"class":147},[141,1599,1600,1602,1604,1607,1609,1612],{"class":143,"line":234},[141,1601,900],{"class":151},[141,1603,155],{"class":151},[141,1605,1606],{"class":158}," IllegalStateException",[141,1608,908],{"class":147},[141,1610,1611],{"class":911},"\"创建失败\"",[141,1613,915],{"class":147},[141,1615,1616],{"class":143,"line":241},[141,1617,250],{"class":147},[18,1619,1620],{},"本地订单可以回滚，但远程支付系统已经完成的操作需要对方提供撤销接口或通过补偿机制处理。",[14,1622,1624],{"id":1623},"十二代理类型或注解位置不合适","十二、代理类型或注解位置不合适",[18,1626,1627,1628,1630],{},"Spring AOP 常见代理包括 JDK 动态代理和基于类的代理。把 ",[22,1629,28],{}," 放在具体实现类的 public 方法上，通常最直观、最稳定：",[95,1632,1634],{"className":135,"code":1633,"language":137,"meta":101,"style":101},"@Service\npublic class OrderServiceImpl implements OrderService {\n\n @Override\n @Transactional\n public void createOrder() {\n \u002F\u002F 数据库操作\n }\n}\n",[22,1635,1636,1642,1658,1662,1669,1675,1685,1689,1693],{"__ignoreMap":101},[141,1637,1638,1640],{"class":143,"line":144},[141,1639,263],{"class":147},[141,1641,266],{"class":151},[141,1643,1644,1646,1648,1651,1654,1656],{"class":143,"line":165},[141,1645,193],{"class":151},[141,1647,196],{"class":151},[141,1649,1650],{"class":158}," OrderServiceImpl",[141,1652,1653],{"class":151}," implements",[141,1655,159],{"class":158},[141,1657,201],{"class":147},[141,1659,1660],{"class":143,"line":210},[141,1661,207],{"emptyLinePlaceholder":206},[141,1663,1664,1666],{"class":143,"line":219},[141,1665,213],{"class":147},[141,1667,1668],{"class":151},"Override\n",[141,1670,1671,1673],{"class":143,"line":234},[141,1672,213],{"class":147},[141,1674,216],{"class":151},[141,1676,1677,1679,1681,1683],{"class":143,"line":241},[141,1678,222],{"class":151},[141,1680,225],{"class":151},[141,1682,228],{"class":158},[141,1684,231],{"class":147},[141,1686,1687],{"class":143,"line":247},[141,1688,238],{"class":237},[141,1690,1691],{"class":143,"line":307},[141,1692,244],{"class":147},[141,1694,1695],{"class":143,"line":379},[141,1696,250],{"class":147},[18,1698,1699],{},"只在接口上放注解可能受到代理方式、注解查找方式和 AspectJ 模式影响。Spring 官方更推荐把事务注解放在具体类的方法上，避免更换代理或织入方式后出现差异。",[14,1701,1703],{"id":1702},"十三排查顺序","十三、排查顺序",[638,1705,1707],{"id":1706},"_1-确认是否真的没有事务","1. 确认是否真的没有事务",[18,1709,1710],{},"不要只根据“数据库数据没回滚”下结论。先确认：",[114,1712,1713,1716,1719,1722],{},[117,1714,1715],{},"方法是否经过事务代理；",[117,1717,1718],{},"是否创建或加入了事务；",[117,1720,1721],{},"最终执行了提交还是回滚；",[117,1723,1724],{},"没回滚的操作是否属于同一个事务资源。",[18,1726,1727],{},"可以临时提高 Spring 事务相关日志级别，并结合数据库连接、SQL 日志和调用链判断。",[638,1729,1731],{"id":1730},"_2-检查代理入口","2. 检查代理入口",[18,1733,1734],{},"依次确认：",[95,1736,1739],{"className":1737,"code":1738,"language":100,"meta":101},[98],"对象是不是 Spring Bean\n ↓\n调用是不是从其他 Bean 进入\n ↓\n方法是否可被当前代理方式增强\n ↓\n是否发生在 Bean 初始化阶段\n",[22,1740,1738],{"__ignoreMap":101},[638,1742,1744],{"id":1743},"_3-检查回滚条件","3. 检查回滚条件",[18,1746,1747],{},"重点检查：",[95,1749,1752],{"className":1750,"code":1751,"language":100,"meta":101},[98],"实际抛出的异常类型\nrollbackFor \u002F noRollbackFor\n异常是否在方法内部被捕获\n异常是否在事务方法返回后才发生\n",[22,1753,1751],{"__ignoreMap":101},[18,1755,1756],{},"事务方法已经正常返回并提交后，调用方后续再抛异常，不能回头撤销已经提交的事务。",[638,1758,1760],{"id":1759},"_4-检查事务边界","4. 检查事务边界",[18,1762,1763],{},"继续确认：",[114,1765,1766,1769,1777,1780],{},[117,1767,1768],{},"是否切换线程；",[117,1770,1771,1772,44,1774,1776],{},"是否使用 ",[22,1773,1350],{},[22,1775,1376],{}," 等传播行为；",[117,1778,1779],{},"是否跨数据源或跨数据库；",[117,1781,1782],{},"是否包含远程调用、消息或其他非事务资源。",[14,1784,1786],{"id":1785},"十四常见问题速查","十四、常见问题速查",[1309,1788,1789,1799],{},[1312,1790,1791],{},[1315,1792,1793,1796],{},[1318,1794,1795],{},"现象",[1318,1797,1798],{},"首先检查",[1328,1800,1801,1809,1820,1828,1837,1848,1856],{},[1315,1802,1803,1806],{},[1333,1804,1805],{},"方法完全没有事务日志",[1333,1807,1808],{},"对象是否为 Spring Bean，调用是否经过代理",[1315,1810,1811,1814],{},[1333,1812,1813],{},"同类方法上的注解不生效",[1333,1815,1816,1817,1819],{},"是否通过 ",[22,1818,35],{}," 自调用",[1315,1821,1822,1825],{},[1333,1823,1824],{},"抛异常但数据仍提交",[1333,1826,1827],{},"异常是否为受检异常，是否被捕获",[1315,1829,1830,1833],{},[1333,1831,1832],{},"外层回滚但内层数据保留",[1333,1834,1771,1835],{},[22,1836,1350],{},[1315,1838,1839,1842],{},[1333,1840,1841],{},"主线程回滚但异步操作成功",[1333,1843,1844,1845,1847],{},"是否切换到 ",[22,1846,1287],{}," 或新线程",[1315,1849,1850,1853],{},[1333,1851,1852],{},"一个库回滚、另一个库提交",[1333,1854,1855],{},"事务管理器和数据源是否匹配",[1315,1857,1858,1861],{},[1333,1859,1860],{},"数据库回滚但远程操作没撤销",[1333,1862,1863],{},"远程调用不属于本地事务",[14,1865,1867],{"id":1866},"十五参考资料","十五、参考资料",[114,1869,1870,1878,1885,1892,1899],{},[117,1871,1872],{},[73,1873,1877],{"href":1874,"rel":1875},"https:\u002F\u002Fdocs.spring.io\u002Fspring-framework\u002Freference\u002Fdata-access\u002Ftransaction\u002Fdeclarative\u002Ftx-decl-explained.html",[1876],"nofollow","Spring 声明式事务实现原理",[117,1879,1880],{},[73,1881,1884],{"href":1882,"rel":1883},"https:\u002F\u002Fdocs.spring.io\u002Fspring-framework\u002Freference\u002Fdata-access\u002Ftransaction\u002Fdeclarative\u002Fannotations.html",[1876],"Spring @Transactional 使用说明",[117,1886,1887],{},[73,1888,1891],{"href":1889,"rel":1890},"https:\u002F\u002Fdocs.spring.io\u002Fspring-framework\u002Freference\u002Fdata-access\u002Ftransaction\u002Fdeclarative\u002Frolling-back.html",[1876],"Spring 声明式事务回滚规则",[117,1893,1894],{},[73,1895,1898],{"href":1896,"rel":1897},"https:\u002F\u002Fdocs.spring.io\u002Fspring-framework\u002Freference\u002Fcore\u002Faop\u002Fproxying.html",[1876],"Spring AOP 代理机制",[117,1900,1901],{},[73,1902,1905],{"href":1903,"rel":1904},"https:\u002F\u002Fdocs.spring.io\u002Fspring-framework\u002Freference\u002Fdata-access\u002Ftransaction\u002Fdeclarative\u002Ftx-propagation.html",[1876],"Spring 事务传播行为",[1907,1908,1909],"style",{},"html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sJ8bj, html code.shiki .sJ8bj{--shiki-default:#6A737D;--shiki-dark:#6A737D}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .s4XuR, html code.shiki .s4XuR{--shiki-default:#E36209;--shiki-dark:#FFAB70}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}",{"title":101,"searchDepth":165,"depth":165,"links":1911},[1912,1913,1914,1915,1916,1917,1918,1924,1925,1926,1927,1928,1929,1930,1931,1932,1938,1939],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":89,"depth":165,"text":90},{"id":128,"depth":165,"text":129},{"id":315,"depth":165,"text":316},{"id":632,"depth":165,"text":633,"children":1919},[1920,1921,1922,1923],{"id":640,"depth":210,"text":641},{"id":672,"depth":210,"text":673},{"id":709,"depth":210,"text":710},{"id":744,"depth":210,"text":745},{"id":763,"depth":165,"text":764},{"id":840,"depth":165,"text":841},{"id":1022,"depth":165,"text":1023},{"id":1199,"depth":165,"text":1200},{"id":1300,"depth":165,"text":1301},{"id":1453,"depth":165,"text":1454},{"id":1528,"depth":165,"text":1529},{"id":1623,"depth":165,"text":1624},{"id":1702,"depth":165,"text":1703,"children":1933},[1934,1935,1936,1937],{"id":1706,"depth":210,"text":1707},{"id":1730,"depth":210,"text":1731},{"id":1743,"depth":210,"text":1744},{"id":1759,"depth":210,"text":1760},{"id":1785,"depth":165,"text":1786},{"id":1866,"depth":165,"text":1867},"wiki:java:spring-transaction-failure-scenarios","从事务代理、同类调用、方法可代理性、异常回滚规则、异步线程、传播行为、多数据源和数据库能力等角度，系统讲解 Spring 声明式事务不生效的常见原因。","basic",false,"md",{},85,"\u002Fjava\u002Fspring-transaction-failure-scenarios","面试专题",{"title":5,"description":1941},"java\u002Fspring-transaction-failure-scenarios","2026-08-02","30Vj4l_ELL2U__KtBLu-sRQU1yzYU5sYcNMimMOS2Bs",[1954,3471,4390,5700,6746,8108,9862,11010,15754,16951,19002,21696,23107,25048,27302,28986],{"id":1955,"title":1956,"body":1957,"commentId":3460,"description":3461,"difficulty":3462,"draft":1943,"extension":1944,"meta":3463,"navigation":206,"order":3464,"path":3465,"section":3466,"seo":3467,"stem":3468,"updated":3469,"__hash__":3470},"java\u002Fjava\u002Fjdk8-synchronized-lock-states.md","JDK 8 synchronized 设计与锁状态转换",{"type":7,"value":1958,"toc":3403},[1959,1963,1969,1980,1983,1989,1992,1994,2003,2008,2011,2016,2022,2026,2029,2035,2042,2045,2051,2054,2057,2104,2108,2111,2117,2123,2126,2135,2140,2144,2151,2166,2280,2286,2292,2295,2298,2304,2307,2311,2317,2320,2326,2333,2336,2369,2373,2376,2379,2382,2386,2389,2392,2399,2402,2407,2411,2414,2420,2423,2426,2429,2435,2438,2441,2444,2450,2453,2459,2465,2469,2476,2479,2485,2488,2500,2503,2506,2509,2515,2518,2521,2524,2528,2531,2534,2538,2541,2545,2548,2552,2555,2558,2563,2567,2570,2572,2575,2578,2584,2587,2590,2593,2597,2611,2614,2620,2623,2629,2632,2638,2641,2645,2648,2652,2655,2658,2661,2667,2673,2677,2680,2686,2689,2695,2698,2701,2705,2708,2722,2725,2728,2734,2737,2743,2747,2754,2760,2763,2769,2772,2775,2789,2792,2796,2801,2807,2813,2823,2828,2832,2835,2838,2854,2857,2860,2863,2867,3043,3047,3051,3057,3061,3064,3070,3073,3077,3083,3087,3090,3161,3164,3262,3265,3291,3294,3300,3303,3309,3313,3317,3320,3324,3327,3331,3334,3338,3341,3345,3348,3352,3355,3359,3389,3392,3400],[14,1960,1962],{"id":1961},"一先给出整体结论","一、先给出整体结论",[18,1964,1965,1968],{},[22,1966,1967],{},"synchronized"," 是 Java 语言提供的内置同步机制。它在语义上负责三件事：",[114,1970,1971,1974,1977],{},[117,1972,1973],{},"同一时刻只允许满足条件的线程进入临界区；",[117,1975,1976],{},"支持同一线程重复获取同一把锁，也就是可重入；",[117,1978,1979],{},"解锁 happens-before 后续对同一 Monitor 的加锁，保证相关共享数据的可见性和有序性。",[18,1981,1982],{},"在 JDK 8 HotSpot 中，为了避免所有同步操作都直接阻塞线程，JVM 会根据竞争情况使用不同实现：",[95,1984,1987],{"className":1985,"code":1986,"language":100,"meta":101},[98],"偏向锁：同一个线程反复进入，尽量避免原子操作\n轻量级锁：线程交替执行或短暂竞争，使用栈上 Lock Record 和 CAS\n重量级锁：竞争较强或必须使用 Monitor 能力时，通过 ObjectMonitor 管理等待线程\n",[22,1988,1986],{"__ignoreMap":101},[18,1990,1991],{},"通常所说的“无锁、偏向锁、轻量级锁、重量级锁”，是对对象头及其关联同步结构的概括，不是 Java 语言规范定义的四种锁类型。",[14,1993,69],{"id":69},[18,1995,1996],{},[73,1997,2000],{"href":1998,"target":76,"rel":1999},"\u002Fimages\u002Fwiki\u002Fjava\u002Fjdk8-synchronized-state-transitions.svg",[78,79],[81,2001],{"src":1998,"alt":2002},"JDK 8 synchronized 锁状态转换总览",[59,2004,2005],{},[18,2006,2007],{},"图中信息较多，可点击图片查看原图。",[18,2009,2010],{},"需要先纠正一个常见说法：",[59,2012,2013],{},[18,2014,2015],{},"“锁只能升级，不能降级”适合帮助理解竞争路径，但并不严谨。",[18,2017,2018,2019],{},"轻量级锁正常释放后会通过 CAS 恢复对象原来的 Mark Word；已经膨胀的 ObjectMonitor 也可能在后续安全点被 JVM 回收。更准确的说法是：",[64,2020,2021],{},"持锁竞争过程中通常不会为了当前请求立即从重量级锁退回轻量级锁，但对象状态并非终身只能单向变化。",[14,2023,2025],{"id":2024},"二synchronized-在字节码中的入口","二、synchronized 在字节码中的入口",[18,2027,2028],{},"同步代码块通常编译为：",[95,2030,2033],{"className":2031,"code":2032,"language":100,"meta":101},[98],"monitorenter\n 临界区代码\nmonitorexit\n",[22,2034,2032],{"__ignoreMap":101},[18,2036,2037,2038,2041],{},"编译器会为正常返回和异常退出路径生成对应的 ",[22,2039,2040],{},"monitorexit","，保证退出同步块时释放锁。",[18,2043,2044],{},"同步方法不会在方法体中出现这两个指令，而是在方法访问标志中使用：",[95,2046,2049],{"className":2047,"code":2048,"language":100,"meta":101},[98],"ACC_SYNCHRONIZED\n",[22,2050,2048],{"__ignoreMap":101},[18,2052,2053],{},"JVM 在调用和返回同步方法时完成 Monitor 的进入与退出。",[18,2055,2056],{},"无论入口是哪一种，最终都围绕同一个锁对象工作：",[1309,2058,2059,2069],{},[1312,2060,2061],{},[1315,2062,2063,2066],{},[1318,2064,2065],{},"写法",[1318,2067,2068],{},"实际锁对象",[1328,2070,2071,2081,2093],{},[1315,2072,2073,2076],{},[1333,2074,2075],{},"实例同步方法",[1333,2077,2078,2079],{},"当前实例 ",[22,2080,35],{},[1315,2082,2083,2086],{},[1333,2084,2085],{},"静态同步方法",[1333,2087,2088,2089,2092],{},"当前类对应的 ",[22,2090,2091],{},"Class"," 对象",[1315,2094,2095,2098],{},[1333,2096,2097],{},"同步代码块",[1333,2099,2100,2103],{},[22,2101,2102],{},"synchronized (...)"," 中指定的对象",[14,2105,2107],{"id":2106},"三对象头与-mark-word","三、对象头与 Mark Word",[18,2109,2110],{},"普通 Java 对象的对象头主要包含：",[95,2112,2115],{"className":2113,"code":2114,"language":100,"meta":101},[98],"Mark Word\nKlass Pointer\n",[22,2116,2114],{"__ignoreMap":101},[18,2118,2119,2120,2122],{},"数组对象还会额外保存数组长度。",[22,2121,1967],{}," 的关键状态主要编码在 Mark Word 中。",[18,2124,2125],{},"以 JDK 8、64 位 HotSpot 为例，Mark Word 会复用同一段空间：",[18,2127,2128],{},[73,2129,2132],{"href":2130,"target":76,"rel":2131},"\u002Fimages\u002Fwiki\u002Fjava\u002Fjdk8-synchronized-mark-word.svg",[78,79],[81,2133],{"src":2130,"alt":2134},"JDK 8 HotSpot Mark Word 与同步结构",[59,2136,2137],{},[18,2138,2139],{},"可点击图片查看完整尺寸。",[638,2141,2143],{"id":2142},"统一按最低-3-位阅读","统一按最低 3 位阅读",[18,2145,2146,2147,2150],{},"为了避免一会儿看 2 位、一会儿看 3 位，本文后续统一展示 Mark Word 的最低 ",[64,2148,2149],{},"3 位","。但要先区分“展示宽度”和“字段含义”：",[114,2152,2153,2160,2163],{},[117,2154,2155,2156,2159],{},"真正的锁标志始终是最低 ",[64,2157,2158],{},"2 位","；",[117,2161,2162],{},"只有普通未锁定和偏向布局会把倒数第 3 位解释成“偏向位”；",[117,2164,2165],{},"轻量级锁、重量级锁保存的是对齐后的指针，本文把其最低 3 位也完整写出，但倒数第 3 位不再表示偏向。",[1309,2167,2168,2184],{},[1312,2169,2170],{},[1315,2171,2172,2175,2178,2181],{},[1318,2173,2174],{},"最低 3 位",[1318,2176,2177],{},"最低 2 位锁标志",[1318,2179,2180],{},"状态",[1318,2182,2183],{},"倒数第 3 位如何解释",[1328,2185,2186,2207,2226,2244,2262],{},[1315,2187,2188,2193,2198,2201],{},[1333,2189,2190],{},[22,2191,2192],{},"001",[1333,2194,2195],{},[22,2196,2197],{},"01",[1333,2199,2200],{},"普通未锁定",[1333,2202,2203,2204],{},"偏向位为 ",[22,2205,2206],{},"0",[1315,2208,2209,2214,2218,2221],{},[1333,2210,2211],{},[22,2212,2213],{},"101",[1333,2215,2216],{},[22,2217,2197],{},[1333,2219,2220],{},"可偏向或已偏向",[1333,2222,2203,2223],{},[22,2224,2225],{},"1",[1315,2227,2228,2233,2238,2241],{},[1333,2229,2230],{},[22,2231,2232],{},"000",[1333,2234,2235],{},[22,2236,2237],{},"00",[1333,2239,2240],{},"轻量级锁",[1333,2242,2243],{},"对齐后的 Lock Record 指针低位，不是偏向位",[1315,2245,2246,2251,2256,2259],{},[1333,2247,2248],{},[22,2249,2250],{},"010",[1333,2252,2253],{},[22,2254,2255],{},"10",[1333,2257,2258],{},"重量级锁",[1333,2260,2261],{},"对齐后的 ObjectMonitor 指针低位，不是偏向位",[1315,2263,2264,2269,2274,2277],{},[1333,2265,2266],{},[22,2267,2268],{},"011",[1333,2270,2271],{},[22,2272,2273],{},"11",[1333,2275,2276],{},"GC 标记",[1333,2278,2279],{},"标记状态的一部分，不是偏向位",[18,2281,2282,2283,2285],{},"因此 ",[22,2284,2213],{}," 应当拆开读成：",[95,2287,2290],{"className":2288,"code":2289,"language":100,"meta":101},[98],"偏向位 1 ｜ 锁标志 01\n",[22,2291,2289],{"__ignoreMap":101},[18,2293,2294],{},"它不是一个三位的“锁标志”。本文使用三位只是为了让所有状态在图表中对齐、便于比较。",[18,2296,2297],{},"其中偏向状态可以继续区分：",[95,2299,2302],{"className":2300,"code":2301,"language":100,"meta":101},[98],"匿名偏向：线程指针为空，允许第一个线程认领\n已偏向：线程指针指向获得偏向的 JavaThread\n",[22,2303,2301],{"__ignoreMap":101},[18,2305,2306],{},"Mark Word 是一块被复用的空间。例如普通未锁定对象可以直接保存 identity hash；偏向对象需要保存线程指针，因此二者不能同时使用同一布局。",[638,2308,2310],{"id":2309},"epoch-到底是什么","epoch 到底是什么",[18,2312,2313,2316],{},[22,2314,2315],{},"epoch"," 可以理解为某个类的“偏向版本号”，它不是时间戳，也不是对象年龄。",[18,2318,2319],{},"偏向锁不只依赖对象自身。支持偏向的类会在类的 prototype header 中保存一个当前 epoch；每个偏向对象的 Mark Word 中也会记录对象认领时使用的 epoch。线程进入偏向对象时，会比较两者：",[95,2321,2324],{"className":2322,"code":2323,"language":100,"meta":101},[98],"对象 epoch == 类当前 epoch\n → 这份偏向记录仍属于当前版本，继续检查偏向线程\n\n对象 epoch != 类当前 epoch\n → 这份偏向记录已经过期，可以进入重偏向或撤销流程\n",[22,2325,2323],{"__ignoreMap":101},[18,2327,2328,2329,2332],{},"它主要服务于",[64,2330,2331],{},"批量重偏向","。当一批对象从线程 A 整体转交给线程 B 使用时，JVM 不必立即逐个改写所有对象头，而是先提升类的 epoch。旧对象之后被访问时，会因为 epoch 不匹配而按新版本重新处理。",[18,2334,2335],{},"所以需要把两个容易混淆的字段分开：",[1309,2337,2338,2348],{},[1312,2339,2340],{},[1315,2341,2342,2345],{},[1318,2343,2344],{},"字段",[1318,2346,2347],{},"含义",[1328,2349,2350,2360],{},[1315,2351,2352,2357],{},[1333,2353,2354],{},[22,2355,2356],{},"age",[1333,2358,2359],{},"对象的 GC 年龄，用于分代回收",[1315,2361,2362,2366],{},[1333,2363,2364],{},[22,2365,2315],{},[1333,2367,2368],{},"类的偏向版本，用于判断对象上的偏向记录是否过期",[14,2370,2372],{"id":2371},"四jdk-8-为什么需要三种锁实现","四、JDK 8 为什么需要三种锁实现",[18,2374,2375],{},"不同竞争场景适合不同成本的同步方式。",[638,2377,2378],{"id":2378},"只有一个线程反复进入",[18,2380,2381],{},"如果一个对象长期只被同一个线程加锁，每次都执行 CAS 仍然是额外成本。偏向锁把对象与线程关联起来，后续同一线程进入时主要检查对象头是否仍偏向自己。",[638,2383,2385],{"id":2384},"多线程交替执行但没有同时竞争","多线程交替执行，但没有同时竞争",[18,2387,2388],{},"例如线程 A 使用完后线程 B 才进入。此时没有必要挂起线程，可以通过栈上 Lock Record 和 CAS 完成加锁、解锁。",[638,2390,2391],{"id":2391},"多线程同时争抢或需要等待队列",[18,2393,2394,2395,2398],{},"当 CAS 快速路径无法解决竞争，或者调用 ",[22,2396,2397],{},"wait()"," 需要条件等待集合时，JVM 使用 ObjectMonitor 管理 Owner、竞争线程和等待线程。",[18,2400,2401],{},"所以这三种实现的目标不是简单比较“谁更高级”，而是：",[59,2403,2404],{},[18,2405,2406],{},"根据实际竞争强度，在原子操作、CPU 自旋、线程阻塞和唤醒成本之间做权衡。",[14,2408,2410],{"id":2409},"五对象初始状态普通未锁定还是匿名偏向","五、对象初始状态：普通未锁定还是匿名偏向",[18,2412,2413],{},"JDK 8 默认启用偏向锁，但默认存在启动延迟：",[95,2415,2418],{"className":2416,"code":2417,"language":100,"meta":101},[98],"-XX:+UseBiasedLocking\n-XX:BiasedLockingStartupDelay=4000\n",[22,2419,2417],{"__ignoreMap":101},[18,2421,2422],{},"因此需要区分对象创建时机：",[638,2424,2425],{"id":2425},"偏向锁尚未启用或被关闭",[18,2427,2428],{},"新对象通常使用普通未锁定布局：",[95,2430,2433],{"className":2431,"code":2432,"language":100,"meta":101},[98],"[identity hash | age | 0 | 01]\n",[22,2434,2432],{"__ignoreMap":101},[18,2436,2437],{},"线程第一次进入同步块时，直接尝试建立轻量级锁。",[638,2439,2440],{"id":2440},"偏向锁已经启用",[18,2442,2443],{},"支持偏向的类创建新对象时，对象通常处于匿名偏向状态：",[95,2445,2448],{"className":2446,"code":2447,"language":100,"meta":101},[98],"[0 | epoch | age | 1 | 01]\n",[22,2449,2447],{"__ignoreMap":101},[18,2451,2452],{},"因此严格来说，不应把这条路径描述为：",[95,2454,2457],{"className":2455,"code":2456,"language":100,"meta":101},[98],"新对象先是无锁，然后第一次进入才“升级”为可偏向状态\n",[22,2458,2456],{"__ignoreMap":101},[18,2460,2461,2462],{},"更准确的说法是：",[64,2463,2464],{},"对象创建时便根据类的 prototype header 获得普通未锁定或匿名偏向的 Mark Word。",[14,2466,2468],{"id":2467},"六偏向锁的获取与重入","六、偏向锁的获取与重入",[18,2470,2471,2472,2475],{},"线程进入一个匿名偏向对象时，会尝试通过 CAS 把自己的 ",[22,2473,2474],{},"JavaThread*","、类当前的 epoch 等信息写入 Mark Word。",[18,2477,2478],{},"成功后，对象变成：",[95,2480,2483],{"className":2481,"code":2482,"language":100,"meta":101},[98],"[当前 JavaThread* | epoch | age | 1 | 01]\n",[22,2484,2482],{"__ignoreMap":101},[18,2486,2487],{},"同一个线程以后再次进入时，主要检查：",[2489,2490,2491,2494,2497],"ol",{},[117,2492,2493],{},"Mark Word 是否仍是偏向模式；",[117,2495,2496],{},"偏向线程是否是当前线程；",[117,2498,2499],{},"对象 epoch 是否仍与类的 prototype header 匹配。",[18,2501,2502],{},"全部满足时可直接进入，不需要再次通过 CAS 抢占锁。",[638,2504,2505],{"id":2505},"偏向锁退出为什么不清除线程信息",[18,2507,2508],{},"偏向锁针对的就是“同一个线程还会再次进入”这一场景。同步块结束后，Mark Word 通常仍保留对原线程的偏向：",[95,2510,2513],{"className":2511,"code":2512,"language":100,"meta":101},[98],"进入前：偏向线程 A\n执行中：偏向线程 A\n退出后：仍偏向线程 A\n",[22,2514,2512],{"__ignoreMap":101},[18,2516,2517],{},"它不是表示线程 A 永远占用临界区，而是表示下一次线程 A 再进入时可以走低成本路径。",[638,2519,2520],{"id":2520},"偏向锁如何实现可重入",[18,2522,2523],{},"对象头记录了偏向线程，但不通过一个公共计数器记录每次进入。JVM 可以结合当前线程栈上的锁记录识别同步嵌套。对同一偏向线程而言，重复进入不需要竞争性地修改对象头。",[14,2525,2527],{"id":2526},"七其他线程访问偏向对象时发生什么","七、其他线程访问偏向对象时发生什么",[18,2529,2530],{},"线程 B 遇到偏向线程 A 的对象时，不能简单地直接覆盖线程指针。JVM 需要先判断原偏向是否仍然有效。",[18,2532,2533],{},"可能出现以下路径。",[638,2535,2537],{"id":2536},"_1-epoch-已过期","1. epoch 已过期",[18,2539,2540],{},"类发生批量重偏向后，旧对象的 epoch 可能落后于类的 epoch。线程 B 可以尝试通过 CAS 将对象重新偏向自己。",[638,2542,2544],{"id":2543},"_2-原线程已经不再持有这把锁","2. 原线程已经不再持有这把锁",[18,2546,2547],{},"JVM 可以撤销原偏向，使对象恢复为普通未锁定状态，或者在允许的情况下重新偏向新线程。",[638,2549,2551],{"id":2550},"_3-原线程仍在同步块中","3. 原线程仍在同步块中",[18,2553,2554],{},"JVM 需要检查原线程栈，撤销偏向并重建合法的锁状态。如果此时存在实际竞争，后续会进入轻量级竞争或直接膨胀为 ObjectMonitor。",[18,2556,2557],{},"因此：",[59,2559,2560],{},[18,2561,2562],{},"另一个线程访问偏向对象，不等于必然直接升级为重量级锁。是否重偏向、撤销为普通状态、转换为轻量级锁或膨胀，需要结合 epoch、类级启发式统计和原线程是否仍持锁判断。",[14,2564,2566],{"id":2565},"八批量重偏向与批量撤销","八、批量重偏向与批量撤销",[18,2568,2569],{},"如果某个类的大量对象不断被不同线程使用，逐个在安全点撤销偏向的成本会很高。HotSpot 会对同一类的偏向撤销次数做启发式统计。",[638,2571,2331],{"id":2331},[18,2573,2574],{},"当撤销达到一定阈值时，JVM 可以提升类 prototype header 中的 epoch。旧对象不需要立刻逐个修改；之后线程发现对象 epoch 过期时，再尝试将它偏向当前线程。",[18,2576,2577],{},"适合这种模式：",[95,2579,2582],{"className":2580,"code":2581,"language":100,"meta":101},[98],"一批对象先由线程 A 使用\n之后整体交给线程 B 使用\n但同一时刻竞争并不强\n",[22,2583,2581],{"__ignoreMap":101},[638,2585,2586],{"id":2586},"批量撤销",[18,2588,2589],{},"如果该类持续表现出多线程竞争，偏向锁已经不再适合，JVM 可以撤销该类的偏向能力。之后新对象不再默认可偏向，已有对象也会按正常锁路径处理。",[18,2591,2592],{},"这也是为什么偏向锁不能只按“对象自身的四级升级”理解：它还存在以类为粒度的 prototype header、epoch 和批量启发式机制。",[14,2594,2596],{"id":2595},"九普通未锁定到轻量级锁","九、普通未锁定到轻量级锁",[18,2598,2599,2600,2603,2604,2607,2608,2610],{},"当对象处于普通未锁定状态，线程进入同步块时会在当前栈帧创建锁记录，HotSpot 源码中对应 ",[22,2601,2602],{},"BasicLock","，解释器栈中通常由 ",[22,2605,2606],{},"BasicObjectLock"," 将对象引用和 ",[22,2609,2602],{}," 组织在一起。",[18,2612,2613],{},"概念流程如下：",[95,2615,2618],{"className":2616,"code":2617,"language":100,"meta":101},[98],"1. 在线程栈创建 Lock Record\n2. 将对象原 Mark Word 保存到 displaced header\n3. CAS 修改对象 Mark Word\n4. 让 Mark Word 指向当前 Lock Record\n",[22,2619,2617],{"__ignoreMap":101},[18,2621,2622],{},"CAS 成功后：",[95,2624,2627],{"className":2625,"code":2626,"language":100,"meta":101},[98],"对象 Mark Word → 线程栈 Lock Record\nLock Record → 保存原 Mark Word\n",[22,2628,2626],{"__ignoreMap":101},[18,2630,2631],{},"对象头低两位为：",[95,2633,2636],{"className":2634,"code":2635,"language":100,"meta":101},[98],"00\n",[22,2637,2635],{"__ignoreMap":101},[18,2639,2640],{},"这就是通常所说的轻量级锁或栈锁。",[638,2642,2644],{"id":2643},"为什么要保存-displaced-header","为什么要保存 displaced header",[18,2646,2647],{},"轻量级锁占用了对象原来的 Mark Word。解锁时需要把原 Mark Word 恢复回对象头，因此先把它保存到 Lock Record。",[14,2649,2651],{"id":2650},"十轻量级锁的可重入","十、轻量级锁的可重入",[18,2653,2654],{},"同一个线程再次获取已经由自己栈锁定的对象时，JVM 会识别对象头中的 Lock Record 指针属于当前线程栈。",[18,2656,2657],{},"此时新的 Lock Record 会使用特殊值表示递归进入，例如 displaced header 置空，而不是再次覆盖对象头。",[18,2659,2660],{},"退出时：",[95,2662,2665],{"className":2663,"code":2664,"language":100,"meta":101},[98],"递归层 Lock Record：只退出当前递归层\n最外层 Lock Record：负责真正恢复对象头\n",[22,2666,2664],{"__ignoreMap":101},[18,2668,2669,2670,2672],{},"这解释了为什么 ",[22,2671,1967],{}," 天然支持可重入。",[14,2674,2676],{"id":2675},"十一轻量级锁如何释放","十一、轻量级锁如何释放",[18,2678,2679],{},"最外层同步块退出时，线程使用 CAS 尝试把 Lock Record 中保存的 displaced header 恢复到对象 Mark Word：",[95,2681,2684],{"className":2682,"code":2683,"language":100,"meta":101},[98],"期望值：对象头仍指向当前 Lock Record\n新值：进入同步块前保存的原 Mark Word\n",[22,2685,2683],{"__ignoreMap":101},[18,2687,2688],{},"CAS 成功：",[95,2690,2693],{"className":2691,"code":2692,"language":100,"meta":101},[98],"轻量级锁正常释放\n对象恢复普通未锁定状态\n",[22,2694,2692],{"__ignoreMap":101},[18,2696,2697],{},"CAS 失败通常意味着对象已在竞争过程中膨胀，不能再直接把原对象头覆盖回去，需要走 ObjectMonitor 的退出逻辑。",[18,2699,2700],{},"这就是“锁只能升级不能降级”表述不够准确的直接例子：没有发生膨胀的轻量级锁，退出后会恢复原 Mark Word。",[14,2702,2704],{"id":2703},"十二轻量级锁何时膨胀","十二、轻量级锁何时膨胀",[18,2706,2707],{},"线程尝试用 CAS 建立轻量级锁失败，说明对象头已经发生变化。可能原因包括：",[114,2709,2710,2713,2716,2719],{},[117,2711,2712],{},"另一个线程持有轻量级锁；",[117,2714,2715],{},"对象已经膨胀为 ObjectMonitor；",[117,2717,2718],{},"竞争期间其他线程正在处理锁状态；",[117,2720,2721],{},"必须执行依赖 ObjectMonitor 的操作。",[18,2723,2724],{},"JVM 可以先进行短暂自旋，希望持锁线程很快退出。自旋避免了线程立即挂起和恢复，但会消耗 CPU，因此只适合临界区较短的情况。",[18,2726,2727],{},"当快速路径不能解决问题时，JVM 会执行 Monitor inflation：",[95,2729,2732],{"className":2730,"code":2731,"language":100,"meta":101},[98],"创建或取得 ObjectMonitor\n复制并保存原 Mark Word\n将对象头改为指向 ObjectMonitor\n由 ObjectMonitor 负责后续竞争\n",[22,2733,2731],{"__ignoreMap":101},[18,2735,2736],{},"对象头低两位变成：",[95,2738,2741],{"className":2739,"code":2740,"language":100,"meta":101},[98],"10\n",[22,2742,2740],{"__ignoreMap":101},[14,2744,2746],{"id":2745},"十三重量级锁与-objectmonitor","十三、重量级锁与 ObjectMonitor",[18,2748,2749,2750,2753],{},"重量级状态下，对象 Mark Word 指向一个 ",[22,2751,2752],{},"ObjectMonitor","。理解它时重点关注以下字段或逻辑角色：",[95,2755,2758],{"className":2756,"code":2757,"language":100,"meta":101},[98],"_owner 当前持有 Monitor 的线程或相关锁记录\n_recursions 重入次数\n_cxq 新到达竞争线程形成的竞争队列\n_EntryList 等待重新竞争 Owner 的线程\n_WaitSet 调用 wait 后等待通知的线程\n_header 膨胀前保存的对象 Mark Word\n",[22,2759,2757],{"__ignoreMap":101},[18,2761,2762],{},"概念结构：",[95,2764,2767],{"className":2765,"code":2766,"language":100,"meta":101},[98],"对象 Mark Word\n │\n ▼\nObjectMonitor\n ├─ Owner\n ├─ Recursions\n ├─ cxq \u002F EntryList\n ├─ WaitSet\n └─ displaced header\n",[22,2768,2766],{"__ignoreMap":101},[18,2770,2771],{},"竞争线程可能先自旋尝试获得 Owner。仍然失败时，线程会进入等待结构并被挂起；持有线程退出后，Monitor 选择或唤醒后继线程继续竞争。",[18,2773,2774],{},"“重量级”的成本主要来自：",[114,2776,2777,2780,2783,2786],{},[117,2778,2779],{},"维护竞争和等待队列；",[117,2781,2782],{},"线程阻塞、唤醒与调度；",[117,2784,2785],{},"高竞争下的上下文切换；",[117,2787,2788],{},"对 Monitor 状态的原子协调。",[18,2790,2791],{},"它并不意味着每次操作都必然立刻执行一次昂贵的系统调用，HotSpot 仍包含快速路径和自适应自旋等优化。",[14,2793,2795],{"id":2794},"十四waitnotify-为什么会涉及重量级-monitor","十四、wait、notify 为什么会涉及重量级 Monitor",[18,2797,2798,2800],{},[22,2799,2397],{}," 的语义不是普通锁竞争：",[95,2802,2805],{"className":2803,"code":2804,"language":100,"meta":101},[98],"确认当前线程持有 Monitor\n完整释放锁及其重入层数\n进入 WaitSet\n等待 notify、notifyAll、中断或超时\n重新参与锁竞争\n恢复原重入状态后返回\n",[22,2806,2804],{"__ignoreMap":101},[18,2808,2809,2810,2812],{},"这需要 Owner、WaitSet、EntryList、重入次数等完整 Monitor 能力，因此 JDK 8 HotSpot 执行 ",[22,2811,2397],{}," 时会确保对象已经膨胀为 ObjectMonitor。",[18,2814,2815,2818,2819,2822],{},[22,2816,2817],{},"notify()"," 和 ",[22,2820,2821],{},"notifyAll()"," 存在一个细节：如果对象当前只是由调用线程栈锁定，那么它不可能已经拥有 WaitSet，HotSpot 可以直接返回而不做无意义的膨胀；否则会取得或膨胀 ObjectMonitor，再处理等待线程。",[18,2824,2825,2827],{},[22,2826,2817],{}," 只是把等待线程从“等待条件”推进到“可以重新竞争锁”的阶段，并不会让它绕过当前 Owner 立即执行。",[14,2829,2831],{"id":2830},"十五identityhashcode-对锁状态的影响","十五、identityHashCode 对锁状态的影响",[18,2833,2834],{},"普通未锁定对象可以把 identity hash 保存在 Mark Word 中，但偏向锁的 Mark Word 需要保存 JavaThread 指针。",[18,2836,2837],{},"因此，对偏向对象计算：",[95,2839,2841],{"className":135,"code":2840,"language":137,"meta":101,"style":101},"System.identityHashCode(obj);\n",[22,2842,2843],{"__ignoreMap":101},[141,2844,2845,2848,2851],{"class":143,"line":144},[141,2846,2847],{"class":147},"System.",[141,2849,2850],{"class":158},"identityHashCode",[141,2852,2853],{"class":147},"(obj);\n",[18,2855,2856],{},"通常会导致偏向撤销，使对象头能够保存 hash。",[18,2858,2859],{},"如果对象正在使用轻量级锁，原 Mark Word 已经保存在当前线程栈的 Lock Record 中。为了稳定保存 identity hash，并让其他线程可靠读取，HotSpot 的相关路径可能把对象膨胀为 ObjectMonitor，再把 hash 保存在 Monitor 保存的 header 中。",[18,2861,2862],{},"所以观察锁升级实验时，不要在不知情的情况下调用可能计算 identity hash 的方法，否则实验本身会改变对象头。",[14,2864,2866],{"id":2865},"十六完整状态转换表","十六、完整状态转换表",[1309,2868,2869,2882],{},[1312,2870,2871],{},[1315,2872,2873,2876,2879],{},[1318,2874,2875],{},"当前状态",[1318,2877,2878],{},"触发条件",[1318,2880,2881],{},"可能结果",[1328,2883,2884,2897,2910,2923,2935,2947,2959,2972,2984,2996,3008,3019,3032],{},[1315,2885,2886,2891,2894],{},[1333,2887,2888,2889],{},"普通未锁定 ",[22,2890,2192],{},[1333,2892,2893],{},"首次进入同步块",[1333,2895,2896],{},"CAS 成功后成为轻量级锁",[1315,2898,2899,2904,2907],{},[1333,2900,2901,2902],{},"匿名偏向 ",[22,2903,2213],{},[1333,2905,2906],{},"第一个线程进入",[1333,2908,2909],{},"CAS 写入线程指针，成为已偏向状态",[1315,2911,2912,2917,2920],{},[1333,2913,2914,2915],{},"已偏向 ",[22,2916,2213],{},[1333,2918,2919],{},"原线程再次进入",[1333,2921,2922],{},"保持偏向，低成本重入",[1315,2924,2925,2929,2932],{},[1333,2926,2914,2927],{},[22,2928,2213],{},[1333,2930,2931],{},"新线程访问且 epoch 过期",[1333,2933,2934],{},"尝试重偏向或撤销",[1315,2936,2937,2941,2944],{},[1333,2938,2914,2939],{},[22,2940,2213],{},[1333,2942,2943],{},"新线程访问，原线程未持锁",[1333,2945,2946],{},"撤销为普通状态，或按策略重偏向",[1315,2948,2949,2953,2956],{},[1333,2950,2914,2951],{},[22,2952,2213],{},[1333,2954,2955],{},"新线程访问，原线程仍持锁",[1333,2957,2958],{},"撤销偏向，转轻量级或膨胀",[1315,2960,2961,2966,2969],{},[1333,2962,2963,2964],{},"轻量级 ",[22,2965,2237],{},[1333,2967,2968],{},"当前线程重入",[1333,2970,2971],{},"新增递归 Lock Record，保持轻量级",[1315,2973,2974,2978,2981],{},[1333,2975,2963,2976],{},[22,2977,2237],{},[1333,2979,2980],{},"无竞争退出",[1333,2982,2983],{},"CAS 恢复原 Mark Word",[1315,2985,2986,2990,2993],{},[1333,2987,2963,2988],{},[22,2989,2237],{},[1333,2991,2992],{},"竞争持续或恢复对象头失败",[1333,2994,2995],{},"膨胀为 ObjectMonitor",[1315,2997,2998,3001,3006],{},[1333,2999,3000],{},"任意适用状态",[1333,3002,3003,3005],{},[22,3004,2397],{}," 等需要完整 Monitor 语义",[1333,3007,2995],{},[1315,3009,3010,3013,3016],{},[1333,3011,3012],{},"偏向\u002F轻量级",[1333,3014,3015],{},"计算 identity hash 等特殊场景",[1333,3017,3018],{},"撤销偏向或膨胀",[1315,3020,3021,3026,3029],{},[1333,3022,3023,3024],{},"重量级 ",[22,3025,2255],{},[1333,3027,3028],{},"Owner 退出",[1333,3030,3031],{},"唤醒\u002F选择后继；对象仍可保持膨胀",[1315,3033,3034,3037,3040],{},[1333,3035,3036],{},"空闲 ObjectMonitor",[1333,3038,3039],{},"后续安全点清理",[1333,3041,3042],{},"JVM 可能执行 Monitor deflation",[14,3044,3046],{"id":3045},"十七三条典型执行路径","十七、三条典型执行路径",[638,3048,3050],{"id":3049},"路径一同一个线程反复进入","路径一：同一个线程反复进入",[95,3052,3055],{"className":3053,"code":3054,"language":100,"meta":101},[98],"匿名偏向\n → CAS 偏向线程 A\n → A 执行同步块\n → A 退出但保留偏向\n → A 再次进入，快速命中\n",[22,3056,3054],{"__ignoreMap":101},[638,3058,3060],{"id":3059},"路径二线程交替使用没有重叠竞争","路径二：线程交替使用，没有重叠竞争",[18,3062,3063],{},"偏向关闭或偏向已撤销时：",[95,3065,3068],{"className":3066,"code":3067,"language":100,"meta":101},[98],"普通未锁定\n → A 建立轻量级锁\n → A CAS 恢复对象头\n → B 建立轻量级锁\n → B CAS 恢复对象头\n",[22,3069,3067],{"__ignoreMap":101},[18,3071,3072],{},"这种场景没有必要让线程进入阻塞等待。",[638,3074,3076],{"id":3075},"路径三多线程同时竞争","路径三：多线程同时竞争",[95,3078,3081],{"className":3079,"code":3080,"language":100,"meta":101},[98],"A 持有轻量级锁\n → B CAS 失败并短暂自旋\n → A 未及时释放\n → 对象膨胀为 ObjectMonitor\n → B 进入竞争\u002F等待结构\n → A 退出并推进后继竞争\n",[22,3082,3080],{"__ignoreMap":101},[14,3084,3086],{"id":3085},"十八jol-验证时要注意什么","十八、JOL 验证时要注意什么",[18,3088,3089],{},"可以使用 JOL 查看对象布局：",[95,3091,3095],{"className":3092,"code":3093,"language":3094,"meta":101,"style":101},"language-xml shiki shiki-themes github-light github-dark","\u003Cdependency>\n \u003CgroupId>org.openjdk.jol\u003C\u002FgroupId>\n \u003CartifactId>jol-core\u003C\u002FartifactId>\n \u003Cversion>0.17\u003C\u002Fversion>\n\u003C\u002Fdependency>\n","xml",[22,3096,3097,3109,3124,3138,3152],{"__ignoreMap":101},[141,3098,3099,3102,3106],{"class":143,"line":144},[141,3100,3101],{"class":147},"\u003C",[141,3103,3105],{"class":3104},"s9eBZ","dependency",[141,3107,3108],{"class":147},">\n",[141,3110,3111,3114,3117,3120,3122],{"class":143,"line":165},[141,3112,3113],{"class":147}," \u003C",[141,3115,3116],{"class":3104},"groupId",[141,3118,3119],{"class":147},">org.openjdk.jol\u003C\u002F",[141,3121,3116],{"class":3104},[141,3123,3108],{"class":147},[141,3125,3126,3128,3131,3134,3136],{"class":143,"line":210},[141,3127,3113],{"class":147},[141,3129,3130],{"class":3104},"artifactId",[141,3132,3133],{"class":147},">jol-core\u003C\u002F",[141,3135,3130],{"class":3104},[141,3137,3108],{"class":147},[141,3139,3140,3142,3145,3148,3150],{"class":143,"line":219},[141,3141,3113],{"class":147},[141,3143,3144],{"class":3104},"version",[141,3146,3147],{"class":147},">0.17\u003C\u002F",[141,3149,3144],{"class":3104},[141,3151,3108],{"class":147},[141,3153,3154,3157,3159],{"class":143,"line":234},[141,3155,3156],{"class":147},"\u003C\u002F",[141,3158,3105],{"class":3104},[141,3160,3108],{"class":147},[18,3162,3163],{},"示例：",[95,3165,3167],{"className":135,"code":3166,"language":137,"meta":101,"style":101},"Object lock = new Object();\n\nSystem.out.println(ClassLayout.parseInstance(lock).toPrintable());\n\nsynchronized (lock) {\n System.out.println(ClassLayout.parseInstance(lock).toPrintable());\n}\n\nSystem.out.println(ClassLayout.parseInstance(lock).toPrintable());\n",[22,3168,3169,3183,3187,3210,3214,3221,3238,3242,3246],{"__ignoreMap":101},[141,3170,3171,3174,3176,3178,3181],{"class":143,"line":144},[141,3172,3173],{"class":147},"Object lock ",[141,3175,152],{"class":151},[141,3177,155],{"class":151},[141,3179,3180],{"class":158}," Object",[141,3182,162],{"class":147},[141,3184,3185],{"class":143,"line":165},[141,3186,207],{"emptyLinePlaceholder":206},[141,3188,3189,3192,3195,3198,3201,3204,3207],{"class":143,"line":210},[141,3190,3191],{"class":147},"System.out.",[141,3193,3194],{"class":158},"println",[141,3196,3197],{"class":147},"(ClassLayout.",[141,3199,3200],{"class":158},"parseInstance",[141,3202,3203],{"class":147},"(lock).",[141,3205,3206],{"class":158},"toPrintable",[141,3208,3209],{"class":147},"());\n",[141,3211,3212],{"class":143,"line":219},[141,3213,207],{"emptyLinePlaceholder":206},[141,3215,3216,3218],{"class":143,"line":234},[141,3217,1967],{"class":151},[141,3219,3220],{"class":147}," (lock) {\n",[141,3222,3223,3226,3228,3230,3232,3234,3236],{"class":143,"line":241},[141,3224,3225],{"class":147}," System.out.",[141,3227,3194],{"class":158},[141,3229,3197],{"class":147},[141,3231,3200],{"class":158},[141,3233,3203],{"class":147},[141,3235,3206],{"class":158},[141,3237,3209],{"class":147},[141,3239,3240],{"class":143,"line":247},[141,3241,250],{"class":147},[141,3243,3244],{"class":143,"line":307},[141,3245,207],{"emptyLinePlaceholder":206},[141,3247,3248,3250,3252,3254,3256,3258,3260],{"class":143,"line":379},[141,3249,3191],{"class":147},[141,3251,3194],{"class":158},[141,3253,3197],{"class":147},[141,3255,3200],{"class":158},[141,3257,3203],{"class":147},[141,3259,3206],{"class":158},[141,3261,3209],{"class":147},[18,3263,3264],{},"实验时要控制以下变量：",[114,3266,3267,3270,3276,3282,3285,3288],{},[117,3268,3269],{},"明确使用 JDK 8 HotSpot；",[117,3271,3272,3273,2159],{},"记录是否开启 ",[22,3274,3275],{},"UseBiasedLocking",[117,3277,3278,3279,2159],{},"记录 ",[22,3280,3281],{},"BiasedLockingStartupDelay",[117,3283,3284],{},"避免日志、调试器或工具意外计算 identity hash；",[117,3286,3287],{},"JOL 输出会受 32\u002F64 位、压缩指针和 GC 配置影响；",[117,3289,3290],{},"线程已经终止不代表任何场景都一定重偏向，仍要看 epoch 和撤销策略。",[18,3292,3293],{},"为了避免默认 4 秒延迟影响实验，可以显式设置：",[95,3295,3298],{"className":3296,"code":3297,"language":100,"meta":101},[98],"-XX:+UseBiasedLocking\n-XX:BiasedLockingStartupDelay=0\n",[22,3299,3297],{"__ignoreMap":101},[18,3301,3302],{},"关闭偏向锁、直接观察轻量级路径：",[95,3304,3307],{"className":3305,"code":3306,"language":100,"meta":101},[98],"-XX:-UseBiasedLocking\n",[22,3308,3306],{"__ignoreMap":101},[14,3310,3312],{"id":3311},"十九常见误区","十九、常见误区",[638,3314,3316],{"id":3315},"误区一新对象一定先是无锁再升级为偏向锁","误区一：新对象一定先是无锁，再升级为偏向锁",[18,3318,3319],{},"不准确。偏向能力启用后，支持偏向的类可以让新对象直接使用匿名偏向的 prototype header。",[638,3321,3323],{"id":3322},"误区二第二个线程出现就一定升级为重量级锁","误区二：第二个线程出现就一定升级为重量级锁",[18,3325,3326],{},"不准确。它可能触发重偏向、偏向撤销、轻量级锁，也可能在存在实际竞争时膨胀。",[638,3328,3330],{"id":3329},"误区三轻量级锁就是一直自旋","误区三：轻量级锁就是一直自旋",[18,3332,3333],{},"不准确。轻量级锁的核心是栈上 Lock Record 与对象头 CAS；自旋是竞争时可能采用的等待优化，不是轻量级锁的完整定义。",[638,3335,3337],{"id":3336},"误区四重量级锁完全由操作系统-mutex-等同实现","误区四：重量级锁完全由操作系统 Mutex 等同实现",[18,3339,3340],{},"过度简化。ObjectMonitor 是 HotSpot 的 JVM 级同步结构，内部会使用 CAS、自旋、队列、park\u002Funpark 等机制；线程最终阻塞和唤醒会依赖操作系统能力，但两者不能直接画等号。",[638,3342,3344],{"id":3343},"误区五锁一旦膨胀这个对象终身都是重量级锁","误区五：锁一旦膨胀，这个对象终身都是重量级锁",[18,3346,3347],{},"不准确。当前竞争阶段通常不会立即降级，但空闲 Monitor 后续可能由 JVM 在安全点执行 deflation。",[638,3349,3351],{"id":3350},"误区六这套流程适用于所有-jdk","误区六：这套流程适用于所有 JDK",[18,3353,3354],{},"不准确。本文讨论的是 JDK 8 HotSpot。偏向锁后来被默认禁用，现代 HotSpot 的锁实现也持续演进，因此理解具体机制时必须先限定版本。",[14,3356,3358],{"id":3357},"二十参考资料","二十、参考资料",[114,3360,3361,3368,3375,3382],{},[117,3362,3363],{},[73,3364,3367],{"href":3365,"rel":3366},"https:\u002F\u002Fgithub.com\u002Fopenjdk\u002Fjdk8u\u002Fblob\u002Fmaster\u002Fhotspot\u002Fsrc\u002Fshare\u002Fvm\u002Foops\u002FmarkOop.hpp",[1876],"JDK 8 HotSpot：markOop.hpp",[117,3369,3370],{},[73,3371,3374],{"href":3372,"rel":3373},"https:\u002F\u002Fgithub.com\u002Fopenjdk\u002Fjdk8u\u002Fblob\u002Fmaster\u002Fhotspot\u002Fsrc\u002Fshare\u002Fvm\u002Fruntime\u002Fsynchronizer.cpp",[1876],"JDK 8 HotSpot：synchronizer.cpp",[117,3376,3377],{},[73,3378,3381],{"href":3379,"rel":3380},"https:\u002F\u002Fgithub.com\u002Fopenjdk\u002Fjdk8u\u002Fblob\u002Fmaster\u002Fhotspot\u002Fsrc\u002Fshare\u002Fvm\u002Fruntime\u002FbiasedLocking.cpp",[1876],"JDK 8 HotSpot：biasedLocking.cpp",[117,3383,3384],{},[73,3385,3388],{"href":3386,"rel":3387},"https:\u002F\u002Fgithub.com\u002Fopenjdk\u002Fjdk8u\u002Fblob\u002Fmaster\u002Fhotspot\u002Fsrc\u002Fshare\u002Fvm\u002Fruntime\u002FobjectMonitor.hpp",[1876],"JDK 8 HotSpot：objectMonitor.hpp",[14,3390,3391],{"id":3391},"相关内容",[114,3393,3394],{},[117,3395,3396],{},[73,3397,3399],{"href":3398},"\u002Fwiki\u002Fjava\u002Fsynchronized-vs-reentrantlock\u002F","synchronized 和 ReentrantLock 的区别",[1907,3401,3402],{},"html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .s9eBZ, html code.shiki .s9eBZ{--shiki-default:#22863A;--shiki-dark:#85E89D}html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}",{"title":101,"searchDepth":165,"depth":165,"links":3404},[3405,3406,3407,3408,3412,3417,3421,3425,3430,3434,3437,3438,3439,3440,3441,3442,3443,3444,3449,3450,3458,3459],{"id":1961,"depth":165,"text":1962},{"id":69,"depth":165,"text":69},{"id":2024,"depth":165,"text":2025},{"id":2106,"depth":165,"text":2107,"children":3409},[3410,3411],{"id":2142,"depth":210,"text":2143},{"id":2309,"depth":210,"text":2310},{"id":2371,"depth":165,"text":2372,"children":3413},[3414,3415,3416],{"id":2378,"depth":210,"text":2378},{"id":2384,"depth":210,"text":2385},{"id":2391,"depth":210,"text":2391},{"id":2409,"depth":165,"text":2410,"children":3418},[3419,3420],{"id":2425,"depth":210,"text":2425},{"id":2440,"depth":210,"text":2440},{"id":2467,"depth":165,"text":2468,"children":3422},[3423,3424],{"id":2505,"depth":210,"text":2505},{"id":2520,"depth":210,"text":2520},{"id":2526,"depth":165,"text":2527,"children":3426},[3427,3428,3429],{"id":2536,"depth":210,"text":2537},{"id":2543,"depth":210,"text":2544},{"id":2550,"depth":210,"text":2551},{"id":2565,"depth":165,"text":2566,"children":3431},[3432,3433],{"id":2331,"depth":210,"text":2331},{"id":2586,"depth":210,"text":2586},{"id":2595,"depth":165,"text":2596,"children":3435},[3436],{"id":2643,"depth":210,"text":2644},{"id":2650,"depth":165,"text":2651},{"id":2675,"depth":165,"text":2676},{"id":2703,"depth":165,"text":2704},{"id":2745,"depth":165,"text":2746},{"id":2794,"depth":165,"text":2795},{"id":2830,"depth":165,"text":2831},{"id":2865,"depth":165,"text":2866},{"id":3045,"depth":165,"text":3046,"children":3445},[3446,3447,3448],{"id":3049,"depth":210,"text":3050},{"id":3059,"depth":210,"text":3060},{"id":3075,"depth":210,"text":3076},{"id":3085,"depth":165,"text":3086},{"id":3311,"depth":165,"text":3312,"children":3451},[3452,3453,3454,3455,3456,3457],{"id":3315,"depth":210,"text":3316},{"id":3322,"depth":210,"text":3323},{"id":3329,"depth":210,"text":3330},{"id":3336,"depth":210,"text":3337},{"id":3343,"depth":210,"text":3344},{"id":3350,"depth":210,"text":3351},{"id":3357,"depth":165,"text":3358},{"id":3391,"depth":165,"text":3391},"wiki:java:jdk8-synchronized-lock-states","从 Mark Word、Lock Record 与 ObjectMonitor 出发，系统理解 JDK 8 HotSpot 中偏向锁、轻量级锁、重量级锁的获取、撤销、膨胀和释放过程。","advanced",{},35,"\u002Fjava\u002Fjdk8-synchronized-lock-states","并发编程",{"title":1956,"description":3461},"java\u002Fjdk8-synchronized-lock-states","2026-07-23","pzK2g0rnXBsTfHk45mk4P4Dlca-bkRaWaNMeJy8yZRA",{"id":3472,"title":3399,"body":3473,"commentId":4380,"description":4381,"difficulty":4382,"draft":1943,"extension":1944,"meta":4383,"navigation":206,"order":4384,"path":4385,"section":1948,"seo":4386,"stem":4387,"updated":4388,"__hash__":4389},"java\u002Fjava\u002Fsynchronized-vs-reentrantlock.md",{"type":7,"value":3474,"toc":4358},[3475,3478,3481,3486,3489,3496,3498,3507,3509,3517,3527,3531,3533,3539,3542,3548,3551,3554,3560,3567,3570,3574,3727,3729,3733,3736,3741,3744,3750,3753,3756,3762,3765,3767,3771,3777,3780,3783,3789,3792,3797,3799,3803,3806,3809,3815,3818,3821,3827,3830,3836,3838,3844,3847,3849,3853,3856,3862,3865,3871,3876,3879,3881,3885,3890,3893,3899,3905,3911,3914,3920,3923,3929,3932,3938,3941,3947,3950,3956,3959,3961,3965,3968,3971,3977,3980,3986,3989,3992,3995,4001,4004,4007,4013,4016,4022,4029,4031,4035,4040,4046,4049,4052,4058,4065,4071,4074,4080,4083,4085,4089,4092,4095,4111,4114,4119,4122,4124,4128,4131,4151,4153,4159,4162,4167,4169,4173,4175,4201,4204,4210,4213,4215,4219,4264,4267,4272,4279,4285,4288,4290,4294,4298,4301,4305,4308,4312,4315,4323,4327,4330,4334,4337,4340,4346,4348,4351],[18,3476,3477],{},"synchronized和reentrantLock的区别？",[10,3479,3480],{"id":3480},"面试标准回答",[59,3482,3483],{},[18,3484,3485],{},"synchronized 是 JVM 层面的内置锁，语法简单，进入同步块后自动加锁，退出时自动释放，支持可重入和内存可见性。ReentrantLock 是基于 AQS 实现的显式锁，同样支持可重入，但提供了公平锁、可响应中断获取锁、tryLock、超时获取以及多个 Condition 等高级能力。两者在现代 JDK 中性能差距通常不是主要选型依据；功能简单时优先 synchronized，需要精细控制时使用 ReentrantLock，并且必须在 finally 中释放锁。",[18,3487,3488],{},"一句话记忆：",[59,3490,3491],{},[18,3492,3493],{},[64,3494,3495],{},"synchronized 简单自动，ReentrantLock 灵活可控。",[14,3497,69],{"id":69},[18,3499,3500],{},[73,3501,3504],{"href":3502,"target":76,"rel":3503},"\u002Fimages\u002Fwiki\u002Fjava\u002Fsynchronized-vs-reentrantlock.svg",[78,79],[81,3505],{"src":3502,"alt":3506},"synchronized 与 ReentrantLock 核心差异和选型建议",[10,3508,86],{"id":86},[18,3510,3511,2818,3513,3516],{},[22,3512,1967],{},[22,3514,3515],{},"ReentrantLock"," 都能实现互斥和可见性，但定位不同：",[59,3518,3519],{},[18,3520,3521,3523,3524,3526],{},[22,3522,1967],{}," 是 JVM 原生关键字，语法简单；",[22,3525,3515],{}," 是 JUC 提供的显式锁，功能更丰富、控制能力更强。",[14,3528,3530],{"id":3529},"一基本用法","一、基本用法",[638,3532,1967],{"id":1967},[95,3534,3537],{"className":3535,"code":3536,"language":100},[98],"synchronized (lock) {\n \u002F\u002F 临界区\n}\n",[22,3538,3536],{"__ignoreMap":101},[18,3540,3541],{},"或者：",[95,3543,3546],{"className":3544,"code":3545,"language":100},[98],"public synchronized void method() {\n}\n",[22,3547,3545],{"__ignoreMap":101},[18,3549,3550],{},"锁会自动释放。",[638,3552,3515],{"id":3553},"reentrantlock",[95,3555,3558],{"className":3556,"code":3557,"language":100},[98],"ReentrantLock lock = new ReentrantLock();\n\nlock.lock();\ntry {\n \u002F\u002F 临界区\n} finally {\n lock.unlock();\n}\n",[22,3559,3557],{"__ignoreMap":101},[18,3561,3562,3563,3566],{},"必须手动释放，所以通常必须写在 ",[22,3564,3565],{},"finally"," 中。",[3568,3569],"hr",{},[14,3571,3573],{"id":3572},"二核心区别","二、核心区别",[1309,3575,3576,3587],{},[1312,3577,3578],{},[1315,3579,3580,3583,3585],{},[1318,3581,3582],{},"对比项",[1318,3584,1967],{},[1318,3586,3515],{},[1328,3588,3589,3600,3611,3621,3631,3644,3656,3668,3679,3694,3705,3716],{},[1315,3590,3591,3594,3597],{},[1333,3592,3593],{},"实现层次",[1333,3595,3596],{},"JVM 关键字、Monitor",[1333,3598,3599],{},"Java 类，基于 AQS",[1315,3601,3602,3605,3608],{},[1333,3603,3604],{},"加锁释放",[1333,3606,3607],{},"自动",[1333,3609,3610],{},"手动",[1315,3612,3613,3616,3619],{},[1333,3614,3615],{},"可重入",[1333,3617,3618],{},"支持",[1333,3620,3618],{},[1315,3622,3623,3626,3629],{},[1333,3624,3625],{},"公平锁",[1333,3627,3628],{},"不支持显式配置",[1333,3630,3618],{},[1315,3632,3633,3636,3639],{},[1333,3634,3635],{},"可中断获取锁",[1333,3637,3638],{},"不支持",[1333,3640,3641],{},[22,3642,3643],{},"lockInterruptibly()",[1315,3645,3646,3649,3651],{},[1333,3647,3648],{},"尝试获取锁",[1333,3650,3638],{},[1333,3652,3653],{},[22,3654,3655],{},"tryLock()",[1315,3657,3658,3661,3663],{},[1333,3659,3660],{},"超时获取锁",[1333,3662,3638],{},[1333,3664,3665],{},[22,3666,3667],{},"tryLock(timeout, unit)",[1315,3669,3670,3673,3676],{},[1333,3671,3672],{},"条件队列",[1333,3674,3675],{},"一个 Monitor WaitSet",[1333,3677,3678],{},"可创建多个 Condition",[1315,3680,3681,3684,3689],{},[1333,3682,3683],{},"等待通知",[1333,3685,3686],{},[22,3687,3688],{},"wait\u002Fnotify\u002FnotifyAll",[1333,3690,3691],{},[22,3692,3693],{},"await\u002Fsignal\u002FsignalAll",[1315,3695,3696,3699,3702],{},[1333,3697,3698],{},"锁状态查询",[1333,3700,3701],{},"能力有限",[1333,3703,3704],{},"提供较多查询方法",[1315,3706,3707,3710,3713],{},[1333,3708,3709],{},"编码复杂度",[1333,3711,3712],{},"低",[1333,3714,3715],{},"较高",[1315,3717,3718,3721,3724],{},[1333,3719,3720],{},"异常释放",[1333,3722,3723],{},"自动释放",[1333,3725,3726],{},"必须 finally unlock",[3568,3728],{},[10,3730,3732],{"id":3731},"三两者都支持可重入","三、两者都支持可重入",[18,3734,3735],{},"可重入指：",[59,3737,3738],{},[18,3739,3740],{},"同一个线程已经持有锁时，可以再次获取同一把锁。",[638,3742,1967],{"id":3743},"synchronized-1",[95,3745,3748],{"className":3746,"code":3747,"language":100},[98],"public synchronized void methodA() {\n methodB();\n}\n\npublic synchronized void methodB() {\n}\n",[22,3749,3747],{"__ignoreMap":101},[18,3751,3752],{},"同一个对象上的两个同步方法，线程可以重入。",[638,3754,3515],{"id":3755},"reentrantlock-1",[95,3757,3760],{"className":3758,"code":3759,"language":100},[98],"lock.lock();\ntry {\n lock.lock();\n try {\n \u002F\u002F 重入\n } finally {\n lock.unlock();\n }\n} finally {\n lock.unlock();\n}\n",[22,3761,3759],{"__ignoreMap":101},[18,3763,3764],{},"获取几次，就必须释放几次。",[3568,3766],{},[10,3768,3770],{"id":3769},"四reentrantlock-支持公平锁","四、ReentrantLock 支持公平锁",[95,3772,3775],{"className":3773,"code":3774,"language":100},[98],"ReentrantLock fairLock = new ReentrantLock(true);\n",[22,3776,3774],{"__ignoreMap":101},[18,3778,3779],{},"公平锁会尽量按 AQS 队列顺序获取锁。",[18,3781,3782],{},"默认是非公平锁：",[95,3784,3787],{"className":3785,"code":3786,"language":100},[98],"ReentrantLock lock = new ReentrantLock();\n",[22,3788,3786],{"__ignoreMap":101},[18,3790,3791],{},"非公平锁允许新线程插队，吞吐量通常更高。",[18,3793,3794,3796],{},[22,3795,1967],{}," 没有 API 让你指定公平性，通常按非公平竞争理解。",[3568,3798],{},[10,3800,3802],{"id":3801},"五reentrantlock-支持可响应中断等待","五、ReentrantLock 支持可响应中断等待",[18,3804,3805],{},"假设线程正在等待锁。",[18,3807,3808],{},"使用：",[95,3810,3813],{"className":3811,"code":3812,"language":100},[98],"lock.lock();\n",[22,3814,3812],{"__ignoreMap":101},[18,3816,3817],{},"即使线程被中断，也不会因为中断立即退出获取锁过程。",[18,3819,3820],{},"而：",[95,3822,3825],{"className":3823,"code":3824,"language":100},[98],"lock.lockInterruptibly();\n",[22,3826,3824],{"__ignoreMap":101},[18,3828,3829],{},"等待期间如果收到中断，会抛出：",[95,3831,3834],{"className":3832,"code":3833,"language":100},[98],"InterruptedException\n",[22,3835,3833],{"__ignoreMap":101},[18,3837,1398],{},[95,3839,3842],{"className":3840,"code":3841,"language":100},[98],"try {\n lock.lockInterruptibly();\n try {\n doWork();\n } finally {\n lock.unlock();\n }\n} catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n}\n",[22,3843,3841],{"__ignoreMap":101},[18,3845,3846],{},"这对于避免线程长时间死等、响应取消请求很有价值。",[3568,3848],{},[10,3850,3852],{"id":3851},"六reentrantlock-支持尝试获取和超时","六、ReentrantLock 支持尝试获取和超时",[638,3854,3855],{"id":3855},"立即尝试",[95,3857,3860],{"className":3858,"code":3859,"language":100},[98],"if (lock.tryLock()) {\n try {\n doWork();\n } finally {\n lock.unlock();\n }\n} else {\n \u002F\u002F 获取失败，走降级逻辑\n}\n",[22,3861,3859],{"__ignoreMap":101},[638,3863,3864],{"id":3864},"超时尝试",[95,3866,3869],{"className":3867,"code":3868,"language":100},[98],"if (lock.tryLock(2, TimeUnit.SECONDS)) {\n try {\n doWork();\n } finally {\n lock.unlock();\n }\n} else {\n \u002F\u002F 两秒内未拿到锁\n}\n",[22,3870,3868],{"__ignoreMap":101},[18,3872,3873,3875],{},[22,3874,1967],{}," 一旦进入竞争，只能等待，无法直接设置超时。",[18,3877,3878],{},"这也是 ReentrantLock 在需要降级、超时控制时的重要优势。",[3568,3880],{},[10,3882,3884],{"id":3883},"七condition-比-waitnotify-更灵活","七、Condition 比 wait\u002Fnotify 更灵活",[18,3886,3887,3889],{},[22,3888,1967],{}," 的一个 Monitor 只有一个 WaitSet。",[18,3891,3892],{},"例如阻塞队列里：",[95,3894,3897],{"className":3895,"code":3896,"language":100},[98],"生产者等待 notFull\n消费者等待 notEmpty\n",[22,3898,3896],{"__ignoreMap":101},[18,3900,3901,3902,3904],{},"使用 ",[22,3903,1967],{}," 时，生产者和消费者都在同一个 WaitSet 中，通常要：",[95,3906,3909],{"className":3907,"code":3908,"language":100},[98],"notifyAll();\n",[22,3910,3908],{"__ignoreMap":101},[18,3912,3913],{},"而 ReentrantLock 可以创建多个 Condition：",[95,3915,3918],{"className":3916,"code":3917,"language":100},[98],"Condition notFull = lock.newCondition();\nCondition notEmpty = lock.newCondition();\n",[22,3919,3917],{"__ignoreMap":101},[18,3921,3922],{},"生产者等待：",[95,3924,3927],{"className":3925,"code":3926,"language":100},[98],"while (queue.size() == capacity) {\n notFull.await();\n}\n",[22,3928,3926],{"__ignoreMap":101},[18,3930,3931],{},"消费者等待：",[95,3933,3936],{"className":3934,"code":3935,"language":100},[98],"while (queue.isEmpty()) {\n notEmpty.await();\n}\n",[22,3937,3935],{"__ignoreMap":101},[18,3939,3940],{},"生产完成：",[95,3942,3945],{"className":3943,"code":3944,"language":100},[98],"notEmpty.signal();\n",[22,3946,3944],{"__ignoreMap":101},[18,3948,3949],{},"消费完成：",[95,3951,3954],{"className":3952,"code":3953,"language":100},[98],"notFull.signal();\n",[22,3955,3953],{"__ignoreMap":101},[18,3957,3958],{},"这样可以精确唤醒，减少无效唤醒。",[3568,3960],{},[10,3962,3964],{"id":3963},"八底层实现不同","八、底层实现不同",[14,3966,1967],{"id":3967},"synchronized-2",[18,3969,3970],{},"经典理解：",[95,3972,3975],{"className":3973,"code":3974,"language":100},[98],"对象头 Mark Word\n+\nMonitor\n+\nJVM 锁优化\n",[22,3976,3974],{"__ignoreMap":101},[18,3978,3979],{},"JDK 8 中可能经历：",[95,3981,3984],{"className":3982,"code":3983,"language":100},[98],"偏向锁\n→ 轻量级锁\n→ 重量级锁\n",[22,3985,3983],{"__ignoreMap":101},[18,3987,3988],{},"这是 HotSpot 的 JVM 实现优化。",[14,3990,3515],{"id":3991},"reentrantlock-2",[18,3993,3994],{},"主要基于：",[95,3996,3999],{"className":3997,"code":3998,"language":100},[98],"AbstractQueuedSynchronizer\n",[22,4000,3998],{"__ignoreMap":101},[18,4002,4003],{},"也就是 AQS。",[18,4005,4006],{},"核心状态：",[95,4008,4011],{"className":4009,"code":4010,"language":100},[98],"volatile int state;\n",[22,4012,4010],{"__ignoreMap":101},[18,4014,4015],{},"独占锁时：",[95,4017,4020],{"className":4018,"code":4019,"language":100},[98],"state = 0 未加锁\nstate = 1 第一次获取\nstate > 1 重入次数\n",[22,4021,4019],{"__ignoreMap":101},[18,4023,4024,4025,4028],{},"竞争失败的线程进入 CLH 变体同步队列，并通过 ",[22,4026,4027],{},"park\u002Funpark"," 等待和唤醒。",[3568,4030],{},[10,4032,4034],{"id":4033},"九异常情况下的差异","九、异常情况下的差异",[18,4036,4037,4039],{},[22,4038,1967],{},"：",[95,4041,4044],{"className":4042,"code":4043,"language":100},[98],"synchronized (lock) {\n throw new RuntimeException();\n}\n",[22,4045,4043],{"__ignoreMap":101},[18,4047,4048],{},"离开同步块时，JVM 自动释放锁。",[18,4050,4051],{},"ReentrantLock：",[95,4053,4056],{"className":4054,"code":4055,"language":100},[98],"lock.lock();\ndoWork();\nlock.unlock();\n",[22,4057,4055],{"__ignoreMap":101},[18,4059,4060,4061,4064],{},"如果 ",[22,4062,4063],{},"doWork()"," 抛异常：",[95,4066,4069],{"className":4067,"code":4068,"language":100},[98],"unlock 没执行\n→ 锁永久未释放\n",[22,4070,4068],{"__ignoreMap":101},[18,4072,4073],{},"所以必须写：",[95,4075,4078],{"className":4076,"code":4077,"language":100},[98],"lock.lock();\ntry {\n doWork();\n} finally {\n lock.unlock();\n}\n",[22,4079,4077],{"__ignoreMap":101},[18,4081,4082],{},"这是 ReentrantLock 最常见的编码风险。",[3568,4084],{},[10,4086,4088],{"id":4087},"十性能区别","十、性能区别",[18,4090,4091],{},"早期 JDK 中，ReentrantLock 性能常常明显优于 synchronized。",[18,4093,4094],{},"但 JDK 6 以后，JVM 对 synchronized 做了大量优化：",[114,4096,4097,4100,4102,4105,4108],{},[117,4098,4099],{},"偏向锁",[117,4101,2240],{},[117,4103,4104],{},"自旋",[117,4106,4107],{},"锁消除",[117,4109,4110],{},"锁粗化",[18,4112,4113],{},"现代 JDK 中：",[59,4115,4116],{},[18,4117,4118],{},"两者性能差异通常不是选型的首要依据。",[18,4120,4121],{},"应该根据功能需求选择，而不是简单认为 ReentrantLock 一定更快。",[3568,4123],{},[10,4125,4127],{"id":4126},"十一什么时候使用-synchronized","十一、什么时候使用 synchronized",[18,4129,4130],{},"适合：",[114,4132,4133,4136,4139,4142,4145,4148],{},[117,4134,4135],{},"临界区简单",[117,4137,4138],{},"不需要公平锁",[117,4140,4141],{},"不需要超时获取",[117,4143,4144],{},"不需要中断锁等待",[117,4146,4147],{},"只有一个等待条件",[117,4149,4150],{},"希望代码简单、自动释放锁",[18,4152,1398],{},[95,4154,4157],{"className":4155,"code":4156,"language":100},[98],"public synchronized void increment() {\n count++;\n}\n",[22,4158,4156],{"__ignoreMap":101},[18,4160,4161],{},"一般优先原则：",[59,4163,4164],{},[18,4165,4166],{},"能用 synchronized 清晰表达时，优先用 synchronized。",[3568,4168],{},[10,4170,4172],{"id":4171},"十二什么时候使用-reentrantlock","十二、什么时候使用 ReentrantLock",[18,4174,4130],{},[114,4176,4177,4180,4186,4189,4192,4195,4198],{},[117,4178,4179],{},"需要公平锁",[117,4181,4182,4183],{},"需要 ",[22,4184,4185],{},"tryLock",[117,4187,4188],{},"需要超时获取锁",[117,4190,4191],{},"需要可中断等待",[117,4193,4194],{},"需要多个 Condition",[117,4196,4197],{},"需要查询等待队列、持锁状态",[117,4199,4200],{},"需要更精细的锁控制",[18,4202,4203],{},"例如转账时避免死锁：",[95,4205,4208],{"className":4206,"code":4207,"language":100},[98],"if (accountA.lock.tryLock(100, TimeUnit.MILLISECONDS)) {\n try {\n if (accountB.lock.tryLock(100, TimeUnit.MILLISECONDS)) {\n try {\n transfer();\n } finally {\n accountB.lock.unlock();\n }\n }\n } finally {\n accountA.lock.unlock();\n }\n}\n",[22,4209,4207],{"__ignoreMap":101},[18,4211,4212],{},"使用 synchronized 很难实现这种超时退避。",[3568,4214],{},[10,4216,4218],{"id":4217},"十三waitnotify-和-awaitsignal-对应关系","十三、wait\u002Fnotify 和 await\u002Fsignal 对应关系",[1309,4220,4221,4229],{},[1312,4222,4223],{},[1315,4224,4225,4227],{},[1318,4226,1967],{},[1318,4228,3515],{},[1328,4230,4231,4242,4253],{},[1315,4232,4233,4237],{},[1333,4234,4235],{},[22,4236,2397],{},[1333,4238,4239],{},[22,4240,4241],{},"Condition.await()",[1315,4243,4244,4248],{},[1333,4245,4246],{},[22,4247,2817],{},[1333,4249,4250],{},[22,4251,4252],{},"Condition.signal()",[1315,4254,4255,4259],{},[1333,4256,4257],{},[22,4258,2821],{},[1333,4260,4261],{},[22,4262,4263],{},"Condition.signalAll()",[18,4265,4266],{},"两者都要求：",[59,4268,4269],{},[18,4270,4271],{},"调用等待或通知方法前，必须先持有对应的锁。",[18,4273,4274,4275,4278],{},"并且等待都应该放在 ",[22,4276,4277],{},"while"," 中：",[95,4280,4283],{"className":4281,"code":4282,"language":100},[98],"while (!conditionSatisfied()) {\n condition.await();\n}\n",[22,4284,4282],{"__ignoreMap":101},[18,4286,4287],{},"防止虚假唤醒和竞争后条件失效。",[3568,4289],{},[10,4291,4293],{"id":4292},"十四常见误区","十四、常见误区",[638,4295,4297],{"id":4296},"误区一reentrantlock-才支持可重入","误区一：ReentrantLock 才支持可重入",[18,4299,4300],{},"不对。两者都可重入。",[638,4302,4304],{"id":4303},"误区二reentrantlock-一定比-synchronized-快","误区二：ReentrantLock 一定比 synchronized 快",[18,4306,4307],{},"不对。现代 JVM 下要看场景，功能差异比纯性能更重要。",[638,4309,4311],{"id":4310},"误区三synchronized-会自动释放reentrantlock-不会","误区三：synchronized 会自动释放，ReentrantLock 不会",[18,4313,4314],{},"更准确地说：",[114,4316,4317,4320],{},[117,4318,4319],{},"synchronized 离开同步块时自动释放",[117,4321,4322],{},"ReentrantLock 必须显式 unlock",[638,4324,4326],{"id":4325},"误区四公平锁一定更好","误区四：公平锁一定更好",[18,4328,4329],{},"公平锁吞吐量通常更低，只在有明确公平性需求时使用。",[638,4331,4333],{"id":4332},"误区五trylock-失败后可以直接-unlock","误区五：tryLock 失败后可以直接 unlock",[18,4335,4336],{},"不可以。只有成功获取锁后才能释放。",[18,4338,4339],{},"正确写法：",[95,4341,4344],{"className":4342,"code":4343,"language":100},[98],"boolean locked = false;\ntry {\n locked = lock.tryLock();\n if (!locked) {\n return;\n }\n\n doWork();\n} finally {\n if (locked) {\n lock.unlock();\n }\n}\n",[22,4345,4343],{"__ignoreMap":101},[3568,4347],{},[14,4349,4350],{"id":4350},"相关主题",[114,4352,4353],{},[117,4354,4355],{},[73,4356,1956],{"href":4357},"\u002Fwiki\u002Fjava\u002Fjdk8-synchronized-lock-states\u002F",{"title":101,"searchDepth":165,"depth":165,"links":4359},[4360,4361,4365,4371,4372,4379],{"id":69,"depth":165,"text":69},{"id":3529,"depth":165,"text":3530,"children":4362},[4363,4364],{"id":1967,"depth":210,"text":1967},{"id":3553,"depth":210,"text":3515},{"id":3572,"depth":165,"text":3573,"children":4366},[4367,4368,4369,4370],{"id":3743,"depth":210,"text":1967},{"id":3755,"depth":210,"text":3515},{"id":3855,"depth":210,"text":3855},{"id":3864,"depth":210,"text":3864},{"id":3967,"depth":165,"text":1967},{"id":3991,"depth":165,"text":3515,"children":4373},[4374,4375,4376,4377,4378],{"id":4296,"depth":210,"text":4297},{"id":4303,"depth":210,"text":4304},{"id":4310,"depth":210,"text":4311},{"id":4325,"depth":210,"text":4326},{"id":4332,"depth":210,"text":4333},{"id":4350,"depth":165,"text":4350},"wiki:java:synchronized-vs-reentrantlock","对比 synchronized 与 ReentrantLock 的实现、可重入、公平锁、中断、超时、Condition 和适用场景。","intermediate",{},71,"\u002Fjava\u002Fsynchronized-vs-reentrantlock",{"title":3399,"description":4381},"java\u002Fsynchronized-vs-reentrantlock","2026-07-21","HvwBdM7dDk9OpIeOwtk34xX3bS9W_vivGkHtOntEom0",{"id":4391,"title":4392,"body":4393,"commentId":5691,"description":5692,"difficulty":3462,"draft":1943,"extension":1944,"meta":5693,"navigation":206,"order":5694,"path":5695,"section":1948,"seo":5696,"stem":5697,"updated":5698,"__hash__":5699},"java\u002Fjava\u002Fkafka-message-loss-prevention.md","Kafka 如何保证消息不丢失",{"type":7,"value":4394,"toc":5646},[4395,4398,4400,4417,4419,4426,4428,4437,4439,4442,4449,4452,4456,4459,4473,4476,4480,4486,4493,4548,4551,4565,4574,4578,4581,4624,4627,4630,4643,4647,4650,4666,4673,4730,4736,4740,4743,4749,4752,4755,4761,4764,4768,4772,4775,4781,4784,4787,4791,4794,4797,4803,4806,4812,4817,4823,4826,4832,4835,4840,4843,4847,4860,4866,4869,4879,4882,4888,4898,4903,4906,4910,4914,4926,4929,4935,4938,4942,4945,4951,4954,5064,5067,5071,5074,5080,5083,5100,5107,5111,5114,5120,5123,5136,5139,5142,5146,5149,5155,5159,5162,5165,5171,5174,5177,5197,5204,5207,5213,5219,5223,5226,5228,5234,5240,5243,5257,5261,5332,5335,5342,5346,5396,5399,5406,5409,5413,5523,5527,5534,5542,5546,5552,5556,5559,5563,5566,5570,5573,5577,5580,5600,5603,5606,5643],[10,4396,4392],{"id":4397},"kafka-如何保证消息不丢失",[14,4399,16],{"id":16},[59,4401,4402],{},[18,4403,4404,4405,4408,4409,4412,4413,4416],{},"Kafka 保证消息不丢失需要覆盖生产者、Broker 和消费者三段链路。生产者侧使用 ",[22,4406,4407],{},"acks=all","、开启重试和幂等生产，并检查发送回调，对最终失败进行落库、告警或补偿；Broker 侧通常设置三副本、",[22,4410,4411],{},"min.insync.replicas=2","，并关闭非同步副本选举，即配置 ",[22,4414,4415],{},"unclean.leader.election.enable=false","，保证消息在足够多的同步副本写入后才确认成功；消费者侧关闭自动提交，在业务处理成功后再提交 Offset，失败时不提交以便重新消费。这样通常实现至少一次投递，所以消费端还必须通过事件 ID、唯一索引或状态机保证幂等。涉及数据库与 Kafka 的一致性时，可以使用 Transactional Outbox；消费端需要应对重复消息时，可以使用 Inbox。Kafka 的消息不丢失是端到端保障，不是只配置一个参数。",[18,4418,57],{},[59,4420,4421],{},[18,4422,4423],{},[64,4424,4425],{},"生产者确认成功，Broker 多副本可靠保存，消费者处理成功后提交，业务端用幂等和补偿兜底。",[14,4427,69],{"id":69},[18,4429,4430],{},[73,4431,4434],{"href":4432,"target":76,"rel":4433},"\u002Fimages\u002Fwiki\u002Fjava\u002Fkafka-message-loss-prevention.svg",[78,79],[81,4435],{"src":4432,"alt":4436},"Kafka 消息不丢失的端到端保障链路",[14,4438,86],{"id":86},[18,4440,4441],{},"Kafka 消息不丢失不是靠某一个参数实现的，而是一个端到端问题：",[59,4443,4444],{},[18,4445,4446],{},[64,4447,4448],{},"生产者必须确认消息发送成功，Broker 必须把消息可靠地保存在足够多的副本中，消费者必须在业务处理成功后再提交 Offset。",[18,4450,4451],{},"其中任何一个环节处理不当，都可能出现“业务上看起来消息丢了”的情况。",[14,4453,4455],{"id":4454},"一先明确什么叫消息丢失","一、先明确什么叫“消息丢失”",[18,4457,4458],{},"常见的丢失场景主要有四类：",[2489,4460,4461,4464,4467,4470],{},[117,4462,4463],{},"生产者调用发送方法后没有检查结果，实际发送失败却被业务忽略。",[117,4465,4466],{},"Leader 收到消息后就返回成功，消息还未复制到 Follower，Leader 随后故障。",[117,4468,4469],{},"消费者先提交 Offset，再执行业务；业务处理失败后，消息不会再次投递。",[117,4471,4472],{},"Kafka 中的消息没有丢，但写数据库、调用下游等业务操作失败，又没有补偿机制。",[18,4474,4475],{},"因此，Kafka 中仍能查到消息，不代表业务一定处理成功；反过来，业务没有结果，也不一定是 Broker 丢了消息。",[14,4477,4479],{"id":4478},"二生产者如何避免丢消息","二、生产者如何避免丢消息",[638,4481,4483,4484],{"id":4482},"_1-使用-acksall","1. 使用 ",[22,4485,4407],{},[18,4487,4488,4489,4492],{},"生产者的 ",[22,4490,4491],{},"acks"," 决定 Broker 在什么条件下确认发送成功：",[1309,4494,4495,4508],{},[1312,4496,4497],{},[1315,4498,4499,4502,4505],{},[1318,4500,4501],{},"配置",[1318,4503,4504],{},"确认时机",[1318,4506,4507],{},"风险",[1328,4509,4510,4523,4536],{},[1315,4511,4512,4517,4520],{},[1333,4513,4514],{},[22,4515,4516],{},"acks=0",[1333,4518,4519],{},"不等待 Broker 响应",[1333,4521,4522],{},"发送失败也无法感知，风险最高",[1315,4524,4525,4530,4533],{},[1333,4526,4527],{},[22,4528,4529],{},"acks=1",[1333,4531,4532],{},"Leader 写入本地日志后返回",[1333,4534,4535],{},"Leader 故障且副本尚未同步时可能丢失",[1315,4537,4538,4542,4545],{},[1333,4539,4540],{},[22,4541,4407],{},[1333,4543,4544],{},"当前 ISR 中的副本都确认后返回",[1333,4546,4547],{},"Kafka 能提供的最强生产者确认保证",[18,4549,4550],{},"关键配置：",[95,4552,4556],{"className":4553,"code":4554,"language":4555,"meta":101,"style":101},"language-properties shiki shiki-themes github-light github-dark","acks=all\n","properties",[22,4557,4558],{"__ignoreMap":101},[141,4559,4560,4562],{"class":143,"line":144},[141,4561,4491],{"class":151},[141,4563,4564],{"class":147},"=all\n",[18,4566,4567,4569,4570,4573],{},[22,4568,4407],{}," 并不等于绝对不丢。它还需要与副本数和 ",[22,4571,4572],{},"min.insync.replicas"," 配合，否则 ISR 中只剩 Leader 一个副本时，依然可能成功写入。",[638,4575,4577],{"id":4576},"_2-开启重试和幂等生产","2. 开启重试和幂等生产",[18,4579,4580],{},"网络抖动、Leader 切换等临时故障可能导致发送失败，生产者需要允许重试：",[95,4582,4584],{"className":4553,"code":4583,"language":4555,"meta":101,"style":101},"enable.idempotence=true\nacks=all\nretries=2147483647\nmax.in.flight.requests.per.connection=5\ndelivery.timeout.ms=120000\n",[22,4585,4586,4594,4600,4608,4616],{"__ignoreMap":101},[141,4587,4588,4591],{"class":143,"line":144},[141,4589,4590],{"class":151},"enable.idempotence",[141,4592,4593],{"class":147},"=true\n",[141,4595,4596,4598],{"class":143,"line":165},[141,4597,4491],{"class":151},[141,4599,4564],{"class":147},[141,4601,4602,4605],{"class":143,"line":210},[141,4603,4604],{"class":151},"retries",[141,4606,4607],{"class":147},"=2147483647\n",[141,4609,4610,4613],{"class":143,"line":219},[141,4611,4612],{"class":151},"max.in.flight.requests.per.connection",[141,4614,4615],{"class":147},"=5\n",[141,4617,4618,4621],{"class":143,"line":234},[141,4619,4620],{"class":151},"delivery.timeout.ms",[141,4622,4623],{"class":147},"=120000\n",[18,4625,4626],{},"幂等生产者会给消息附加 Producer ID 和序列号，使 Broker 能识别同一生产会话内的重复写入，避免因重试产生重复消息。",[18,4628,4629],{},"需要注意：",[114,4631,4632,4635,4640],{},[117,4633,4634],{},"幂等生产解决的是重试导致的重复写入，不是发送失败后的业务补偿。",[117,4636,4637,4639],{},[22,4638,4620],{}," 到期后，生产者仍可能最终失败。",[117,4641,4642],{},"业务不能无限依赖客户端重试，最终失败必须记录、告警或进入补偿流程。",[638,4644,4646],{"id":4645},"_3-必须检查发送结果","3. 必须检查发送结果",[18,4648,4649],{},"下面这种“只发送、不处理结果”的写法存在风险：",[95,4651,4653],{"className":135,"code":4652,"language":137,"meta":101,"style":101},"producer.send(record);\n",[22,4654,4655],{"__ignoreMap":101},[141,4656,4657,4660,4663],{"class":143,"line":144},[141,4658,4659],{"class":147},"producer.",[141,4661,4662],{"class":158},"send",[141,4664,4665],{"class":147},"(record);\n",[18,4667,4668,4669,4672],{},"应该检查回调或 ",[22,4670,4671],{},"Future"," 的执行结果：",[95,4674,4676],{"className":135,"code":4675,"language":137,"meta":101,"style":101},"producer.send(record, (metadata, exception) -> {\n if (exception != null) {\n \u002F\u002F 记录原始消息、告警并进入补偿流程\n handleSendFailure(record, exception);\n }\n});\n",[22,4677,4678,4692,4708,4713,4721,4725],{"__ignoreMap":101},[141,4679,4680,4682,4684,4687,4690],{"class":143,"line":144},[141,4681,4659],{"class":147},[141,4683,4662],{"class":158},[141,4685,4686],{"class":147},"(record, (metadata, exception) ",[141,4688,4689],{"class":151},"->",[141,4691,201],{"class":147},[141,4693,4694,4697,4700,4703,4706],{"class":143,"line":165},[141,4695,4696],{"class":151}," if",[141,4698,4699],{"class":147}," (exception ",[141,4701,4702],{"class":151},"!=",[141,4704,4705],{"class":428}," null",[141,4707,507],{"class":147},[141,4709,4710],{"class":143,"line":210},[141,4711,4712],{"class":237}," \u002F\u002F 记录原始消息、告警并进入补偿流程\n",[141,4714,4715,4718],{"class":143,"line":219},[141,4716,4717],{"class":158}," handleSendFailure",[141,4719,4720],{"class":147},"(record, exception);\n",[141,4722,4723],{"class":143,"line":234},[141,4724,244],{"class":147},[141,4726,4727],{"class":143,"line":241},[141,4728,4729],{"class":147},"});\n",[18,4731,4732,4733,4735],{},"序列化失败、鉴权失败、消息过大和超时等错误，最终都需要业务明确处理。不能把“调用过 ",[22,4734,4662],{},"”当成“消息已经可靠进入 Kafka”。",[638,4737,4739],{"id":4738},"_4-数据库与-kafka-的一致性","4. 数据库与 Kafka 的一致性",[18,4741,4742],{},"如果业务流程是：",[95,4744,4747],{"className":4745,"code":4746,"language":100,"meta":101},[98],"更新数据库\n→\n发送 Kafka 消息\n",[22,4748,4746],{"__ignoreMap":101},[18,4750,4751],{},"数据库更新成功、消息发送失败时，仍然会造成业务事件丢失。",[18,4753,4754],{},"常见解决方式是本地消息表，也叫 Transactional Outbox：",[95,4756,4759],{"className":4757,"code":4758,"language":100,"meta":101},[98],"同一个数据库事务\n├── 更新业务数据\n└── 写入待发送事件表\n\n事务提交后\n→ 后台任务投递 Kafka\n→ 成功后标记事件已发送\n",[22,4760,4758],{"__ignoreMap":101},[18,4762,4763],{},"这样即使 Kafka 暂时不可用，消息也可以从本地消息表继续重试。Kafka 事务可以保证 Kafka 内部多条记录及消费 Offset 的原子性，但不会自动把外部数据库事务包含进来。",[14,4765,4767],{"id":4766},"三broker-如何保证消息可靠保存","三、Broker 如何保证消息可靠保存",[638,4769,4771],{"id":4770},"_1-合理设置副本数","1. 合理设置副本数",[18,4773,4774],{},"生产环境通常使用：",[95,4776,4779],{"className":4777,"code":4778,"language":100,"meta":101},[98],"replication.factor = 3\n",[22,4780,4778],{"__ignoreMap":101},[18,4782,4783],{},"一个分区包含一个 Leader 和多个 Follower。生产者与 Leader 交互，Follower 从 Leader 复制日志。某个 Broker 故障后，可以从仍然同步的副本中选举新 Leader。",[18,4785,4786],{},"副本数提高的是容错能力，但副本只有真正保持同步才有意义。",[638,4788,4790],{"id":4789},"_2-理解-isr","2. 理解 ISR",[18,4792,4793],{},"ISR 是 In-Sync Replicas，即当前与 Leader 保持同步的副本集合。",[18,4795,4796],{},"例如一个三副本分区：",[95,4798,4801],{"className":4799,"code":4800,"language":100,"meta":101},[98],"Leader A\nFollower B\nFollower C\n\nISR = [A, B, C]\n",[22,4802,4800],{"__ignoreMap":101},[18,4804,4805],{},"如果 C 长时间跟不上 Leader，它会被移出 ISR：",[95,4807,4810],{"className":4808,"code":4809,"language":100,"meta":101},[98],"ISR = [A, B]\n",[22,4811,4809],{"__ignoreMap":101},[18,4813,4814,4816],{},[22,4815,4407],{}," 等待的是当前 ISR 的确认，而不是永远等待所有配置副本。",[638,4818,4820,4821],{"id":4819},"_3-配置-mininsyncreplicas","3. 配置 ",[22,4822,4572],{},[18,4824,4825],{},"推荐组合：",[95,4827,4830],{"className":4828,"code":4829,"language":100,"meta":101},[98],"replication.factor = 3\nmin.insync.replicas = 2\nacks = all\n",[22,4831,4829],{"__ignoreMap":101},[18,4833,4834],{},"它表达的含义是：",[59,4836,4837],{},[18,4838,4839],{},"至少要有两个同步副本可用，写入才允许成功。",[18,4841,4842],{},"如果 ISR 只剩一个副本，Broker 会拒绝写入。此时系统牺牲部分可用性，避免在单副本状态下继续写入并承担更高的数据丢失风险。",[638,4844,4846],{"id":4845},"_4-关闭非同步副本选举","4. 关闭非同步副本选举",[95,4848,4850],{"className":4553,"code":4849,"language":4555,"meta":101,"style":101},"unclean.leader.election.enable=false\n",[22,4851,4852],{"__ignoreMap":101},[141,4853,4854,4857],{"class":143,"line":144},[141,4855,4856],{"class":151},"unclean.leader.election.enable",[141,4858,4859],{"class":147},"=false\n",[18,4861,4862,4865],{},[22,4863,4864],{},"unclean leader election"," 指允许不在 ISR 中的副本被选举为 Leader。如果所有同步副本都不可用，非 ISR 副本可能缺少最新消息；将它选为 Leader 虽然能更快恢复分区服务，却可能造成日志回退和数据丢失。",[18,4867,4868],{},"因此，对数据可靠性要求较高的场景应明确配置：",[59,4870,4871],{},[18,4872,4873],{},[64,4874,4875,4876,4878],{},"关闭非同步副本选举：",[22,4877,4415],{},"。",[18,4880,4881],{},"这是一个典型的取舍：",[95,4883,4886],{"className":4884,"code":4885,"language":100,"meta":101},[98],"开启非同步副本选举：可用性更高，但可能丢失消息\n关闭非同步副本选举：数据可靠性更强，但分区可能暂时不可用\n",[22,4887,4885],{"__ignoreMap":101},[638,4889,4891,4892,4894,4895],{"id":4890},"_5-acksall-不等于每条消息都立即-fsync","5. ",[22,4893,4407],{}," 不等于每条消息都立即 ",[22,4896,4897],{},"fsync",[18,4899,4900,4901,4878],{},"Kafka 的持久性主要依赖顺序写日志、操作系统页缓存和多副本机制。Broker 返回成功，并不表示每个副本都对该消息单独执行了一次物理磁盘 ",[22,4902,4897],{},[18,4904,4905],{},"实际生产中，通常通过跨 Broker 副本降低单机和单盘故障风险，而不是强制每条消息同步刷盘。若多个副本同时发生不可恢复故障，仍不存在数学意义上的绝对零丢失。",[14,4907,4909],{"id":4908},"四消费者如何避免消费丢失","四、消费者如何避免“消费丢失”",[638,4911,4913],{"id":4912},"_1-关闭自动提交-offset","1. 关闭自动提交 Offset",[95,4915,4917],{"className":4553,"code":4916,"language":4555,"meta":101,"style":101},"enable.auto.commit=false\n",[22,4918,4919],{"__ignoreMap":101},[141,4920,4921,4924],{"class":143,"line":144},[141,4922,4923],{"class":151},"enable.auto.commit",[141,4925,4859],{"class":147},[18,4927,4928],{},"自动提交可能出现以下顺序：",[95,4930,4933],{"className":4931,"code":4932,"language":100,"meta":101},[98],"拉取消息\n→ 自动提交 Offset\n→ 执行业务\n→ 进程崩溃\n",[22,4934,4932],{"__ignoreMap":101},[18,4936,4937],{},"重启后，消费者会从已提交的下一个 Offset 继续消费，刚才尚未处理成功的消息就被跳过了。",[638,4939,4941],{"id":4940},"_2-业务成功后再提交-offset","2. 业务成功后再提交 Offset",[18,4943,4944],{},"更可靠的顺序是：",[95,4946,4949],{"className":4947,"code":4948,"language":100,"meta":101},[98],"拉取消息\n→ 执行业务\n→ 业务成功\n→ 提交 Offset\n",[22,4950,4948],{"__ignoreMap":101},[18,4952,4953],{},"如果业务处理失败，就不提交 Offset，让消息后续重新消费：",[95,4955,4957],{"className":135,"code":4956,"language":137,"meta":101,"style":101},"while (true) {\n ConsumerRecords\u003CString, String> records = consumer.poll(Duration.ofSeconds(1));\n\n for (ConsumerRecord\u003CString, String> record : records) {\n process(record);\n }\n\n consumer.commitSync();\n}\n",[22,4958,4959,4971,5008,5012,5035,5042,5046,5050,5060],{"__ignoreMap":101},[141,4960,4961,4963,4966,4969],{"class":143,"line":144},[141,4962,4277],{"class":151},[141,4964,4965],{"class":147}," (",[141,4967,4968],{"class":428},"true",[141,4970,507],{"class":147},[141,4972,4973,4976,4979,4982,4984,4987,4989,4992,4995,4998,5001,5003,5005],{"class":143,"line":165},[141,4974,4975],{"class":147}," ConsumerRecords\u003C",[141,4977,4978],{"class":151},"String",[141,4980,4981],{"class":147},", ",[141,4983,4978],{"class":151},[141,4985,4986],{"class":147},"> records ",[141,4988,152],{"class":151},[141,4990,4991],{"class":147}," consumer.",[141,4993,4994],{"class":158},"poll",[141,4996,4997],{"class":147},"(Duration.",[141,4999,5000],{"class":158},"ofSeconds",[141,5002,908],{"class":147},[141,5004,2225],{"class":428},[141,5006,5007],{"class":147},"));\n",[141,5009,5010],{"class":143,"line":210},[141,5011,207],{"emptyLinePlaceholder":206},[141,5013,5014,5017,5020,5022,5024,5026,5029,5032],{"class":143,"line":219},[141,5015,5016],{"class":151}," for",[141,5018,5019],{"class":147}," (ConsumerRecord\u003C",[141,5021,4978],{"class":151},[141,5023,4981],{"class":147},[141,5025,4978],{"class":151},[141,5027,5028],{"class":147},"> record ",[141,5030,5031],{"class":151},":",[141,5033,5034],{"class":147}," records) {\n",[141,5036,5037,5040],{"class":143,"line":234},[141,5038,5039],{"class":158}," process",[141,5041,4665],{"class":147},[141,5043,5044],{"class":143,"line":241},[141,5045,244],{"class":147},[141,5047,5048],{"class":143,"line":247},[141,5049,207],{"emptyLinePlaceholder":206},[141,5051,5052,5055,5058],{"class":143,"line":307},[141,5053,5054],{"class":147}," consumer.",[141,5056,5057],{"class":158},"commitSync",[141,5059,162],{"class":147},[141,5061,5062],{"class":143,"line":379},[141,5063,250],{"class":147},[18,5065,5066],{},"示例表达的是基本原则。实际批量消费时，如果一批消息中只有部分成功，需要准确管理各分区可提交的 Offset，不能直接把失败消息之后的位置一起提交。",[638,5068,5070],{"id":5069},"_3-为什么还需要业务幂等","3. 为什么还需要业务幂等",[18,5072,5073],{},"“处理成功后提交”可以避免消息被跳过，但会引入重复：",[95,5075,5078],{"className":5076,"code":5077,"language":100,"meta":101},[98],"业务处理成功\n→ 提交 Offset 前进程崩溃\n→ 重启后再次消费同一条消息\n",[22,5079,5077],{"__ignoreMap":101},[18,5081,5082],{},"因此，可靠消费通常采用至少一次投递，并在业务层保证幂等。常见方式包括：",[114,5084,5085,5088,5091,5094,5097],{},[117,5086,5087],{},"使用事件 ID 建立数据库唯一索引。",[117,5089,5090],{},"建立消费去重表或 Inbox 表。",[117,5092,5093],{},"使用业务状态机，只允许合法状态转换。",[117,5095,5096],{},"更新时带版本号或业务条件。",[117,5098,5099],{},"对扣款、发券等操作使用唯一业务流水号。",[59,5101,5102],{},[18,5103,5104],{},[64,5105,5106],{},"不丢消息通常意味着允许重复，再通过幂等消除重复影响。",[638,5108,5110],{"id":5109},"_4-kafka-内部链路的-exactly-once","4. Kafka 内部链路的 Exactly Once",[18,5112,5113],{},"如果消费 Kafka 后仍然写回 Kafka，可以使用 Kafka 事务，把输出记录和消费 Offset 放进同一个事务：",[95,5115,5118],{"className":5116,"code":5117,"language":100,"meta":101},[98],"消费消息\n→ 处理\n→ 写入下游 Topic\n→ sendOffsetsToTransaction\n→ 提交事务\n",[22,5119,5117],{"__ignoreMap":101},[18,5121,5122],{},"下游消费者设置：",[95,5124,5126],{"className":4553,"code":5125,"language":4555,"meta":101,"style":101},"isolation.level=read_committed\n",[22,5127,5128],{"__ignoreMap":101},[141,5129,5130,5133],{"class":143,"line":144},[141,5131,5132],{"class":151},"isolation.level",[141,5134,5135],{"class":147},"=read_committed\n",[18,5137,5138],{},"这样只读取已提交事务的数据。",[18,5140,5141],{},"但如果最终写入的是 MySQL 等外部系统，Kafka 事务并不能自动保证 Kafka 与数据库的原子性。生产方可以用 Outbox 保证事件可靠发出，消费方可以用 Inbox 应对重复消费，具体区别见下一节。",[14,5143,5145],{"id":5144},"五outbox-与-inbox-分别是什么","五、Outbox 与 Inbox 分别是什么",[18,5147,5148],{},"Outbox 和 Inbox 都借助数据库本地事务解决消息链路中的一致性问题，但它们位于不同位置：",[95,5150,5153],{"className":5151,"code":5152,"language":100,"meta":101},[98],"业务生产方 → Outbox → Kafka → Inbox → 业务消费方\n",[22,5154,5152],{"__ignoreMap":101},[638,5156,5158],{"id":5157},"_1-outbox保证业务事件可靠发出","1. Outbox：保证业务事件可靠发出",[18,5160,5161],{},"Outbox 位于消息生产方，用来解决“数据库更新成功，但 Kafka 消息发送失败”的双写不一致问题。",[18,5163,5164],{},"核心流程：",[95,5166,5169],{"className":5167,"code":5168,"language":100,"meta":101},[98],"同一个数据库事务\n├── 更新业务数据\n└── 写入 Outbox 事件表\n\n事务提交\n→ 后台投递程序扫描 Outbox\n→ 发送 Kafka\n→ 收到成功确认后标记已发送\n",[22,5170,5168],{"__ignoreMap":101},[18,5172,5173],{},"例如创建订单时，不直接把“订单创建事件”的可靠性寄托在一次 Kafka 调用上，而是在创建订单的同一个数据库事务中写入一条 Outbox 记录。即使 Kafka 暂时不可用，后台任务仍可继续重试。",[18,5175,5176],{},"Outbox 的关键点：",[114,5178,5179,5182,5188,5191,5194],{},[117,5180,5181],{},"业务数据和事件记录必须写入同一个数据库事务。",[117,5183,5184,5185,4878],{},"每条事件应有全局唯一的 ",[22,5186,5187],{},"eventId",[117,5189,5190],{},"投递程序可以轮询事件表，也可以通过 CDC 捕获新增事件。",[117,5192,5193],{},"“发送成功但标记失败”可能导致再次投递，因此消费者仍需幂等。",[117,5195,5196],{},"Outbox 解决的是事件可靠发出，不保证消费者一定处理成功。",[18,5198,5199,5200,5203],{},"这里的 CDC 是 ",[64,5201,5202],{},"Change Data Capture（变更数据捕获）","。它会读取数据库的变更日志，例如 MySQL Binlog，捕获数据的新增、修改和删除，再把变更发送到 Kafka。常用工具有 Debezium、Canal。",[18,5205,5206],{},"在 Outbox 场景中，它的工作链路是：",[95,5208,5211],{"className":5209,"code":5210,"language":100,"meta":101},[98],"业务事务写入业务表和 Outbox 表\n→ CDC 监听 Binlog\n→ 捕获新增的 Outbox 记录\n→ 发送到 Kafka\n",[22,5212,5210],{"__ignoreMap":101},[18,5214,5215,5216,5218],{},"相比定时扫描 Outbox 表，CDC 延迟更低，也能减少频繁查询数据库的压力。但消息链路仍可能产生重复，因此必须保留 ",[22,5217,5187],{},"，并由消费端保证幂等。",[638,5220,5222],{"id":5221},"_2-inbox保证重复消息只产生一次业务效果","2. Inbox：保证重复消息只产生一次业务效果",[18,5224,5225],{},"Inbox 位于消息消费方，用来记录已经处理过的事件，主要解决至少一次投递带来的重复消费问题。",[18,5227,5164],{},[95,5229,5232],{"className":5230,"code":5231,"language":100,"meta":101},[98],"收到 Kafka 消息\n→ 开启数据库事务\n→ 根据 eventId 写入 Inbox 记录\n→ 执行业务更新\n→ 提交数据库事务\n→ 提交 Kafka Offset\n",[22,5233,5231],{"__ignoreMap":101},[18,5235,5236,5237,5239],{},"Inbox 表通常对 ",[22,5238,5187],{}," 建立唯一索引。重复消息到达时，如果发现该事件已经存在，就不再重复执行业务逻辑。",[18,5241,5242],{},"Inbox 的关键点：",[114,5244,5245,5248,5251,5254],{},[117,5246,5247],{},"Inbox 记录和业务更新必须处于同一个数据库事务。",[117,5249,5250],{},"唯一索引负责防止同一事件被并发重复处理。",[117,5252,5253],{},"数据库事务提交后、Offset 提交前发生故障，消息仍会重投，但 Inbox 可以识别重复。",[117,5255,5256],{},"如果消费逻辑还会调用外部 HTTP 接口，Inbox 无法自动让数据库和外部接口形成原子事务；仍需下游幂等、重试或补偿。",[638,5258,5260],{"id":5259},"_3-两者的区别","3. 两者的区别",[1309,5262,5263,5275],{},[1312,5264,5265],{},[1315,5266,5267,5269,5272],{},[1318,5268,3582],{},[1318,5270,5271],{},"Outbox",[1318,5273,5274],{},"Inbox",[1328,5276,5277,5288,5299,5310,5321],{},[1315,5278,5279,5282,5285],{},[1333,5280,5281],{},"所在位置",[1333,5283,5284],{},"消息生产方",[1333,5286,5287],{},"消息消费方",[1315,5289,5290,5293,5296],{},[1333,5291,5292],{},"主要目标",[1333,5294,5295],{},"防止业务成功但事件未发出",[1333,5297,5298],{},"防止重复消息重复产生业务效果",[1315,5300,5301,5304,5307],{},[1333,5302,5303],{},"本地事务内容",[1333,5305,5306],{},"业务更新 + 写事件表",[1333,5308,5309],{},"写消费记录 + 业务更新",[1315,5311,5312,5315,5318],{},[1333,5313,5314],{},"后台动作",[1333,5316,5317],{},"把待发送事件投递到 Kafka",[1333,5319,5320],{},"通常不需要再次投递",[1315,5322,5323,5326,5329],{},[1333,5324,5325],{},"仍需注意",[1333,5327,5328],{},"投递过程可能产生重复消息",[1333,5330,5331],{},"外部调用仍需幂等或补偿",[18,5333,5334],{},"一句话区分：",[59,5336,5337],{},[18,5338,5339],{},[64,5340,5341],{},"Outbox 保证“该发的消息最终发出去”，Inbox 保证“重复收到的消息不会重复生效”。",[14,5343,5345],{"id":5344},"六三种投递语义","六、三种投递语义",[1309,5347,5348,5361],{},[1312,5349,5350],{},[1315,5351,5352,5355,5358],{},[1318,5353,5354],{},"语义",[1318,5356,5357],{},"Offset 与业务处理顺序",[1318,5359,5360],{},"结果",[1328,5362,5363,5374,5385],{},[1315,5364,5365,5368,5371],{},[1333,5366,5367],{},"At Most Once",[1333,5369,5370],{},"先提交，再处理",[1333,5372,5373],{},"可能丢失，通常不重复",[1315,5375,5376,5379,5382],{},[1333,5377,5378],{},"At Least Once",[1333,5380,5381],{},"先处理，再提交",[1333,5383,5384],{},"不轻易丢失，可能重复",[1315,5386,5387,5390,5393],{},[1333,5388,5389],{},"Exactly Once",[1333,5391,5392],{},"事务或幂等机制协调",[1333,5394,5395],{},"业务效果恰好一次",[18,5397,5398],{},"绝大多数业务系统采用：",[59,5400,5401],{},[18,5402,5403],{},[64,5404,5405],{},"Kafka 至少一次投递 + 消费端业务幂等。",[18,5407,5408],{},"这通常比追求所有环节的强事务更容易实现，也更便于扩展。",[14,5410,5412],{"id":5411},"七常见故障与保障措施","七、常见故障与保障措施",[1309,5414,5415,5428],{},[1312,5416,5417],{},[1315,5418,5419,5422,5425],{},[1318,5420,5421],{},"故障场景",[1318,5423,5424],{},"可能后果",[1318,5426,5427],{},"主要保障",[1328,5429,5430,5441,5454,5467,5479,5490,5501,5512],{},[1315,5431,5432,5435,5438],{},[1333,5433,5434],{},"生产者网络抖动",[1333,5436,5437],{},"发送失败或结果未知",[1333,5439,5440],{},"重试、幂等生产、回调处理",[1315,5442,5443,5446,5449],{},[1333,5444,5445],{},"Leader 写入后立即故障",[1333,5447,5448],{},"未同步消息丢失",[1333,5450,5451,5453],{},[22,5452,4407],{},"、副本、ISR",[1315,5455,5456,5459,5462],{},[1333,5457,5458],{},"ISR 只剩一个副本",[1333,5460,5461],{},"单点故障风险升高",[1333,5463,5464,5466],{},[22,5465,4572],{}," 拒绝写入",[1315,5468,5469,5472,5475],{},[1333,5470,5471],{},"同步副本全部不可用",[1333,5473,5474],{},"非同步副本选主后日志回退",[1333,5476,4875,5477],{},[22,5478,4415],{},[1315,5480,5481,5484,5487],{},[1333,5482,5483],{},"消费者先提交后处理",[1333,5485,5486],{},"业务消息被跳过",[1333,5488,5489],{},"关闭自动提交，成功后提交",[1315,5491,5492,5495,5498],{},[1333,5493,5494],{},"处理成功但提交前崩溃",[1333,5496,5497],{},"重复消费",[1333,5499,5500],{},"业务幂等、唯一流水号",[1315,5502,5503,5506,5509],{},[1333,5504,5505],{},"数据库成功、Kafka 失败",[1333,5507,5508],{},"业务事件未发出",[1333,5510,5511],{},"Transactional Outbox",[1315,5513,5514,5517,5520],{},[1333,5515,5516],{},"Kafka 成功、下游失败",[1333,5518,5519],{},"业务结果缺失",[1333,5521,5522],{},"重试、死信、补偿、告警",[14,5524,5526],{"id":5525},"八常见误区","八、常见误区",[638,5528,5530,5531,5533],{"id":5529},"误区一配置-acksall-就绝对不会丢","误区一：配置 ",[22,5532,4407],{}," 就绝对不会丢",[18,5535,5536,5538,5539,5541],{},[22,5537,4407],{}," 只解决生产者到 Broker 的确认强度，还要配合副本数、",[22,5540,4572],{},"、正确选主和消费者提交策略。",[638,5543,5545],{"id":5544},"误区二配置无限重试就不会丢","误区二：配置无限重试就不会丢",[18,5547,5548,5549,5551],{},"重试仍然受 ",[22,5550,4620],{}," 等条件限制，而且权限错误、序列化错误等问题无法靠盲目重试解决。最终失败必须被业务感知和补偿。",[638,5553,5555],{"id":5554},"误区三手动提交-offset-就是-exactly-once","误区三：手动提交 Offset 就是 Exactly Once",[18,5557,5558],{},"手动提交只能帮助建立“处理成功后提交”的顺序，崩溃窗口仍可能造成重复消费，因此还需要业务幂等。",[638,5560,5562],{"id":5561},"误区四kafka-事务可以自动覆盖数据库","误区四：Kafka 事务可以自动覆盖数据库",[18,5564,5565],{},"Kafka 事务主要协调 Kafka 内部的消息与 Offset，不会自动与 MySQL 等外部数据库形成同一个原子事务。",[638,5567,5569],{"id":5568},"误区五broker-返回成功就等于所有副本已经物理刷盘","误区五：Broker 返回成功就等于所有副本已经物理刷盘",[18,5571,5572],{},"Kafka 的确认、副本复制和磁盘刷盘是不同概念。高可靠主要依靠多副本和同步副本约束，而不是把每条消息都单独同步刷盘。",[14,5574,5576],{"id":5575},"九监控和运维同样重要","九、监控和运维同样重要",[18,5578,5579],{},"配置正确后，还应持续监控：",[114,5581,5582,5585,5588,5591,5594,5597],{},[117,5583,5584],{},"发送失败率、重试次数和发送延迟。",[117,5586,5587],{},"ISR 收缩、未充分复制分区和离线分区。",[117,5589,5590],{},"Broker 磁盘空间、磁盘延迟和网络异常。",[117,5592,5593],{},"消费积压、消费失败、重平衡次数。",[117,5595,5596],{},"死信消息和补偿任务堆积。",[117,5598,5599],{},"业务事件与最终结果的对账差异。",[18,5601,5602],{},"没有监控和对账，即使消息已经丢失，系统也可能长期无法发现。",[14,5604,5605],{"id":5605},"参考资料",[114,5607,5608,5615,5622,5629,5636],{},[117,5609,5610],{},[73,5611,5614],{"href":5612,"rel":5613},"https:\u002F\u002Fkafka.apache.org\u002F41\u002Fconfiguration\u002Fproducer-configs\u002F",[1876],"Apache Kafka Producer Configs",[117,5616,5617],{},[73,5618,5621],{"href":5619,"rel":5620},"https:\u002F\u002Fkafka.apache.org\u002F41\u002Fconfiguration\u002Fbroker-configs\u002F",[1876],"Apache Kafka Broker Configs",[117,5623,5624],{},[73,5625,5628],{"href":5626,"rel":5627},"https:\u002F\u002Fkafka.apache.org\u002F41\u002Fconfiguration\u002Fconsumer-configs\u002F",[1876],"Apache Kafka Consumer Configs",[117,5630,5631],{},[73,5632,5635],{"href":5633,"rel":5634},"https:\u002F\u002Fkafka.apache.org\u002F41\u002Fdesign\u002Fdesign\u002F",[1876],"Apache Kafka Design：Message Delivery Semantics",[117,5637,5638],{},[73,5639,5642],{"href":5640,"rel":5641},"https:\u002F\u002Fkafka.apache.org\u002F41\u002Fjavadoc\u002Forg\u002Fapache\u002Fkafka\u002Fclients\u002Fconsumer\u002FKafkaConsumer.html",[1876],"Apache KafkaConsumer JavaDoc",[1907,5644,5645],{},"html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .sJ8bj, html code.shiki .sJ8bj{--shiki-default:#6A737D;--shiki-dark:#6A737D}",{"title":101,"searchDepth":165,"depth":165,"links":5647},[5648,5649,5650,5651,5652,5659,5668,5674,5679,5680,5681,5689,5690],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":4454,"depth":165,"text":4455},{"id":4478,"depth":165,"text":4479,"children":5653},[5654,5656,5657,5658],{"id":4482,"depth":210,"text":5655},"1. 使用 acks=all",{"id":4576,"depth":210,"text":4577},{"id":4645,"depth":210,"text":4646},{"id":4738,"depth":210,"text":4739},{"id":4766,"depth":165,"text":4767,"children":5660},[5661,5662,5663,5665,5666],{"id":4770,"depth":210,"text":4771},{"id":4789,"depth":210,"text":4790},{"id":4819,"depth":210,"text":5664},"3. 配置 min.insync.replicas",{"id":4845,"depth":210,"text":4846},{"id":4890,"depth":210,"text":5667},"5. acks=all 不等于每条消息都立即 fsync",{"id":4908,"depth":165,"text":4909,"children":5669},[5670,5671,5672,5673],{"id":4912,"depth":210,"text":4913},{"id":4940,"depth":210,"text":4941},{"id":5069,"depth":210,"text":5070},{"id":5109,"depth":210,"text":5110},{"id":5144,"depth":165,"text":5145,"children":5675},[5676,5677,5678],{"id":5157,"depth":210,"text":5158},{"id":5221,"depth":210,"text":5222},{"id":5259,"depth":210,"text":5260},{"id":5344,"depth":165,"text":5345},{"id":5411,"depth":165,"text":5412},{"id":5525,"depth":165,"text":5526,"children":5682},[5683,5685,5686,5687,5688],{"id":5529,"depth":210,"text":5684},"误区一：配置 acks=all 就绝对不会丢",{"id":5544,"depth":210,"text":5545},{"id":5554,"depth":210,"text":5555},{"id":5561,"depth":210,"text":5562},{"id":5568,"depth":210,"text":5569},{"id":5575,"depth":165,"text":5576},{"id":5605,"depth":165,"text":5605},"wiki:java:kafka-message-loss-prevention","从生产者、Broker 和消费者三段链路分析 Kafka 消息丢失的原因，以及 acks、ISR、副本、手动提交 Offset 和业务幂等的完整保障方案。",{},72,"\u002Fjava\u002Fkafka-message-loss-prevention",{"title":4392,"description":5692},"java\u002Fkafka-message-loss-prevention","2026-07-24","7RYCOV4a1N5fgUG67sSi5WAq6gaBz5gHS16sBwuy4yk",{"id":5701,"title":5702,"body":5703,"commentId":6738,"description":6739,"difficulty":3462,"draft":1943,"extension":1944,"meta":6740,"navigation":206,"order":6741,"path":6742,"section":1948,"seo":6743,"stem":6744,"updated":5698,"__hash__":6745},"java\u002Fjava\u002Fkafka-high-concurrency-performance-availability.md","Kafka 是如何实现高并发、高性能、高可用的",{"type":7,"value":5704,"toc":6693},[5705,5708,5710,5724,5726,5733,5735,5744,5746,5749,5763,5767,5771,5774,5780,5783,5790,5794,5797,5800,5811,5814,5818,5821,5823,5829,5832,5836,5839,5842,5846,5850,5853,5859,5862,5866,5869,5875,5895,5898,5902,5905,5911,5914,5928,5934,5938,5941,5947,5950,5967,5974,5980,5983,5986,5993,5996,6024,6031,6035,6038,6041,6055,6072,6076,6079,6085,6091,6097,6100,6109,6115,6118,6125,6131,6135,6138,6141,6147,6149,6155,6158,6164,6167,6170,6173,6194,6197,6201,6205,6208,6214,6217,6220,6224,6227,6233,6236,6245,6248,6253,6256,6259,6263,6268,6279,6282,6296,6299,6302,6308,6311,6315,6322,6328,6331,6334,6382,6385,6391,6394,6398,6401,6404,6410,6413,6417,6479,6482,6488,6492,6495,6515,6518,6521,6527,6530,6534,6538,6541,6545,6551,6555,6558,6562,6565,6572,6579,6583,6586,6597,6601,6614,6617,6631,6633,6675,6677,6690],[10,5706,5702],{"id":5707},"kafka-是如何实现高并发高性能高可用的",[14,5709,16],{"id":16},[59,5711,5712],{},[18,5713,5714,5715,5718,5719,44,5721,5723],{},"Kafka 的高并发主要依靠分区实现横向扩展：一个 Topic 被拆成多个 Partition，分区 Leader 分散在不同 Broker 上，生产者可以并行写入，消费者组也可以按分区并行消费。高性能主要来自追加写和顺序 I\u002FO、操作系统 Page Cache、生产与消费两端的批处理、批量压缩，以及通过 ",[22,5716,5717],{},"sendfile"," 实现的零拷贝传输。高可用则依靠多副本、Leader\u002FFollower、ISR、故障选主和 KRaft Controller Quorum；生产端再配合 ",[22,5720,4407],{},[22,5722,4572],{}," 和幂等生产，消费端通过 Consumer Group、Offset 与重新分配实现故障恢复。Kafka 的核心设计是在分区粒度上并行，在单分区内部维持有序日志，再用副本机制保障故障后的连续服务。",[18,5725,57],{},[59,5727,5728],{},[18,5729,5730],{},[64,5731,5732],{},"分区提供并行度，顺序日志、批处理和零拷贝提供吞吐量，副本、ISR 与故障选主提供可用性。",[14,5734,69],{"id":69},[18,5736,5737],{},[73,5738,5741],{"href":5739,"target":76,"rel":5740},"\u002Fimages\u002Fwiki\u002Fjava\u002Fkafka-high-concurrency-performance-availability.svg",[78,79],[81,5742],{"src":5739,"alt":5743},"Kafka 高并发、高性能和高可用实现机制总览",[14,5745,86],{"id":86},[18,5747,5748],{},"Kafka 的三个能力不是彼此孤立的：",[114,5750,5751,5754,5757,5760],{},[117,5752,5753],{},"分区既是并发执行和横向扩展的单位，也是副本复制与故障恢复的单位。",[117,5755,5756],{},"批处理既减少网络请求，也把大量小写入转化为更高效的顺序写。",[117,5758,5759],{},"Page Cache 既提升读写性能，也能配合副本机制避免为了可靠性而对每条消息执行同步刷盘。",[117,5761,5762],{},"副本增强了可靠性，但同时会增加网络、磁盘与确认延迟，因此需要在吞吐、延迟和可靠性之间取舍。",[14,5764,5766],{"id":5765},"一高并发通过分区横向扩展","一、高并发：通过分区横向扩展",[638,5768,5770],{"id":5769},"_1-partition-是-kafka-的并行单元","1. Partition 是 Kafka 的并行单元",[18,5772,5773],{},"一个 Topic 可以拆成多个 Partition：",[95,5775,5778],{"className":5776,"code":5777,"language":100,"meta":101},[98],"Topic: order-events\n├── Partition 0 → Leader 在 Broker A\n├── Partition 1 → Leader 在 Broker B\n└── Partition 2 → Leader 在 Broker C\n",[22,5779,5777],{"__ignoreMap":101},[18,5781,5782],{},"不同分区可以由不同 Broker 同时处理，因此整体吞吐不再受限于单台机器。增加 Broker 并合理增加分区后，存储容量、网络带宽和读写能力都可以横向扩展。",[18,5784,5785,5786,5789],{},"Kafka 只保证",[64,5787,5788],{},"单分区内有序","，不保证一个 Topic 的所有分区之间全局有序。这是它获得并行能力的重要前提。",[638,5791,5793],{"id":5792},"_2-生产者直接找到分区-leader","2. 生产者直接找到分区 Leader",[18,5795,5796],{},"生产者会缓存集群元数据，根据消息 Key、显式分区或默认分区策略选择 Partition，然后直接向该分区的 Leader 发送数据，中间不需要额外的统一路由节点。",[18,5798,5799],{},"常见分区方式：",[114,5801,5802,5805,5808],{},[117,5803,5804],{},"指定 Key：相同 Key 通常进入同一分区，适合保证同一订单、用户或账户内的消息顺序。",[117,5806,5807],{},"不指定 Key：默认分区策略会在适当时机选择分区，并尽量形成较大的批次。",[117,5809,5810],{},"自定义分区器：按租户、地区或业务规则路由。",[18,5812,5813],{},"如果 Key 分布不均，大量消息集中到少数分区，就会出现热点分区。此时即使 Broker 很多，整体吞吐仍会被热点 Leader 限制。",[638,5815,5817],{"id":5816},"_3-consumer-group-按分区并行消费","3. Consumer Group 按分区并行消费",[18,5819,5820],{},"同一个 Consumer Group 中，一个 Partition 在同一时刻只分配给一个 Consumer；一个 Consumer 可以负责多个 Partition。",[18,5822,1398],{},[95,5824,5827],{"className":5825,"code":5826,"language":100,"meta":101},[98],"4 个 Partition + 2 个 Consumer\n→ 每个 Consumer 负责约 2 个 Partition\n\n4 个 Partition + 4 个 Consumer\n→ 每个 Consumer 负责约 1 个 Partition\n\n4 个 Partition + 6 个 Consumer\n→ 最多只有 4 个 Consumer 能获得 Partition\n",[22,5828,5826],{"__ignoreMap":101},[18,5830,5831],{},"因此，一个消费组的有效并行度上限通常受 Partition 数量约束。简单增加 Consumer，而不增加 Partition，不一定能提高吞吐量。",[638,5833,5835],{"id":5834},"_4-broker-内部通过线程分工处理请求","4. Broker 内部通过线程分工处理请求",[18,5837,5838],{},"Broker 不会用一个线程串行完成所有网络和磁盘工作。网络线程负责接收请求、解析协议和返回响应，请求处理线程负责执行 Produce、Fetch 等具体逻辑，后台线程负责日志清理、副本同步等任务。",[18,5840,5841],{},"这种职责分离让网络连接管理、业务请求处理和后台维护能够并行执行，避免某类工作完全阻塞其他工作。",[14,5843,5845],{"id":5844},"二高性能把随机小操作变成顺序批量操作","二、高性能：把随机小操作变成顺序批量操作",[638,5847,5849],{"id":5848},"_1-顺序追加写","1. 顺序追加写",[18,5851,5852],{},"Kafka 的 Partition 本质上是一条只追加的日志。新消息写到日志末尾，不需要像通用数据库那样频繁进行随机位置更新。",[95,5854,5857],{"className":5855,"code":5856,"language":100,"meta":101},[98],"旧数据 ────────────────→ 日志末尾追加新批次\noffset 0 1 2 3 4 5 6 ...\n",[22,5858,5856],{"__ignoreMap":101},[18,5860,5861],{},"顺序 I\u002FO 能充分利用磁盘和操作系统的预读、合并写能力。日志达到一定大小或时间后会切分为新的 Segment，旧 Segment 可以按保留策略清理或压缩，不影响当前日志继续追加。",[638,5863,5865],{"id":5864},"_2-分段日志与稀疏索引","2. 分段日志与稀疏索引",[18,5867,5868],{},"每个 Partition 由多个日志 Segment 组成，常见文件包括：",[95,5870,5873],{"className":5871,"code":5872,"language":100,"meta":101},[98],"00000000000000000000.log\n00000000000000000000.index\n00000000000000000000.timeindex\n",[22,5874,5872],{"__ignoreMap":101},[114,5876,5877,5883,5889],{},[117,5878,5879,5882],{},[22,5880,5881],{},".log"," 保存消息批次。",[117,5884,5885,5888],{},[22,5886,5887],{},".index"," 保存相对 Offset 到日志物理位置的稀疏映射。",[117,5890,5891,5894],{},[22,5892,5893],{},".timeindex"," 保存时间戳到相对 Offset 的稀疏映射。",[18,5896,5897],{},"查找消息时，Kafka 先定位 Segment，再通过稀疏索引找到接近目标的位置，最后在日志中继续顺序查找。索引不需要记录每一条消息，因此能控制索引体积和内存占用。",[638,5899,5901],{"id":5900},"_3-充分利用-page-cache","3. 充分利用 Page Cache",[18,5903,5904],{},"Kafka 不把全部消息封装成大量 Java 堆对象长期缓存，而是依赖操作系统 Page Cache：",[95,5906,5909],{"className":5907,"code":5908,"language":100,"meta":101},[98],"Producer\n→ Broker 写日志文件\n→ 数据先进入 Page Cache\n→ 操作系统异步回写磁盘\n",[22,5910,5908],{"__ignoreMap":101},[18,5912,5913],{},"这样做有几个好处：",[114,5915,5916,5919,5922,5925],{},[117,5917,5918],{},"利用操作系统成熟的预读和回写机制。",[117,5920,5921],{},"减少 JVM 堆内存占用和 GC 压力。",[117,5923,5924],{},"热数据可以直接从 Page Cache 读取。",[117,5926,5927],{},"Broker 重启后，操作系统缓存仍可能保留部分热数据，不必完全重新构建 JVM 内缓存。",[18,5929,5930,5931,5933],{},"Kafka 的可靠性主要依赖多副本，而不是对每条消息都执行一次同步 ",[22,5932,4897],{},"。如果强制每条消息同步刷盘，吞吐和延迟都会明显恶化。",[638,5935,5937],{"id":5936},"_4-端到端批处理","4. 端到端批处理",[18,5939,5940],{},"批处理贯穿生产、Broker 存储和消费三段链路：",[95,5942,5945],{"className":5943,"code":5944,"language":100,"meta":101},[98],"多条消息\n→ Producer 聚合成 Record Batch\n→ 一次网络请求发送\n→ Broker 将 Record Batch 连续追加到分区日志\n→ Consumer 一次 Fetch 多条消息\n",[22,5946,5944],{"__ignoreMap":101},[18,5948,5949],{},"它可以摊薄：",[114,5951,5952,5955,5958,5961,5964],{},[117,5953,5954],{},"网络往返成本。",[117,5956,5957],{},"系统调用成本。",[117,5959,5960],{},"协议头和请求头开销。",[117,5962,5963],{},"磁盘写入次数。",[117,5965,5966],{},"消息压缩成本。",[18,5968,5969,5970,5973],{},"这里的“Broker 追加批次”不是把多条消息合并成一条业务消息，也不承诺底层一定只发生一次系统调用。它表示 Kafka 的生产者和存储格式都以 ",[64,5971,5972],{},"Record Batch"," 为基本单位：",[95,5975,5978],{"className":5976,"code":5977,"language":100,"meta":101},[98],"Record Batch\n├── 批次头：baseOffset、长度、时间戳、压缩类型、CRC 等\n├── Record 1\n├── Record 2\n└── Record 3\n",[22,5979,5977],{"__ignoreMap":101},[18,5981,5982],{},"Producer 会先按 Partition 在内存中积累消息，形成 Record Batch。Broker 收到后，对批次进行校验，为其中的消息确定 Offset，然后把整段连续数据追加到对应 Partition 的当前日志 Segment 末尾。相比每条消息都单独发请求、单独写日志，批次追加可以用更少的请求和更大的连续 I\u002FO 摊薄固定开销。",[18,5984,5985],{},"一个 ProduceRequest 还可以携带多个 Partition 的 Record Batch，但 Broker 最终仍然分别追加到各个 Partition 的日志中。因此：",[59,5987,5988],{},[18,5989,5990],{},[64,5991,5992],{},"批次是网络传输和日志写入的基本单位，Partition 才是日志组织、顺序保证和副本复制的基本单位。",[18,5994,5995],{},"生产者常见相关参数：",[95,5997,5999],{"className":4553,"code":5998,"language":4555,"meta":101,"style":101},"batch.size=16384\nlinger.ms=5\ncompression.type=lz4\n",[22,6000,6001,6009,6016],{"__ignoreMap":101},[141,6002,6003,6006],{"class":143,"line":144},[141,6004,6005],{"class":151},"batch.size",[141,6007,6008],{"class":147},"=16384\n",[141,6010,6011,6014],{"class":143,"line":165},[141,6012,6013],{"class":151},"linger.ms",[141,6015,4615],{"class":147},[141,6017,6018,6021],{"class":143,"line":210},[141,6019,6020],{"class":151},"compression.type",[141,6022,6023],{"class":147},"=lz4\n",[18,6025,6026,2818,6028,6030],{},[22,6027,6005],{},[22,6029,6013],{}," 体现的是吞吐与延迟之间的取舍：适度等待可以积累更大的批次，但等待过长会增加低流量场景的发送延迟。参数值应根据消息大小、流量和延迟目标压测确定，不能机械照搬示例。",[638,6032,6034],{"id":6033},"_5-批量压缩","5. 批量压缩",[18,6036,6037],{},"Kafka 对一个 Record Batch 进行整体压缩，而不是分别压缩每条消息。相似消息中的字段名和公共内容可以获得更好的压缩率。",[18,6039,6040],{},"压缩后的批次会以压缩形式写入日志并传输给消费者，从而降低：",[114,6042,6043,6046,6049,6052],{},[117,6044,6045],{},"Broker 磁盘占用。",[117,6047,6048],{},"生产者到 Broker 的网络流量。",[117,6050,6051],{},"副本复制流量。",[117,6053,6054],{},"Broker 到消费者的网络流量。",[18,6056,6057,6058,44,6061,44,6064,6067,6068,6071],{},"压缩会消耗 CPU，因此需要根据资源瓶颈选择 ",[22,6059,6060],{},"lz4",[22,6062,6063],{},"zstd",[22,6065,6066],{},"snappy"," 或 ",[22,6069,6070],{},"gzip"," 等算法。网络或磁盘是瓶颈时，压缩往往能换取更高吞吐。",[638,6073,6075],{"id":6074},"_6-零拷贝","6. 零拷贝",[18,6077,6078],{},"消费者拉取日志数据时，普通路径可能需要：",[95,6080,6083],{"className":6081,"code":6082,"language":100,"meta":101},[98],"磁盘 → Page Cache → 用户空间 → Socket Buffer → 网卡\n",[22,6084,6082],{"__ignoreMap":101},[18,6086,6087,6088,6090],{},"Kafka 在适用条件下利用 Linux ",[22,6089,5717],{},"，让数据从 Page Cache 直接进入网络发送路径，减少用户态和内核态之间的复制与上下文切换：",[95,6092,6095],{"className":6093,"code":6094,"language":100,"meta":101},[98],"Page Cache → Socket \u002F 网卡\n",[22,6096,6094],{"__ignoreMap":101},[18,6098,6099],{},"这就是常说的零拷贝。它主要优化 Broker 向消费者传输已有日志数据的过程。",[18,6101,6102],{},[73,6103,6106],{"href":6104,"target":76,"rel":6105},"\u002Fimages\u002Fwiki\u002Fjava\u002Fkafka-sendfile-vs-traditional-io.svg",[78,79],[81,6107],{"src":6104,"alt":6108},"Kafka sendfile 零拷贝与传统文件传输路径对比",[18,6110,6111,6112,6114],{},"传统路径需要先把数据从内核 Page Cache 复制到 Broker 的用户空间，再从用户空间写回内核 Socket Buffer；",[22,6113,5717],{}," 让内核直接组织 Page Cache 到网络 Socket 的传输，Broker 不再把消息内容完整搬入 JVM 用户空间。",[18,6116,6117],{},"所以“零拷贝”更准确的含义是：",[59,6119,6120],{},[18,6121,6122],{},[64,6123,6124],{},"减少或绕过 Page Cache 与用户空间之间不必要的数据复制，而不是数据在磁盘、内存和网卡之间一次都不移动。",[18,6126,6127,6128,6130],{},"需要注意，Kafka 官方文档明确说明，启用 SSL 时数据要经过用户态 TLS 处理，当前不会使用这条 ",[22,6129,5717],{}," 路径。因此不能笼统地说所有 Kafka 网络传输都一定是零拷贝。",[638,6132,6134],{"id":6133},"_7-consumer-pull-与长轮询","7. Consumer Pull 与长轮询",[18,6136,6137],{},"Kafka 由消费者主动 Pull 数据。消费者可以根据自己的处理能力决定拉取速度，处理不过来时，未消费消息会暂时保留在 Kafka 中，并表现为 Consumer Lag 增长，而不是由 Broker 持续 Push 直至压垮消费者。",[18,6139,6140],{},"Consumer Lag 表示消费者的消费进度落后于 Partition 最新位置的程度。监控消费组时，通常可以近似理解为：",[95,6142,6145],{"className":6143,"code":6144,"language":100,"meta":101},[98],"Consumer Lag\n= Partition Log End Offset\n- Consumer Group 已提交 Offset\n",[22,6146,6144],{"__ignoreMap":101},[18,6148,1398],{},[95,6150,6153],{"className":6151,"code":6152,"language":100,"meta":101},[98],"Partition 下一条待写位置：10000\n消费组下一条待消费位置：9400\n\nLag = 10000 - 9400 = 600\n",[22,6154,6152],{"__ignoreMap":101},[18,6156,6157],{},"这表示当前大约还有 600 个 Offset 的数据尚未被该消费组处理。Lag 不是消息丢失，而是消费积压：",[95,6159,6162],{"className":6160,"code":6161,"language":100,"meta":101},[98],"生产速度 > 消费速度\n→ Lag 持续增大\n\n消费速度 > 生产速度\n→ Consumer 逐步追赶\n→ Lag 逐步减小\n",[22,6163,6161],{"__ignoreMap":101},[18,6165,6166],{},"Lag 不能只看某一时刻的绝对值，还要观察增长趋势、积压持续时间和业务允许的最大延迟。同样数量的 Lag，在每秒几条和每秒几十万条的 Topic 中代表的时间延迟完全不同。",[18,6168,6169],{},"如果 Lag 长期增长，可能是消费者处理变慢、下游故障、分区热点、Consumer 数量不足或频繁重平衡。若积压时间超过 Topic 的数据保留期限，旧消息可能已经被清理，消费者就不能再依靠 Kafka 把这部分数据完整追回。",[18,6171,6172],{},"Fetch 请求支持批量拉取和长轮询：",[95,6174,6176],{"className":4553,"code":6175,"language":4555,"meta":101,"style":101},"fetch.min.bytes=1\nfetch.max.wait.ms=500\n",[22,6177,6178,6186],{"__ignoreMap":101},[141,6179,6180,6183],{"class":143,"line":144},[141,6181,6182],{"class":151},"fetch.min.bytes",[141,6184,6185],{"class":147},"=1\n",[141,6187,6188,6191],{"class":143,"line":165},[141,6189,6190],{"class":151},"fetch.max.wait.ms",[141,6192,6193],{"class":147},"=500\n",[18,6195,6196],{},"Broker 暂时没有足够数据时，可以等待一段时间再响应，避免消费者无数据时频繁空轮询；流量较高时，又可以一次返回较大的批次。",[14,6198,6200],{"id":6199},"三高可用副本isr-与故障转移","三、高可用：副本、ISR 与故障转移",[638,6202,6204],{"id":6203},"_1-每个-partition-可以有多个副本","1. 每个 Partition 可以有多个副本",[18,6206,6207],{},"假设副本因子为 3：",[95,6209,6212],{"className":6210,"code":6211,"language":100,"meta":101},[98],"Partition 0\n├── Leader：Broker A\n├── Follower：Broker B\n└── Follower：Broker C\n",[22,6213,6211],{"__ignoreMap":101},[18,6215,6216],{},"生产和普通消费请求由 Leader 处理，Follower 分别从 Leader 拉取并复制日志。多个 Follower 的同步是彼此独立的，不存在先同步 B、再由 B 同步 C 的固定顺序。",[18,6218,6219],{},"副本应尽量分散在不同 Broker；具备机架感知配置时，还可以跨机架放置，降低单机或单机架故障带来的影响。",[638,6221,6223],{"id":6222},"_2-isr-维护可安全选主的副本集合","2. ISR 维护可安全选主的副本集合",[18,6225,6226],{},"ISR 是 In-Sync Replicas，即当前与 Leader 保持同步的副本集合。Follower 故障或长时间落后时会被移出 ISR，重新追上后可以再次加入。",[95,6228,6231],{"className":6229,"code":6230,"language":100,"meta":101},[98],"正常：ISR = [A, B, C]\nC 落后：ISR = [A, B]\n",[22,6232,6230],{"__ignoreMap":101},[18,6234,6235],{},"Leader 故障后，Controller 会从符合条件的副本中选择新的 Leader。以 ISR 为基础进行选主，可以避免把明显缺少最新日志的副本直接作为新的数据源。",[638,6237,6239,6240,6242,6243],{"id":6238},"_3-acks-与-mininsyncreplicas","3. ",[22,6241,4491],{}," 与 ",[22,6244,4572],{},[18,6246,6247],{},"常见的高可靠组合是：",[95,6249,6251],{"className":6250,"code":4829,"language":100,"meta":101},[98],[22,6252,4829],{"__ignoreMap":101},[18,6254,6255],{},"含义是生产者等待当前 ISR 的确认，并且 ISR 至少要有两个副本，否则 Broker 拒绝写入。",[18,6257,6258],{},"这个配置体现了 CAP 取舍：副本不足时拒绝写入，会降低部分可用性，但可以避免在只剩单副本时继续写入并承担更高的数据丢失风险。",[638,6260,6262],{"id":6261},"_4-kraft-controller-quorum-保证控制面可用","4. KRaft Controller Quorum 保证控制面可用",[6264,6265,6267],"h4",{"id":6266},"kraft-controller-quorum-是什么","KRaft Controller Quorum 是什么",[18,6269,6270,6271,6274,6275,6278],{},"KRaft 是 Kafka 自己实现的元数据管理机制，用来替代早期依赖的 ZooKeeper。集群中会有若干个承担 ",[22,6272,6273],{},"controller"," 角色的节点，这些 Controller 组成一个基于 Raft 共识协议的 ",[64,6276,6277],{},"Controller Quorum","，即控制器仲裁组。",[18,6280,6281],{},"它们维护的是集群元数据，而不是普通 Topic 的业务消息：",[114,6283,6284,6287,6290,6293],{},[117,6285,6286],{},"Broker 注册、存活状态和节点信息。",[117,6288,6289],{},"Topic 与 Partition 的定义。",[117,6291,6292],{},"每个 Partition 的副本分配、Leader 和 ISR。",[117,6294,6295],{},"配置、配额以及其他集群级元数据。",[18,6297,6298],{},"这些变化会写入 KRaft 的集群元数据日志，并复制给 Quorum 中的其他 Controller。一次元数据变更获得多数 Controller 确认后才算提交，因此单个 Controller 故障不会导致已提交元数据丢失。",[18,6300,6301],{},"常见部署是 3 个或 5 个 Controller：",[95,6303,6306],{"className":6304,"code":6305,"language":100,"meta":101},[98],"3 个 Controller → 多数派为 2，可容忍 1 个故障\n5 个 Controller → 多数派为 3，可容忍 2 个故障\n",[22,6307,6305],{"__ignoreMap":101},[18,6309,6310],{},"如果存活 Controller 失去多数派，集群不能安全提交新的元数据变更。此时已有数据读写是否还能短暂继续，取决于具体操作和现有元数据状态，但创建 Topic、Partition Leader 调度等控制面操作会受到影响。",[6264,6312,6314],{"id":6313},"active-controller-是什么","Active Controller 是什么",[18,6316,6317,6318,6321],{},"Controller Quorum 在同一时刻会选出一个 Leader，Kafka 的文档和运行语境中通常称它为 ",[64,6319,6320],{},"Active Controller","。其他 Controller 作为 Follower 复制元数据日志，随时准备接管。",[95,6323,6326],{"className":6324,"code":6325,"language":100,"meta":101},[98],"Controller A：Active Controller\n├── 接收和处理元数据变更\n├── 管理 Broker 注册与故障\n├── 触发 Partition Leader 选举\n└── 把变更写入元数据日志\n\nController B、C：Follower Controllers\n├── 复制元数据日志\n└── Active Controller 故障后参与重新选举\n",[22,6327,6325],{"__ignoreMap":101},[18,6329,6330],{},"Active Controller 不是所有业务消息的入口，也不负责替 Broker 保存普通 Topic 数据。生产者和消费者仍然直接与 Partition Leader 所在的 Broker 通信。",[18,6332,6333],{},"需要明确区分两个层面：",[1309,6335,6336,6352],{},[1312,6337,6338],{},[1315,6339,6340,6343,6346,6349],{},[1318,6341,6342],{},"层面",[1318,6344,6345],{},"主要角色",[1318,6347,6348],{},"保存什么",[1318,6350,6351],{},"负责什么",[1328,6353,6354,6368],{},[1315,6355,6356,6359,6362,6365],{},[1333,6357,6358],{},"数据面",[1333,6360,6361],{},"Broker、Partition Leader\u002FFollower",[1333,6363,6364],{},"普通 Topic 的业务消息",[1333,6366,6367],{},"生产、消费、副本复制",[1315,6369,6370,6373,6376,6379],{},[1333,6371,6372],{},"控制面",[1333,6374,6375],{},"KRaft Controller Quorum",[1333,6377,6378],{},"集群元数据日志",[1333,6380,6381],{},"节点管理、元数据变更、Leader 调度",[18,6383,6384],{},"例如 Broker A 突然故障：",[95,6386,6389],{"className":6387,"code":6388,"language":100,"meta":101},[98],"Active Controller 感知 Broker A 失联\n→ 找出受影响的 Partition\n→ 从符合条件的副本中选择新 Leader\n→ 将选举结果写入元数据日志\n→ 多数 Controller 确认提交\n→ 向相关 Broker 发布新元数据\n→ 客户端刷新元数据并访问新 Leader\n",[22,6390,6388],{"__ignoreMap":101},[18,6392,6393],{},"如果 Active Controller 自身故障，剩余 Controller 会通过 Raft 重新选出新的 Active Controller。新节点已经复制了已提交的元数据日志，因此可以继续管理集群。",[638,6395,6397],{"id":6396},"_5-consumer-group-自动接管故障消费者的分区","5. Consumer Group 自动接管故障消费者的分区",[18,6399,6400],{},"消费者通过心跳维持组成员身份。如果某个 Consumer 崩溃或超时，Consumer Group 会重新分配它原来负责的 Partition，让其他 Consumer 接管。",[18,6402,6403],{},"消费进度保存在已提交的 Offset 中，因此新 Consumer 可以从相应位置继续处理：",[95,6405,6408],{"className":6406,"code":6407,"language":100,"meta":101},[98],"Consumer A 故障\n→ 触发重新分配\n→ Partition 交给 Consumer B\n→ B 从已提交 Offset 继续消费\n",[22,6409,6407],{"__ignoreMap":101},[18,6411,6412],{},"重平衡期间可能产生短暂停顿，所以高可用不等于无感切换。合理设置会话、心跳、处理时长，并避免频繁扩缩容，有助于减少重平衡影响。",[14,6414,6416],{"id":6415},"四三种能力如何协同","四、三种能力如何协同",[1309,6418,6419,6435],{},[1312,6420,6421],{},[1315,6422,6423,6426,6429,6432],{},[1318,6424,6425],{},"目标",[1318,6427,6428],{},"核心机制",[1318,6430,6431],{},"解决的问题",[1318,6433,6434],{},"主要代价",[1328,6436,6437,6451,6465],{},[1315,6438,6439,6442,6445,6448],{},[1333,6440,6441],{},"高并发",[1333,6443,6444],{},"多 Partition、多 Broker、Consumer Group",[1333,6446,6447],{},"并行生产、存储和消费",[1333,6449,6450],{},"分区与元数据管理成本",[1315,6452,6453,6456,6459,6462],{},[1333,6454,6455],{},"高性能",[1333,6457,6458],{},"顺序写、Page Cache、批处理、压缩、零拷贝",[1333,6460,6461],{},"降低 I\u002FO、复制和网络开销",[1333,6463,6464],{},"批处理延迟与 CPU 消耗",[1315,6466,6467,6470,6473,6476],{},[1333,6468,6469],{},"高可用",[1333,6471,6472],{},"多副本、ISR、Controller Quorum、故障转移",[1333,6474,6475],{},"节点故障后继续提供服务",[1333,6477,6478],{},"副本存储、网络与确认延迟",[18,6480,6481],{},"可以把整个链路理解为：",[95,6483,6486],{"className":6484,"code":6485,"language":100,"meta":101},[98],"消息按 Partition 分流\n→ Producer 批量发送\n→ Leader 顺序追加到日志\n→ Follower 并行复制\n→ 满足确认条件后返回\n→ Consumer Group 按 Partition 批量拉取\n",[22,6487,6485],{"__ignoreMap":101},[14,6489,6491],{"id":6490},"五为什么不能只靠增加分区提升性能","五、为什么不能只靠增加分区提升性能",[18,6493,6494],{},"分区是扩展能力的基础，但分区不是越多越好。分区数量增加会同时带来：",[114,6496,6497,6500,6503,6506,6509,6512],{},[117,6498,6499],{},"更多日志目录、Segment 和文件句柄。",[117,6501,6502],{},"更多副本复制任务。",[117,6504,6505],{},"更大的集群元数据。",[117,6507,6508],{},"更高的 Leader 选举和故障恢复成本。",[117,6510,6511],{},"Consumer Group 重平衡开销。",[117,6513,6514],{},"单 Key 顺序范围更难调整。",[18,6516,6517],{},"合理做法是根据目标吞吐量、单分区压测能力、消费者并行度、副本数和未来增长空间估算，而不是一次创建大量分区。",[18,6519,6520],{},"一个简化估算思路：",[95,6522,6525],{"className":6523,"code":6524,"language":100,"meta":101},[98],"分区数 ≥ max(\n 目标生产吞吐 \u002F 单分区生产吞吐,\n 目标消费吞吐 \u002F 单消费者单分区吞吐,\n 期望消费并行度\n)\n",[22,6526,6524],{"__ignoreMap":101},[18,6528,6529],{},"最终仍需要在接近生产环境的机器、网络、副本配置和消息大小下进行压测。",[14,6531,6533],{"id":6532},"六常见误区","六、常见误区",[638,6535,6537],{"id":6536},"误区一kafka-使用磁盘所以一定比内存消息队列慢","误区一：Kafka 使用磁盘，所以一定比内存消息队列慢",[18,6539,6540],{},"Kafka 采用顺序追加、Page Cache 和批处理，大量读写实际在操作系统缓存中完成。性能取决于访问模式，而不是简单由“使用磁盘”决定。",[638,6542,6544],{"id":6543},"误区二零拷贝让数据完全不发生复制","误区二：零拷贝让数据完全不发生复制",[18,6546,6547,6548,6550],{},"零拷贝是减少不必要的用户态复制，并非物理意义上的一次复制都没有；而且启用 SSL 时不会走 Kafka 文档描述的 ",[22,6549,5717],{}," 路径。",[638,6552,6554],{"id":6553},"误区三消费者越多消费速度一定越快","误区三：消费者越多，消费速度一定越快",[18,6556,6557],{},"同一消费组内，一个 Partition 同时只能交给一个 Consumer。Consumer 数超过 Partition 数后，多出的 Consumer 不会获得分区。",[638,6559,6561],{"id":6560},"误区四副本越多高可用越高且没有代价","误区四：副本越多，高可用越高且没有代价",[18,6563,6564],{},"更多副本会增加存储、网络复制和写确认成本。副本数应根据故障域和可靠性目标确定，常见三副本不代表所有场景都必须相同。",[638,6566,6568,6569,6571],{"id":6567},"误区五acksall-就代表所有配置副本都已写入","误区五：",[22,6570,4407],{}," 就代表所有配置副本都已写入",[18,6573,6574,6576,6577,4878],{},[22,6575,4407],{}," 等待的是当前 ISR，而不是所有配置副本。要避免 ISR 只剩一个副本时仍然成功写入，需要配合 ",[22,6578,4572],{},[14,6580,6582],{"id":6581},"七排查性能和可用性问题时看什么","七、排查性能和可用性问题时看什么",[638,6584,6585],{"id":6585},"生产端",[114,6587,6588,6591,6594],{},[117,6589,6590],{},"发送吞吐、请求延迟、错误率和重试次数。",[117,6592,6593],{},"批次大小、压缩率和缓冲区等待。",[117,6595,6596],{},"消息 Key 是否造成分区流量倾斜。",[638,6598,6600],{"id":6599},"broker","Broker",[114,6602,6603,6606,6609,6611],{},[117,6604,6605],{},"各 Broker、Partition 和 Leader 的流量是否均衡。",[117,6607,6608],{},"磁盘利用率、磁盘延迟、网络带宽和请求队列。",[117,6610,5587],{},[117,6612,6613],{},"Page Cache 命中效果和系统是否发生 Swap。",[638,6615,6616],{"id":6616},"消费端",[114,6618,6619,6622,6625,6628],{},[117,6620,6621],{},"Consumer Lag 及其增长速度。",[117,6623,6624],{},"单条消息处理耗时和批次处理耗时。",[117,6626,6627],{},"Consumer 数量与 Partition 数量是否匹配。",[117,6629,6630],{},"重平衡次数、心跳超时和 Offset 提交失败。",[14,6632,5605],{"id":5605},[114,6634,6635,6641,6648,6655,6660,6665,6670],{},[117,6636,6637],{},[73,6638,6640],{"href":5633,"rel":6639},[1876],"Apache Kafka Design",[117,6642,6643],{},[73,6644,6647],{"href":6645,"rel":6646},"https:\u002F\u002Fkafka.apache.org\u002F41\u002Foperations\u002Fkraft\u002F",[1876],"Apache Kafka KRaft",[117,6649,6650],{},[73,6651,6654],{"href":6652,"rel":6653},"https:\u002F\u002Fkafka.apache.org\u002F41\u002Fimplementation\u002Fmessage-format\u002F",[1876],"Apache Kafka Message Format",[117,6656,6657],{},[73,6658,5614],{"href":5612,"rel":6659},[1876],[117,6661,6662],{},[73,6663,5628],{"href":5626,"rel":6664},[1876],[117,6666,6667],{},[73,6668,5621],{"href":5619,"rel":6669},[1876],[117,6671,6672],{},[73,6673,5642],{"href":5640,"rel":6674},[1876],[14,6676,3391],{"id":3391},[114,6678,6679,6684],{},[117,6680,6681],{},[73,6682,4392],{"href":6683},"\u002Fwiki\u002Fjava\u002Fkafka-message-loss-prevention\u002F",[117,6685,6686],{},[73,6687,6689],{"href":6688},"\u002Fwiki\u002Fjava\u002Fkafka-message-backlog-handling\u002F","Kafka 消息积压如何处理",[1907,6691,6692],{},"html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"title":101,"searchDepth":165,"depth":165,"links":6694},[6695,6696,6697,6698,6704,6713,6721,6722,6723,6731,6736,6737],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":5765,"depth":165,"text":5766,"children":6699},[6700,6701,6702,6703],{"id":5769,"depth":210,"text":5770},{"id":5792,"depth":210,"text":5793},{"id":5816,"depth":210,"text":5817},{"id":5834,"depth":210,"text":5835},{"id":5844,"depth":165,"text":5845,"children":6705},[6706,6707,6708,6709,6710,6711,6712],{"id":5848,"depth":210,"text":5849},{"id":5864,"depth":210,"text":5865},{"id":5900,"depth":210,"text":5901},{"id":5936,"depth":210,"text":5937},{"id":6033,"depth":210,"text":6034},{"id":6074,"depth":210,"text":6075},{"id":6133,"depth":210,"text":6134},{"id":6199,"depth":165,"text":6200,"children":6714},[6715,6716,6717,6719,6720],{"id":6203,"depth":210,"text":6204},{"id":6222,"depth":210,"text":6223},{"id":6238,"depth":210,"text":6718},"3. acks 与 min.insync.replicas",{"id":6261,"depth":210,"text":6262},{"id":6396,"depth":210,"text":6397},{"id":6415,"depth":165,"text":6416},{"id":6490,"depth":165,"text":6491},{"id":6532,"depth":165,"text":6533,"children":6724},[6725,6726,6727,6728,6729],{"id":6536,"depth":210,"text":6537},{"id":6543,"depth":210,"text":6544},{"id":6553,"depth":210,"text":6554},{"id":6560,"depth":210,"text":6561},{"id":6567,"depth":210,"text":6730},"误区五：acks=all 就代表所有配置副本都已写入",{"id":6581,"depth":165,"text":6582,"children":6732},[6733,6734,6735],{"id":6585,"depth":210,"text":6585},{"id":6599,"depth":210,"text":6600},{"id":6616,"depth":210,"text":6616},{"id":5605,"depth":165,"text":5605},{"id":3391,"depth":165,"text":3391},"wiki:java:kafka-high-concurrency-performance-availability","从分区并行、顺序写、Page Cache、批处理、零拷贝、副本与 ISR 等机制，系统理解 Kafka 高吞吐与高可用架构。",{},73,"\u002Fjava\u002Fkafka-high-concurrency-performance-availability",{"title":5702,"description":6739},"java\u002Fkafka-high-concurrency-performance-availability","qNGjCN5U7STnjw0cnfrIs6bM77HfEAuGKTcJPBrUgY8",{"id":6747,"title":6689,"body":6748,"commentId":8100,"description":8101,"difficulty":3462,"draft":1943,"extension":1944,"meta":8102,"navigation":206,"order":8103,"path":8104,"section":1948,"seo":8105,"stem":8106,"updated":5698,"__hash__":8107},"java\u002Fjava\u002Fkafka-message-backlog-handling.md",{"type":7,"value":6749,"toc":8053},[6750,6753,6755,6760,6762,6769,6771,6780,6782,6785,6791,6794,6798,6801,6804,6809,6811,6817,6820,6823,6894,6897,6900,6906,6909,6915,6918,6921,6925,6929,6935,6938,6942,6945,6968,6975,6979,6982,7002,7005,7011,7014,7018,7021,7024,7030,7033,7037,7040,7057,7060,7064,7068,7071,7077,7080,7084,7087,7101,7104,7107,7113,7116,7120,7123,7126,7129,7133,7137,7140,7143,7149,7152,7156,7159,7182,7184,7190,7195,7198,7204,7207,7210,7227,7230,7234,7237,7276,7279,7304,7308,7311,7317,7320,7326,7329,7339,7342,7348,7351,7359,7373,7382,7386,7399,7402,7408,7412,7415,7421,7424,7430,7433,7436,7439,7442,7445,7476,7479,7483,7487,7490,7493,7500,7503,7507,7510,7513,7519,7522,7528,7531,7534,7539,7542,7545,7549,7555,7558,7562,7568,7574,7577,7580,7594,7598,7601,7607,7610,7614,7617,7620,7626,7629,7649,7652,7656,7659,7665,7668,7682,7685,7689,7692,7698,7701,7707,7710,7716,7718,7724,7727,7733,7737,7740,7747,7750,7767,7770,7774,7777,7780,7837,7844,7897,7900,7903,7909,7915,7918,7921,7927,7930,7934,7937,7960,7964,7968,7971,7978,7981,7985,7988,7992,7999,8002,8006,8009,8011,8037,8039,8050],[10,6751,6689],{"id":6752},"kafka-消息积压如何处理",[14,6754,16],{"id":16},[59,6756,6757],{},[18,6758,6759],{},"Kafka 消息积压不能一上来就盲目增加消费者，首先要确认积压范围和原因：观察各 Partition 的 Consumer Lag、生产速率、消费速率、消费者存活状态、重平衡、处理耗时和下游依赖。如果消费实例异常或下游故障，应先恢复服务；如果生产速度持续大于消费速度，需要对非核心生产流量限流，同时扩容消费者，但同一消费组的有效并行度不会超过 Partition 数量。如果单条处理过慢，应通过批量写库、减少同步 RPC、优化慢 SQL 或使用受控的异步处理提高单实例吞吐；如果只有个别 Partition 积压，要检查消息 Key 是否造成热点；如果被异常消息反复阻塞，需要有限重试后进入死信或人工补偿。恢复时间可以用“积压量 ÷（消费速率－生产速率）”估算，只有消费能力大于生产速度，积压才会真正下降。Offset 跳到最新只能在业务明确同意丢弃旧消息时使用，不能作为常规解决方案。",[18,6761,57],{},[59,6763,6764],{},[18,6765,6766],{},[64,6767,6768],{},"先判断为什么消费速度落后，再从减少流入、恢复异常、提升单实例吞吐和增加有效并行度四个方向处理。",[14,6770,69],{"id":69},[18,6772,6773],{},[73,6774,6777],{"href":6775,"target":76,"rel":6776},"\u002Fimages\u002Fwiki\u002Fjava\u002Fkafka-message-backlog-handling.svg",[78,79],[81,6778],{"src":6775,"alt":6779},"Kafka 消息积压排查与处理流程",[14,6781,86],{"id":86},[18,6783,6784],{},"Kafka 消息积压的本质是：",[95,6786,6789],{"className":6787,"code":6788,"language":100,"meta":101},[98],"一段时间内的生产速度\n>\n一段时间内的有效消费速度\n",[22,6790,6788],{"__ignoreMap":101},[18,6792,6793],{},"积压不是单一故障类型，它可能由突发流量、消费者异常、下游变慢、分区热点或异常消息阻塞引起。不同原因的处理方式完全不同。",[14,6795,6797],{"id":6796},"一什么是-kafka-消息积压","一、什么是 Kafka 消息积压",[18,6799,6800],{},"每个 Partition 中的消息都有 Offset。生产者持续向日志末尾写入，消费组通过已提交 Offset 记录自己的处理进度。",[18,6802,6803],{},"监控消费组时，Consumer Lag 通常可以近似理解为：",[95,6805,6807],{"className":6806,"code":6144,"language":100,"meta":101},[98],[22,6808,6144],{"__ignoreMap":101},[18,6810,1398],{},[95,6812,6815],{"className":6813,"code":6814,"language":100,"meta":101},[98],"Partition Log End Offset：120000\n消费组已提交 Offset：95000\n\nLag = 120000 - 95000 = 25000\n",[22,6816,6814],{"__ignoreMap":101},[18,6818,6819],{},"表示这个消费组在该 Partition 上大约落后 25000 个 Offset。",[18,6821,6822],{},"需要同时观察三类指标：",[1309,6824,6825,6837],{},[1312,6826,6827],{},[1315,6828,6829,6832,6834],{},[1318,6830,6831],{},"指标",[1318,6833,2347],{},[1318,6835,6836],{},"判断价值",[1328,6838,6839,6850,6861,6872,6883],{},[1315,6840,6841,6844,6847],{},[1333,6842,6843],{},"当前 Lag",[1333,6845,6846],{},"还落后多少 Offset",[1333,6848,6849],{},"反映积压规模",[1315,6851,6852,6855,6858],{},[1333,6853,6854],{},"Lag 增长速度",[1333,6856,6857],{},"单位时间新增多少积压",[1333,6859,6860],{},"判断问题是否正在恶化",[1315,6862,6863,6866,6869],{},[1333,6864,6865],{},"最老未处理消息年龄",[1333,6867,6868],{},"最老待处理消息的时间戳距现在多久",[1333,6870,6871],{},"反映业务已经延迟多久",[1315,6873,6874,6877,6880],{},[1333,6875,6876],{},"积压字节量",[1333,6878,6879],{},"待处理消息占用的总字节数",[1333,6881,6882],{},"反映网络、磁盘和反序列化压力",[1315,6884,6885,6888,6891],{},[1333,6886,6887],{},"单条处理耗时",[1333,6889,6890],{},"处理一条或一批消息实际需要多久",[1333,6892,6893],{},"用于估算积压清空速度",[18,6895,6896],{},"只看 Lag 绝对值容易误判。例如同样积压 10 万条，在每秒消费 20 万条的系统里可能很快恢复，在每秒只消费 100 条的系统里则非常严重。",[18,6898,6899],{},"Lag 是 Offset 数量差，本身只表示“落后多少条记录”，不能直接等同于时间延迟。对于相同的 10 万 Lag，消费者处理速度越快，处理完现有积压所需的时间越短：",[95,6901,6904],{"className":6902,"code":6903,"language":100,"meta":101},[98],"处理现有积压所需时间\n≈ Lag ÷ 消费速度\n",[22,6905,6903],{"__ignoreMap":101},[18,6907,6908],{},"如果生产者仍在持续写入，要估算 Lag 整体降为 0 的时间，则应扣除生产速度：",[95,6910,6913],{"className":6911,"code":6912,"language":100,"meta":101},[98],"Lag 归零时间\n≈ Lag ÷（消费速度－生产速度）\n",[22,6914,6912],{"__ignoreMap":101},[18,6916,6917],{},"只有消费速度大于生产速度，Lag 才会持续下降。至于当前业务已经延迟多久，应直接查看最老未处理消息的时间戳，而不是只根据 Lag 推算。",[18,6919,6920],{},"消息大小影响的是积压字节量、网络传输和反序列化成本；单条处理复杂度影响的是消费速度。它们都很重要，但不能与 Lag 条数或消息年龄混为同一个指标。",[14,6922,6924],{"id":6923},"二先判断积压发生在哪里","二、先判断积压发生在哪里",[638,6926,6928],{"id":6927},"_1-是所有-partition-积压还是少数-partition-积压","1. 是所有 Partition 积压，还是少数 Partition 积压",[95,6930,6933],{"className":6931,"code":6932,"language":100,"meta":101},[98],"所有 Partition 的 Lag 都增长\n→ 更可能是整体消费能力不足、消费者异常或下游故障\n\n只有少数 Partition 的 Lag 很高\n→ 更可能是 Key 倾斜、热点业务或个别异常消息\n",[22,6934,6932],{"__ignoreMap":101},[18,6936,6937],{},"不能只看 Topic 的总 Lag。总数会掩盖单个热点 Partition，应同时查看每个 Partition 的 Lag、生产速率和消费速率。",[638,6939,6941],{"id":6940},"_2-消费者是否正常工作","2. 消费者是否正常工作",[18,6943,6944],{},"先检查：",[114,6946,6947,6950,6953,6956,6962,6965],{},[117,6948,6949],{},"消费实例是否存活，是否频繁重启。",[117,6951,6952],{},"Consumer Group 中是否存在空闲或反复加入、退出的成员。",[117,6954,6955],{},"是否频繁发生重平衡。",[117,6957,6958,6961],{},[22,6959,6960],{},"poll()"," 是否长时间没有被调用。",[117,6963,6964],{},"Offset 是否持续推进。",[117,6966,6967],{},"消费日志中是否存在反序列化、鉴权、提交 Offset 或业务异常。",[18,6969,6970,6971,6974],{},"如果业务处理时间超过 ",[22,6972,6973],{},"max.poll.interval.ms","，消费者会被认为没有正常推进消费，Partition 可能被重新分配。消费者不断处理、超时、重平衡，又可能造成更严重的积压。",[638,6976,6978],{"id":6977},"_3-单条消息处理是否变慢","3. 单条消息处理是否变慢",[18,6980,6981],{},"Kafka 消费本身往往不是最慢的部分，真正瓶颈通常在业务逻辑：",[114,6983,6984,6987,6990,6993,6996,6999],{},[117,6985,6986],{},"数据库慢 SQL、锁等待或连接池耗尽。",[117,6988,6989],{},"调用外部 RPC 超时。",[117,6991,6992],{},"每条消息单独写库，缺少批处理。",[117,6994,6995],{},"序列化、解压或大对象处理消耗 CPU。",[117,6997,6998],{},"消费逻辑加了粒度过大的锁。",[117,7000,7001],{},"下游 Elasticsearch、Redis 或第三方接口限流。",[18,7003,7004],{},"应把消费耗时拆分为：",[95,7006,7009],{"className":7007,"code":7008,"language":100,"meta":101},[98],"拉取耗时\n+ 反序列化耗时\n+ 业务计算耗时\n+ 数据库 \u002F RPC \u002F 下游写入耗时\n+ Offset 提交耗时\n",[22,7010,7008],{"__ignoreMap":101},[18,7012,7013],{},"只有找到主要耗时，优化才有方向。",[638,7015,7017],{"id":7016},"_4-是否被毒消息阻塞","4. 是否被“毒消息”阻塞",[18,7019,7020],{},"毒消息是指某条数据因为格式错误、业务状态异常或下游约束问题，每次消费都会失败。",[18,7022,7023],{},"如果代码采用无限重试：",[95,7025,7028],{"className":7026,"code":7027,"language":100,"meta":101},[98],"消费失败\n→ 立即重试\n→ 再次失败\n→ 一直占住当前 Partition\n",[22,7029,7027],{"__ignoreMap":101},[18,7031,7032],{},"该 Partition 后续所有消息都可能无法继续处理，表现为单分区 Lag 持续增大。",[638,7034,7036],{"id":7035},"_5-broker-或基础设施是否成为瓶颈","5. Broker 或基础设施是否成为瓶颈",[18,7038,7039],{},"还要检查：",[114,7041,7042,7045,7048,7051,7054],{},[117,7043,7044],{},"Broker 磁盘延迟、网络带宽和 CPU。",[117,7046,7047],{},"Fetch 请求延迟和错误率。",[117,7049,7050],{},"ISR 收缩、离线分区和副本同步异常。",[117,7052,7053],{},"消费者所在机器的 CPU、内存、GC 和网络。",[117,7055,7056],{},"是否发生跨机房访问或网络抖动。",[18,7058,7059],{},"如果 Broker 或网络已经饱和，单纯增加 Consumer 可能只会制造更多请求和竞争。",[14,7061,7063],{"id":7062},"三紧急处理先止住-lag-增长","三、紧急处理：先止住 Lag 增长",[638,7065,7067],{"id":7066},"_1-恢复异常消费者和下游","1. 恢复异常消费者和下游",[18,7069,7070],{},"如果积压源于实例宕机、数据库故障或下游超时，应优先恢复根因：",[95,7072,7075],{"className":7073,"code":7074,"language":100,"meta":101},[98],"恢复消费实例\n→ 恢复数据库 \u002F RPC \u002F 下游\n→ 确认 Offset 开始推进\n→ 再评估是否需要扩容\n",[22,7076,7074],{"__ignoreMap":101},[18,7078,7079],{},"下游仍不可用时强行增加消费者，只会放大连接数、重试和超时流量。",[638,7081,7083],{"id":7082},"_2-对非核心生产流量限流或降级","2. 对非核心生产流量限流或降级",[18,7085,7086],{},"如果生产速度仍在持续上升，而消费端已经满负荷，可以在业务允许时：",[114,7088,7089,7092,7095,7098],{},[117,7090,7091],{},"限制非核心事件的生产速率。",[117,7093,7094],{},"暂停可延迟的定时任务和批量导入。",[117,7096,7097],{},"合并低价值事件。",[117,7099,7100],{},"对非核心功能降级。",[18,7102,7103],{},"这不是最终解决方案，但能降低流入速度，给消费端争取恢复窗口。",[18,7105,7106],{},"这里的“合并低价值事件”，不是随意删除消息，而是对业务允许只保留最终状态或聚合结果的事件进行压缩。例如：",[95,7108,7111],{"className":7109,"code":7110,"language":100,"meta":101},[98],"同一个商品在 1 秒内连续产生 20 次缓存刷新通知\n→ 只保留一次刷新通知\n\n同一设备连续上报多次进度：10%、20%、30%\n→ 如果业务只关心最新进度，可以只发送 30%\n\n大量指标增量事件\n→ 在生产端按时间窗口汇总后，发送一条聚合结果\n",[22,7112,7110],{"__ignoreMap":101},[18,7114,7115],{},"合并前必须先定义清楚业务语义，包括按什么 Key 合并、合并时间窗口多长、保留最新值还是累计值，以及异常时如何补偿。订单状态流转、支付、账户流水、库存扣减、审计日志等每条事件都具有独立业务意义，不能使用这种方式合并。",[638,7117,7119],{"id":7118},"_3-确认消息保留时间是否足够","3. 确认消息保留时间是否足够",[18,7121,7122],{},"积压消息依赖 Kafka 的日志保留策略。如果预计追赶需要数小时或数天，应确认 Topic 的保留时间和磁盘空间是否足够。",[18,7124,7125],{},"如果最老未消费消息超过保留期限，旧日志可能被清理。此时即使消费者恢复，也无法从 Kafka 读取已经删除的数据。",[18,7127,7128],{},"紧急情况下可以评估临时延长保留时间，但必须同步评估 Broker 磁盘容量，避免积压尚未解决又触发磁盘告警。",[14,7130,7132],{"id":7131},"四提升消费能力","四、提升消费能力",[638,7134,7136],{"id":7135},"_1-增加-consumer-实例","1. 增加 Consumer 实例",[18,7138,7139],{},"增加同一 Consumer Group 中的实例，可以让更多 Partition 并行消费。",[18,7141,7142],{},"但有效并行度受 Partition 数量限制：",[95,7144,7147],{"className":7145,"code":7146,"language":100,"meta":101},[98],"8 个 Partition + 4 个 Consumer\n→ 可以继续扩容\n\n8 个 Partition + 8 个 Consumer\n→ 已接近分区级并行上限\n\n8 个 Partition + 12 个 Consumer\n→ 约 4 个 Consumer 无 Partition 可处理\n",[22,7148,7146],{"__ignoreMap":101},[18,7150,7151],{},"因此扩容前要同时查看当前 Partition 数量、消费者数量和分配情况。",[638,7153,7155],{"id":7154},"_2-优化单实例处理吞吐","2. 优化单实例处理吞吐",[18,7157,7158],{},"常见优化方式：",[114,7160,7161,7164,7167,7170,7173,7176,7179],{},[117,7162,7163],{},"把逐条写数据库改为批量写入。",[117,7165,7166],{},"合并相同业务 Key 的重复更新。",[117,7168,7169],{},"优化 SQL、索引和事务范围。",[117,7171,7172],{},"减少消费线程中的同步远程调用。",[117,7174,7175],{},"对可并行步骤使用有界线程池。",[117,7177,7178],{},"复用连接和客户端，避免每条消息重复创建。",[117,7180,7181],{},"降低无必要的日志和对象序列化开销。",[18,7183,1398],{},[95,7185,7188],{"className":7186,"code":7187,"language":100,"meta":101},[98],"原方案：\n每条消息 → 一次数据库事务\n\n优化后：\n一批消息 → 分组校验 → 批量写入 → 提交对应 Offset\n",[22,7189,7187],{"__ignoreMap":101},[18,7191,7192,7193,4878],{},"批量越大不一定越好。批次过大会增加内存占用、事务时间和失败重试成本，还可能让一次处理时间超过 ",[22,7194,6973],{},[18,7196,7197],{},"这里的“同步远程调用”，是指消费线程发送 RPC 或 HTTP 请求后，必须等待对方返回才能继续处理下一条消息：",[95,7199,7202],{"className":7200,"code":7201,"language":100,"meta":101},[98],"消费一条消息\n→ 调用远程库存服务\n→ 阻塞等待 50 ms\n→ 收到结果\n→ 再处理下一条消息\n",[22,7203,7201],{"__ignoreMap":101},[18,7205,7206],{},"即使本地计算只需要 1 ms，线程的大部分时间也消耗在网络等待上。如果每条消息都串行调用一次远程服务，单线程理论吞吐很容易被远程调用耗时限制。",[18,7208,7209],{},"“减少同步 RPC”可以从以下方向处理：",[114,7211,7212,7215,7218,7221,7224],{},[117,7213,7214],{},"把逐条调用改为批量接口，例如一次查询或提交 100 条。",[117,7216,7217],{},"对可复用且允许短时间不一致的数据使用本地缓存，减少重复查询。",[117,7219,7220],{},"把互不依赖的调用改成受控并发，但必须限制并发数，避免压垮下游。",[117,7222,7223],{},"将通知、埋点等非核心副作用发送到下游 Topic，由独立消费者异步执行。",[117,7225,7226],{},"合理设置超时、熔断和连接池，避免故障调用长期占住消费线程。",[18,7228,7229],{},"如果必须拿到远程结果才能保证当前消息处理正确，就不能为了吞吐简单删除该 RPC。此时更重要的是批量化、限制并发、幂等和下游容量治理。",[638,7231,7233],{"id":7232},"_3-谨慎调整消费参数","3. 谨慎调整消费参数",[18,7235,7236],{},"常见参数包括：",[95,7238,7240],{"className":4553,"code":7239,"language":4555,"meta":101,"style":101},"max.poll.records=500\nmax.poll.interval.ms=300000\nfetch.min.bytes=1\nfetch.max.wait.ms=500\nmax.partition.fetch.bytes=1048576\n",[22,7241,7242,7249,7256,7262,7268],{"__ignoreMap":101},[141,7243,7244,7247],{"class":143,"line":144},[141,7245,7246],{"class":151},"max.poll.records",[141,7248,6193],{"class":147},[141,7250,7251,7253],{"class":143,"line":165},[141,7252,6973],{"class":151},[141,7254,7255],{"class":147},"=300000\n",[141,7257,7258,7260],{"class":143,"line":210},[141,7259,6182],{"class":151},[141,7261,6185],{"class":147},[141,7263,7264,7266],{"class":143,"line":219},[141,7265,6190],{"class":151},[141,7267,6193],{"class":147},[141,7269,7270,7273],{"class":143,"line":234},[141,7271,7272],{"class":151},"max.partition.fetch.bytes",[141,7274,7275],{"class":147},"=1048576\n",[18,7277,7278],{},"调整原则：",[114,7280,7281,7290,7296,7301],{},[117,7282,7283,7284,7286,7287,7289],{},"如果一批消息处理不完，应适当减小 ",[22,7285,7246],{},"，或优化处理速度，而不是只把 ",[22,7288,6973],{}," 调得无限大。",[117,7291,7292,7293,7295],{},"增大 ",[22,7294,6182],{}," 可以提高批量拉取效率，但会增加低流量时的等待延迟。",[117,7297,7298,7300],{},[22,7299,7272],{}," 过小可能限制大批次拉取，但调大后要评估客户端内存。",[117,7302,7303],{},"参数优化只能降低 Kafka 拉取开销，无法解决数据库或 RPC 本身处理缓慢。",[638,7305,7307],{"id":7306},"_4-异步处理必须有边界","4. 异步处理必须有边界",[18,7309,7310],{},"一种常见设计是由 Poll 线程负责拉取，再把消息交给工作线程池处理：",[95,7312,7315],{"className":7313,"code":7314,"language":100,"meta":101},[98],"Poll 线程\n→ 有界队列\n→ 工作线程池\n→ 处理完成\n→ 按 Partition 推进可安全提交的 Offset\n",[22,7316,7314],{"__ignoreMap":101},[18,7318,7319],{},"为什么必须使用有界队列？假设 Kafka 已经积压 100 万条，Poll 线程仍然高速拉取并塞入无界队列，而工作线程每秒只能处理 100 条，那么积压只是从 Kafka 的磁盘日志转移到了 JVM 堆内存。结果可能是：",[95,7321,7324],{"className":7322,"code":7323,"language":100,"meta":101},[98],"队列持续增长\n→ 堆内存占用上升\n→ Full GC 频繁\n→ 消费进程响应变慢甚至 OOM\n→ 未提交的内存任务随进程退出而丢失并被重新投递\n",[22,7325,7323],{"__ignoreMap":101},[18,7327,7328],{},"Kafka 本身就是持久化队列，没有必要把尚未具备处理能力的消息提前搬进易失的 JVM 内存。",[6264,7330,7332,7333,2818,7336],{"id":7331},"使用高低水位控制-pause-和-resume","使用高、低水位控制 ",[22,7334,7335],{},"pause()",[22,7337,7338],{},"resume()",[18,7340,7341],{},"可以为队列设置容量和两个阈值。例如队列容量为 10000：",[95,7343,7346],{"className":7344,"code":7345,"language":100,"meta":101},[98],"高水位：8000\n队列达到高水位\n→ Poll 线程对相关 Partition 调用 pause()\n→ 后续 poll() 暂停返回这些 Partition 的新消息\n\n低水位：3000\n工作线程处理后，队列下降到低水位\n→ Poll 线程调用 resume()\n→ 后续 poll() 重新拉取这些 Partition\n",[22,7347,7345],{"__ignoreMap":101},[18,7349,7350],{},"使用两个不同阈值是为了避免队列在一个临界值附近反复暂停、恢复。阈值不能照搬固定数字，应根据单条消息大小、堆内存、工作线程数和峰值处理耗时进行容量评估。",[18,7352,7353,7355,7356,7358],{},[22,7354,7335],{}," 的含义是暂停指定 Partition 在后续 ",[22,7357,6960],{}," 中返回新记录，它不会：",[114,7360,7361,7364,7367,7370],{},[117,7362,7363],{},"取消当前 Partition 的分配。",[117,7365,7366],{},"自动提交 Offset。",[117,7368,7369],{},"主动触发 Consumer Group 重平衡。",[117,7371,7372],{},"清除已经拉取并放入本地队列的消息。",[18,7374,7375,7376,7378,7379,7381],{},"暂停期间仍然必须持续调用 ",[22,7377,6960],{},"，让 Consumer 处理心跳、协调和重平衡事件。不能因为所有分区都已暂停，就让 Poll 线程长时间睡眠或等待队列清空，否则仍可能超过 ",[22,7380,6973],{}," 并失去分区。",[6264,7383,7385],{"id":7384},"只能由-consumer-所在线程控制拉取","只能由 Consumer 所在线程控制拉取",[18,7387,7388,7391,7392,44,7394,44,7396,7398],{},[22,7389,7390],{},"KafkaConsumer"," 不是线程安全的。通常由唯一的 Poll 线程持有并调用 ",[22,7393,6960],{},[22,7395,7335],{},[22,7397,7338],{}," 和提交 Offset；工作线程只处理业务，并把“完成结果”写回一个线程安全的完成队列。工作线程不能直接操作同一个 Consumer。",[18,7400,7401],{},"伪代码可以理解为：",[95,7403,7406],{"className":7404,"code":7405,"language":100,"meta":101},[98],"Poll 线程循环：\n 读取工作线程上报的完成结果\n 推进每个 Partition 的连续成功 Offset\n 根据队列水位执行 pause \u002F resume\n poll() 拉取允许继续消费的 Partition\n 把记录投递到对应的有界工作队列\n\n工作线程：\n 处理业务\n 成功或失败结果写回完成队列\n 不直接调用 KafkaConsumer\n",[22,7407,7405],{"__ignoreMap":101},[6264,7409,7411],{"id":7410},"为什么要按-partition-提交连续成功区间","为什么要按 Partition 提交“连续成功区间”",[18,7413,7414],{},"假设同一 Partition 拉取到：",[95,7416,7419],{"className":7417,"code":7418,"language":100,"meta":101},[98],"Offset 100、101、102\n",[22,7420,7418],{"__ignoreMap":101},[18,7422,7423],{},"并发处理结果是：",[95,7425,7428],{"className":7426,"code":7427,"language":100,"meta":101},[98],"100 成功\n101 仍在处理\n102 成功\n",[22,7429,7427],{"__ignoreMap":101},[18,7431,7432],{},"此时最多只能提交 101，也就是声明 100 已处理完成；不能提交 103。否则进程在 101 完成前崩溃，重启后会从 103 开始，101 就可能被永久跳过。",[18,7434,7435],{},"只有 101 也成功后，100～102 形成连续成功区间，才能提交 103。若业务要求同一 Partition 严格有序，最简单的方式是同一 Partition 串行处理，不要并发执行。",[6264,7437,7438],{"id":7438},"重平衡时还要处理本地未完成任务",[18,7440,7441],{},"发生 Partition 撤销时，应停止向被撤销 Partition 的队列继续投递，并在回调允许的时间内提交已经连续处理成功的 Offset。尚未完成或来不及安全提交的任务，应允许新 Consumer 从旧 Offset 重新消费，因此业务处理必须具备幂等性。",[18,7443,7444],{},"需要共同遵守的约束包括：",[114,7446,7447,7452,7455,7462,7467,7470,7473],{},[117,7448,7449,7451],{},[22,7450,7390],{}," 本身不是线程安全的，不能让多个工作线程同时操作同一个 Consumer。",[117,7453,7454],{},"队列必须有界，不能把 Kafka 的积压无上限转移到 JVM 内存。",[117,7456,7457,6242,7459,7461],{},[22,7458,7335],{},[22,7460,7338],{}," 应由 Poll 线程执行，工作线程通过控制信号提出请求。",[117,7463,7464,7465,4878],{},"即使 Partition 已暂停，Poll 线程也要持续执行 ",[22,7466,6960],{},[117,7468,7469],{},"Offset 必须在消息真正处理成功后提交。",[117,7471,7472],{},"同一 Partition 如果要求严格顺序，不能让后面的消息先于前面的消息产生业务效果。",[117,7474,7475],{},"并发完成后只能提交“连续成功区间”的下一个 Offset，不能跨过尚未完成或失败的消息。",[18,7477,7478],{},"异步化能提高吞吐，但会显著增加 Offset、顺序和失败处理的复杂度。",[14,7480,7482],{"id":7481},"五partition-不够时怎么办","五、Partition 不够时怎么办",[638,7484,7486],{"id":7485},"_1-增加-partition-主要提升未来并行度","1. 增加 Partition 主要提升未来并行度",[18,7488,7489],{},"如果 Consumer 数量已经等于 Partition 数量，且单分区处理能力也接近上限，可以评估增加 Partition。",[18,7491,7492],{},"但要明确：",[59,7494,7495],{},[18,7496,7497],{},[64,7498,7499],{},"给 Topic 新增 Partition，不会把旧 Partition 中已经积压的消息自动重新分布到新 Partition。",[18,7501,7502],{},"新 Partition 主要承接之后产生的新消息。旧积压仍然留在原来的 Partition 中，仍需由对应消费者追赶。",[638,7504,7506],{"id":7505},"_2-增加-partition-可能改变-key-路由","2. 增加 Partition 可能改变 Key 路由",[18,7508,7509],{},"默认的 Key 哈希结果通常与 Partition 数量有关。增加 Partition 后，同一个 Key 的新消息可能进入不同于历史消息的 Partition，从而影响跨扩容时点的顺序假设。",[18,7511,7512],{},"例如为了便于理解，假设某个分区规则可以简化为：",[95,7514,7517],{"className":7515,"code":7516,"language":100,"meta":101},[98],"目标分区 = hash(key) % Partition 数量\n",[22,7518,7516],{"__ignoreMap":101},[18,7520,7521],{},"同一个 Key 的哈希值为 13：",[95,7523,7526],{"className":7524,"code":7525,"language":100,"meta":101},[98],"原来 4 个 Partition：13 % 4 = 1，写入 P1\n扩容到 8 个 Partition：13 % 8 = 5，新消息写入 P5\n",[22,7527,7525],{"__ignoreMap":101},[18,7529,7530],{},"扩容前已经写入 P1 的旧消息不会被搬到 P5。P1 和 P5 又可能由不同 Consumer 并行处理，因此 P5 中的新消息可能先于 P1 中的旧消息完成。这个风险不只是“扩容瞬间”存在，而是会持续到旧分区中的相关历史消息全部处理完毕。",[18,7532,7533],{},"所谓“消费端能否接受跨分区处理”，实际是在问：",[59,7535,7536],{},[18,7537,7538],{},"同一个业务 Key 的旧消息和新消息同时位于不同 Partition，并可能并行、乱序完成时，业务是否仍然正确？",[18,7540,7541],{},"如果事件是独立日志或幂等的最终状态覆盖，业务可能可以接受；如果事件依赖严格顺序，例如“创建订单 → 支付成功 → 关闭订单”，就不能直接接受。",[18,7543,7544],{},"如果业务依赖同一 Key 的严格顺序，常见选择有：",[6264,7546,7548],{"id":7547},"方案一排空旧消息后再扩分区","方案一：排空旧消息后再扩分区",[95,7550,7553],{"className":7551,"code":7552,"language":100,"meta":101},[98],"限制或暂停生产\n→ 等待旧 Topic 的相关消息处理完成\n→ 增加 Partition\n→ 恢复生产\n",[22,7554,7552],{"__ignoreMap":101},[18,7556,7557],{},"这种方式逻辑最清楚，但需要维护窗口，而且在高流量系统中可能很难完全停写。",[6264,7559,7561],{"id":7560},"方案二新建-topic-并进行受控切换","方案二：新建 Topic 并进行受控切换",[18,7563,7564,7565,4039],{},"例如创建具有目标分区数和新路由规则的 ",[22,7566,7567],{},"order-events-v2",[95,7569,7572],{"className":7570,"code":7571,"language":100,"meta":101},[98],"1. 创建并验证新 Topic\n2. 定义明确的切换时间、版本号或业务水位\n3. 新消息从切换点开始写入 v2\n4. v1 消费者继续处理切换点以前的旧消息\n5. 确认某个 Key 或全部旧消息越过安全水位后，再允许 v2 对应消息生效\n6. 完成核对后停止 v1，并保留回滚方案\n",[22,7573,7571],{"__ignoreMap":101},[18,7575,7576],{},"新建 Topic 的价值是把新旧路由、配置和消费组隔离开，便于验证与回滚；代价是必须设计双 Topic 切换、重复消息、遗漏检查和新旧 Offset 衔接。它不是 Kafka 自动迁移，而是业务自己完成的版本化切换。",[18,7578,7579],{},"因此扩分区前应明确回答：",[114,7581,7582,7585,7588,7591],{},[117,7583,7584],{},"分区器如何计算目标 Partition。",[117,7586,7587],{},"旧消息是否已经处理完成。",[117,7589,7590],{},"同一 Key 跨新旧 Partition 并行处理是否会破坏业务顺序。",[117,7592,7593],{},"是选择维护窗口排空旧消息，还是新建 Topic 做受控切换。",[638,7595,7597],{"id":7596},"_3-极端情况下建立临时加速链路","3. 极端情况下建立临时加速链路",[18,7599,7600],{},"当原 Topic 分区数严重不足、积压量巨大时，可以设计经过评审的临时方案：",[95,7602,7605],{"className":7603,"code":7604,"language":100,"meta":101},[98],"原 Topic\n→ 临时搬运程序\n→ 更高分区数的中转 Topic\n→ 临时扩容后的消费组\n→ 业务处理\n",[22,7606,7604],{"__ignoreMap":101},[18,7608,7609],{},"这会引入顺序、重复、Offset 衔接和回切问题，只适合经过完整设计和演练的场景，不能在生产事故中临时拍脑袋执行。",[14,7611,7613],{"id":7612},"六热点-partition-如何处理","六、热点 Partition 如何处理",[18,7615,7616],{},"如果只有少数 Partition 积压，需要检查消息 Key 分布。",[18,7618,7619],{},"例如所有消息都使用同一个固定 Key：",[95,7621,7624],{"className":7622,"code":7623,"language":100,"meta":101},[98],"key = \"default\"\n→ 所有消息进入同一 Partition\n→ 其他 Partition 空闲\n→ 单分区成为瓶颈\n",[22,7625,7623],{"__ignoreMap":101},[18,7627,7628],{},"解决方向包括：",[114,7630,7631,7634,7637,7643,7646],{},[117,7632,7633],{},"选择分布更均匀的业务 Key。",[117,7635,7636],{},"对非顺序场景取消固定 Key。",[117,7638,7639,7640,4878],{},"对热点业务 Key 做可控分片，例如 ",[22,7641,7642],{},"userId + shardNo",[117,7644,7645],{},"单独拆分热点租户或热点业务到独立 Topic。",[117,7647,7648],{},"优化该 Partition 对应消费者的单条处理耗时。",[18,7650,7651],{},"Key 拆分会改变顺序语义。原来同一 Key 的全局顺序，拆分后通常只能保证每个子 Key 内部有序。",[14,7653,7655],{"id":7654},"七毒消息和重试如何处理","七、毒消息和重试如何处理",[18,7657,7658],{},"不要让一条永远失败的消息无限阻塞 Partition。常见处理策略是：",[95,7660,7663],{"className":7661,"code":7662,"language":100,"meta":101},[98],"第一次失败\n→ 记录错误并有限重试\n→ 仍然失败\n→ 进入重试 Topic \u002F 死信 Topic\n→ 主消费链路继续\n→ 告警和人工补偿\n",[22,7664,7662],{"__ignoreMap":101},[18,7666,7667],{},"需要保留：",[114,7669,7670,7673,7676,7679],{},[117,7671,7672],{},"原始 Topic、Partition 和 Offset。",[117,7674,7675],{},"消息 Key、事件 ID 和原始内容。",[117,7677,7678],{},"异常原因和重试次数。",[117,7680,7681],{},"首次失败和最后失败时间。",[18,7683,7684],{},"如果业务要求同一 Key 严格顺序，就不能简单跳过失败消息继续处理后续消息。此时应暂停对应 Partition，优先修复或补偿该消息；这是吞吐与顺序之间的业务取舍。",[14,7686,7688],{"id":7687},"八如何估算多久能消化完积压","八、如何估算多久能消化完积压",[18,7690,7691],{},"设：",[95,7693,7696],{"className":7694,"code":7695,"language":100,"meta":101},[98],"B = 当前积压消息数\nP = 当前生产速度（条\u002F秒）\nC = 扩容后的稳定消费速度（条\u002F秒）\n",[22,7697,7695],{"__ignoreMap":101},[18,7699,7700],{},"只有：",[95,7702,7705],{"className":7703,"code":7704,"language":100,"meta":101},[98],"C > P\n",[22,7706,7704],{"__ignoreMap":101},[18,7708,7709],{},"积压才会下降。理论恢复时间约为：",[95,7711,7714],{"className":7712,"code":7713,"language":100,"meta":101},[98],"恢复时间 T = B \u002F (C - P)\n",[22,7715,7713],{"__ignoreMap":101},[18,7717,1398],{},[95,7719,7722],{"className":7720,"code":7721,"language":100,"meta":101},[98],"当前积压 B = 360 万条\n生产速度 P = 2000 条\u002F秒\n消费速度 C = 5000 条\u002F秒\n\n净消化速度 = 5000 - 2000 = 3000 条\u002F秒\n理论恢复时间 = 3600000 \u002F 3000 = 1200 秒\n≈ 20 分钟\n",[22,7723,7721],{"__ignoreMap":101},[18,7725,7726],{},"实际还要为重平衡、失败重试、下游波动和流量峰值预留余量。",[18,7728,4060,7729,7732],{},[22,7730,7731],{},"C \u003C= P","，无论运行多久都追不上，必须降低生产速率或提高有效消费能力。",[14,7734,7736],{"id":7735},"九offset-跳到最新为什么不是常规方案","九、Offset 跳到最新为什么不是常规方案",[18,7738,7739],{},"把消费组 Offset 重置到最新位置，确实可以让 Lag 迅速变成 0，但其本质是：",[59,7741,7742],{},[18,7743,7744],{},[64,7745,7746],{},"主动放弃尚未消费的历史消息。",[18,7748,7749],{},"只有同时满足以下条件才可以考虑：",[114,7751,7752,7755,7758,7761,7764],{},[117,7753,7754],{},"业务明确确认旧消息可以丢弃。",[117,7756,7757],{},"已评估对账、状态和下游影响。",[117,7759,7760],{},"已保留必要的审计或补偿数据。",[117,7762,7763],{},"操作前进行了 Dry Run，并确认 Topic、Consumer Group 和目标 Offset。",[117,7765,7766],{},"操作期间停止相关消费者，避免 Offset 并发变化。",[18,7768,7769],{},"资金、订单、库存等关键链路不能把重置 Offset 当作普通清积压手段。",[638,7771,7773],{"id":7772},"什么是-dry-run","什么是 Dry Run",[18,7775,7776],{},"Dry Run 就是“只预演，不执行”。它先计算并展示每个 Partition 将从哪个 Offset 调整到哪个 Offset，供操作人员核对 Topic、消费组、分区范围和目标位置，但不真正修改已提交 Offset。",[18,7778,7779],{},"例如将消费组预演重置到最新位置：",[95,7781,7785],{"className":7782,"code":7783,"language":7784,"meta":101,"style":101},"language-bash shiki shiki-themes github-light github-dark","bin\u002Fkafka-consumer-groups.sh \\\n --bootstrap-server kafka.example.com:9092 \\\n --group order-consumer-group \\\n --topic order-events \\\n --reset-offsets \\\n --to-latest\n","bash",[22,7786,7787,7795,7805,7815,7825,7832],{"__ignoreMap":101},[141,7788,7789,7792],{"class":143,"line":144},[141,7790,7791],{"class":158},"bin\u002Fkafka-consumer-groups.sh",[141,7793,7794],{"class":428}," \\\n",[141,7796,7797,7800,7803],{"class":143,"line":165},[141,7798,7799],{"class":428}," --bootstrap-server",[141,7801,7802],{"class":911}," kafka.example.com:9092",[141,7804,7794],{"class":428},[141,7806,7807,7810,7813],{"class":143,"line":210},[141,7808,7809],{"class":428}," --group",[141,7811,7812],{"class":911}," order-consumer-group",[141,7814,7794],{"class":428},[141,7816,7817,7820,7823],{"class":143,"line":219},[141,7818,7819],{"class":428}," --topic",[141,7821,7822],{"class":911}," order-events",[141,7824,7794],{"class":428},[141,7826,7827,7830],{"class":143,"line":234},[141,7828,7829],{"class":428}," --reset-offsets",[141,7831,7794],{"class":428},[141,7833,7834],{"class":143,"line":241},[141,7835,7836],{"class":428}," --to-latest\n",[18,7838,7839,7840,7843],{},"Kafka 4.1 的消费组工具默认只展示重置计划；确认结果无误后，显式增加 ",[22,7841,7842],{},"--execute"," 才会真正执行：",[95,7845,7847],{"className":7782,"code":7846,"language":7784,"meta":101,"style":101},"bin\u002Fkafka-consumer-groups.sh \\\n --bootstrap-server kafka.example.com:9092 \\\n --group order-consumer-group \\\n --topic order-events \\\n --reset-offsets \\\n --to-latest \\\n --execute\n",[22,7848,7849,7855,7863,7871,7879,7885,7892],{"__ignoreMap":101},[141,7850,7851,7853],{"class":143,"line":144},[141,7852,7791],{"class":158},[141,7854,7794],{"class":428},[141,7856,7857,7859,7861],{"class":143,"line":165},[141,7858,7799],{"class":428},[141,7860,7802],{"class":911},[141,7862,7794],{"class":428},[141,7864,7865,7867,7869],{"class":143,"line":210},[141,7866,7809],{"class":428},[141,7868,7812],{"class":911},[141,7870,7794],{"class":428},[141,7872,7873,7875,7877],{"class":143,"line":219},[141,7874,7819],{"class":428},[141,7876,7822],{"class":911},[141,7878,7794],{"class":428},[141,7880,7881,7883],{"class":143,"line":234},[141,7882,7829],{"class":428},[141,7884,7794],{"class":428},[141,7886,7887,7890],{"class":143,"line":241},[141,7888,7889],{"class":428}," --to-latest",[141,7891,7794],{"class":428},[141,7893,7894],{"class":143,"line":247},[141,7895,7896],{"class":428}," --execute\n",[18,7898,7899],{},"不同 Kafka 版本的工具参数可能略有差异，生产操作前应以实际部署版本的命令帮助和官方文档为准。",[638,7901,7902],{"id":7902},"为什么操作期间要停止消费者",[18,7904,7905,7906,7908],{},"活动消费者会继续执行 ",[22,7907,6960],{},"、处理消息并提交 Offset。如果管理人员同时重置 Offset，就可能发生竞态：",[95,7910,7913],{"className":7911,"code":7912,"language":100,"meta":101},[98],"管理员把 Offset 从 1000 重置到 5000\n→ 仍在运行的消费者随后提交自己内存中的旧进度 1200\n→ 重置结果被旧提交覆盖\n",[22,7914,7912],{"__ignoreMap":101},[18,7916,7917],{},"反过来也可能是消费者刚处理到 1300，管理员基于稍早看到的状态执行重置，导致已处理消息重复消费或尚未处理消息被跳过。活动成员还可能触发重平衡，使操作时看到的分区归属和 Offset 继续变化。",[18,7919,7920],{},"因此安全流程应是：",[95,7922,7925],{"className":7923,"code":7924,"language":100,"meta":101},[98],"停止该消费组的所有消费者\n→ 确认消费组已无活动成员\n→ 记录操作前 Offset\n→ 执行 Dry Run 并双人核对\n→ 使用 --execute 修改 Offset\n→ 再次查询并确认结果\n→ 启动消费者并观察消费位置\n",[22,7926,7924],{"__ignoreMap":101},[18,7928,7929],{},"这不仅是避免并发覆盖。Kafka 官方的消费组 Offset 重置说明也明确要求先确保消费实例处于非活动状态。",[14,7931,7933],{"id":7932},"十恢复后要做什么","十、恢复后要做什么",[18,7935,7936],{},"积压恢复不代表问题结束，还应完成：",[2489,7938,7939,7942,7945,7948,7951,7954,7957],{},[117,7940,7941],{},"复盘根因和时间线。",[117,7943,7944],{},"补充总 Lag、最大分区 Lag、时间 Lag 和增长率告警。",[117,7946,7947],{},"建立生产速度、消费速度和预计恢复时间看板。",[117,7949,7950],{},"对热点 Partition、毒消息和下游耗时建立专项监控。",[117,7952,7953],{},"按峰值流量进行容量压测，保留消费冗余。",[117,7955,7956],{},"演练消费者扩容、下游故障、重平衡和死信补偿。",[117,7958,7959],{},"核对积压期间是否发生消息过期、重复处理或业务遗漏。",[14,7961,7963],{"id":7962},"十一常见误区","十一、常见误区",[638,7965,7967],{"id":7966},"误区一积压就直接增加-consumer","误区一：积压就直接增加 Consumer",[18,7969,7970],{},"如果 Partition 数量不足、多数 Consumer 已空闲，或者瓶颈实际在数据库，增加 Consumer 不会解决问题，反而可能加剧下游压力。",[638,7972,7974,7975,7977],{"id":7973},"误区二把-maxpollrecords-调大就能提升吞吐","误区二：把 ",[22,7976,7246],{}," 调大就能提升吞吐",[18,7979,7980],{},"拉取更多消息不等于处理更快。批次过大还可能导致处理超时、重平衡和更高的失败重试成本。",[638,7982,7984],{"id":7983},"误区三增加-partition-会重新分配旧积压","误区三：增加 Partition 会重新分配旧积压",[18,7986,7987],{},"新增 Partition 不会迁移旧 Partition 中已有的消息，只能为后续消息提供更多并行空间。",[638,7989,7991],{"id":7990},"误区四lag-等于业务延迟","误区四：Lag 等于业务延迟",[18,7993,7994,7995,7998],{},"Lag 是 Offset 数量差，只表示还落后多少条记录，不等于时间延迟。相同 Lag 下，消费者处理速度越快，处理完现有积压所需的时间越短；如果生产仍在继续，则应使用 ",[22,7996,7997],{},"Lag ÷（消费速度－生产速度）"," 估算 Lag 归零时间。",[18,8000,8001],{},"当前业务已经延迟多久，应通过最老未处理消息的时间戳判断。消息大小影响积压字节量、网络与反序列化成本，单条处理耗时影响消费速度。因此排查时应把 Lag 条数、最老消息年龄、积压字节量和实际处理吞吐分开观察，不能混成一个指标。",[638,8003,8005],{"id":8004},"误区五把-offset-跳到最新就是清理积压","误区五：把 Offset 跳到最新就是清理积压",[18,8007,8008],{},"这不是“处理了积压”，而是“丢弃了积压”。必须经过明确的业务授权和风险评估。",[14,8010,5605],{"id":5605},[114,8012,8013,8018,8023,8030],{},[117,8014,8015],{},[73,8016,5628],{"href":5626,"rel":8017},[1876],[117,8019,8020],{},[73,8021,5642],{"href":5640,"rel":8022},[1876],[117,8024,8025],{},[73,8026,8029],{"href":8027,"rel":8028},"https:\u002F\u002Fkafka.apache.org\u002F41\u002Foperations\u002Fconsumer-rebalance-protocol\u002F",[1876],"Apache Kafka Consumer Rebalance Protocol",[117,8031,8032],{},[73,8033,8036],{"href":8034,"rel":8035},"https:\u002F\u002Fkafka.apache.org\u002F41\u002Foperations\u002Fbasic-kafka-operations\u002F",[1876],"Apache Kafka Basic Operations",[14,8038,3391],{"id":3391},[114,8040,8041,8046],{},[117,8042,8043],{},[73,8044,5702],{"href":8045},"\u002Fwiki\u002Fjava\u002Fkafka-high-concurrency-performance-availability\u002F",[117,8047,8048],{},[73,8049,4392],{"href":6683},[1907,8051,8052],{},"html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}",{"title":101,"searchDepth":165,"depth":165,"links":8054},[8055,8056,8057,8058,8059,8066,8071,8077,8082,8083,8084,8085,8089,8090,8098,8099],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":6796,"depth":165,"text":6797},{"id":6923,"depth":165,"text":6924,"children":8060},[8061,8062,8063,8064,8065],{"id":6927,"depth":210,"text":6928},{"id":6940,"depth":210,"text":6941},{"id":6977,"depth":210,"text":6978},{"id":7016,"depth":210,"text":7017},{"id":7035,"depth":210,"text":7036},{"id":7062,"depth":165,"text":7063,"children":8067},[8068,8069,8070],{"id":7066,"depth":210,"text":7067},{"id":7082,"depth":210,"text":7083},{"id":7118,"depth":210,"text":7119},{"id":7131,"depth":165,"text":7132,"children":8072},[8073,8074,8075,8076],{"id":7135,"depth":210,"text":7136},{"id":7154,"depth":210,"text":7155},{"id":7232,"depth":210,"text":7233},{"id":7306,"depth":210,"text":7307},{"id":7481,"depth":165,"text":7482,"children":8078},[8079,8080,8081],{"id":7485,"depth":210,"text":7486},{"id":7505,"depth":210,"text":7506},{"id":7596,"depth":210,"text":7597},{"id":7612,"depth":165,"text":7613},{"id":7654,"depth":165,"text":7655},{"id":7687,"depth":165,"text":7688},{"id":7735,"depth":165,"text":7736,"children":8086},[8087,8088],{"id":7772,"depth":210,"text":7773},{"id":7902,"depth":210,"text":7902},{"id":7932,"depth":165,"text":7933},{"id":7962,"depth":165,"text":7963,"children":8091},[8092,8093,8095,8096,8097],{"id":7966,"depth":210,"text":7967},{"id":7973,"depth":210,"text":8094},"误区二：把 max.poll.records 调大就能提升吞吐",{"id":7983,"depth":210,"text":7984},{"id":7990,"depth":210,"text":7991},{"id":8004,"depth":210,"text":8005},{"id":5605,"depth":165,"text":5605},{"id":3391,"depth":165,"text":3391},"wiki:java:kafka-message-backlog-handling","从 Consumer Lag 识别、瓶颈定位、限流止血、消费者扩容、批量处理、热点分区和毒消息治理等方面，系统讲解 Kafka 消息积压处理方案。",{},74,"\u002Fjava\u002Fkafka-message-backlog-handling",{"title":6689,"description":8101},"java\u002Fkafka-message-backlog-handling","NjJRIgQZ4iCH7tlxGsujjTJ3RJTGuEk0nuO11Ax1vw8",{"id":8109,"title":8110,"body":8111,"commentId":9854,"description":9855,"difficulty":3462,"draft":1943,"extension":1944,"meta":9856,"navigation":206,"order":9857,"path":9858,"section":1948,"seo":9859,"stem":9860,"updated":5698,"__hash__":9861},"java\u002Fjava\u002Fmysql-transaction-isolation-and-phantom-read.md","MySQL 的隔离级别都有哪些？如何避免幻读？",{"type":7,"value":8112,"toc":9805},[8113,8115,8118,8157,8160,8174,8177,8180,8185,8187,8196,8198,8202,8205,8210,8213,8216,8297,8299,8304,8308,8312,8315,8321,8327,8331,8334,8340,8343,8348,8352,8355,8361,8364,8367,8372,8375,8383,8387,8391,8394,8405,8408,8412,8415,8418,8424,8427,8433,8441,8445,8448,8454,8460,8463,8466,8470,8473,8479,8499,8502,8505,8509,8512,8516,8522,8561,8564,8575,8578,8582,8585,8626,8629,8632,8636,8639,8682,8689,8729,8732,8763,8766,8769,8774,8777,8781,8784,8832,8839,8861,8864,8867,8892,8898,8901,8906,8910,8914,8917,8919,8954,8960,8964,8967,8970,8976,8979,8985,8988,8992,8995,9001,9004,9010,9013,9019,9039,9042,9047,9050,9084,9097,9103,9106,9112,9115,9118,9142,9148,9151,9185,9189,9192,9195,9232,9235,9238,9241,9246,9248,9253,9256,9273,9277,9280,9322,9325,9328,9331,9345,9348,9371,9374,9378,9384,9387,9393,9396,9408,9411,9414,9418,9421,9429,9432,9440,9443,9457,9461,9465,9467,9481,9485,9487,9501,9505,9507,9521,9524,9544,9548,9551,9573,9576,9596,9599,9629,9632,9654,9657,9668,9671,9686,9697,9700,9708,9711,9713,9717,9720,9724,9727,9735,9739,9742,9746,9749,9753,9756,9760,9763,9765,9802],[14,8114,16],{"id":16},[18,8116,8117],{},"MySQL InnoDB 支持四种事务隔离级别：读未提交、读已提交、可重复读和串行化。",[114,8119,8120,8126,8132,8151],{},[117,8121,8122,8125],{},[64,8123,8124],{},"读未提交（READ UNCOMMITTED）","：可能发生脏读、不可重复读和幻读。",[117,8127,8128,8131],{},[64,8129,8130],{},"读已提交（READ COMMITTED）","：只能读取已经提交的数据，但每次普通查询都会创建新的 Read View，因此可能发生不可重复读和幻读。",[117,8133,8134,8137,8138,44,8141,44,8144,2818,8147,8150],{},[64,8135,8136],{},"可重复读（REPEATABLE READ）","：MySQL InnoDB 的默认隔离级别。同一事务中的普通快照读复用第一次查询建立的 Read View，避免不可重复读，并通过一致性快照避免看到后来插入的幻影行；对于 ",[22,8139,8140],{},"SELECT ... FOR UPDATE",[22,8142,8143],{},"SELECT ... FOR SHARE",[22,8145,8146],{},"UPDATE",[22,8148,8149],{},"DELETE"," 等当前读，则通过 Next-Key Lock 锁住索引记录及其前面的间隙，阻止其他事务在查询范围内插入新记录。",[117,8152,8153,8156],{},[64,8154,8155],{},"串行化（SERIALIZABLE）","：隔离性最强，事务近似串行执行，可以避免脏读、不可重复读和幻读，但并发能力最低。",[18,8158,8159],{},"因此，回答“InnoDB 如何避免幻读”时，需要区分两类读取：",[2489,8161,8162,8169],{},[117,8163,8164,8165,8168],{},"普通 ",[22,8166,8167],{},"SELECT"," 属于快照读，REPEATABLE READ 通过 MVCC 和同一个 Read View，让事务始终读取同一份一致性快照。",[117,8170,8171,8173],{},[22,8172,8140],{}," 等属于当前读，REPEATABLE READ 通过 Gap Lock 和 Next-Key Lock 阻止其他事务向锁定范围插入新记录。",[18,8175,8176],{},"如果业务逻辑是“先查询是否存在，再决定是否插入或更新”，仅依赖快照读通常不够，应在 REPEATABLE READ 下使用合适索引和锁定读，并通过唯一索引等数据库约束作为最终兜底。",[638,8178,8179],{"id":8179},"一句话总结",[59,8181,8182],{},[18,8183,8184],{},"InnoDB 默认使用 REPEATABLE READ：普通查询靠 MVCC 的一致性快照避免看见幻影行，当前读靠 Next-Key Lock 锁住记录和间隙，阻止幻影行被插入。",[14,8186,69],{"id":69},[18,8188,8189],{},[73,8190,8193],{"href":8191,"target":76,"rel":8192},"\u002Fimages\u002Fwiki\u002Fjava\u002Fmysql-transaction-isolation-and-phantom-read.svg",[78,79],[81,8194],{"src":8191,"alt":8195},"MySQL 四种事务隔离级别与 InnoDB 避免幻读的机制",[14,8197,86],{"id":86},[14,8199,8201],{"id":8200},"一事务隔离级别解决什么问题","一、事务隔离级别解决什么问题",[18,8203,8204],{},"多个事务并发执行时，一个事务的写入可能影响另一个事务的读取。隔离级别用于规定：",[59,8206,8207],{},[18,8208,8209],{},"一个事务能够看到其他事务的哪些修改，以及什么时候能够看到这些修改。",[18,8211,8212],{},"隔离级别越高，事务之间的影响越小，但加锁和等待通常越多，并发能力也可能越低。",[18,8214,8215],{},"MySQL InnoDB 支持 SQL 标准定义的四种隔离级别：",[1309,8217,8218,8238],{},[1312,8219,8220],{},[1315,8221,8222,8225,8229,8232,8235],{},[1318,8223,8224],{},"隔离级别",[1318,8226,8228],{"align":8227},"right","脏读",[1318,8230,8231],{"align":8227},"不可重复读",[1318,8233,8234],{"align":8227},"幻读",[1318,8236,8237],{"align":8227},"并发能力",[1328,8239,8240,8255,8269,8283],{},[1315,8241,8242,8245,8248,8250,8252],{},[1333,8243,8244],{},"READ UNCOMMITTED",[1333,8246,8247],{"align":8227},"可能",[1333,8249,8247],{"align":8227},[1333,8251,8247],{"align":8227},[1333,8253,8254],{"align":8227},"最高",[1315,8256,8257,8260,8263,8265,8267],{},[1333,8258,8259],{},"READ COMMITTED",[1333,8261,8262],{"align":8227},"避免",[1333,8264,8247],{"align":8227},[1333,8266,8247],{"align":8227},[1333,8268,3715],{"align":8227},[1315,8270,8271,8274,8276,8278,8281],{},[1333,8272,8273],{},"REPEATABLE READ",[1333,8275,8262],{"align":8227},[1333,8277,8262],{"align":8227},[1333,8279,8280],{"align":8227},"InnoDB 通过 MVCC 和 Next-Key Lock 处理",[1333,8282,3715],{"align":8227},[1315,8284,8285,8288,8290,8292,8294],{},[1333,8286,8287],{},"SERIALIZABLE",[1333,8289,8262],{"align":8227},[1333,8291,8262],{"align":8227},[1333,8293,8262],{"align":8227},[1333,8295,8296],{"align":8227},"最低",[18,8298,4629],{},[59,8300,8301],{},[18,8302,8303],{},"“REPEATABLE READ 可能发生幻读”是 SQL 标准层面的常见结论；MySQL InnoDB 在该级别上又实现了 MVCC 和 Next-Key Lock，对快照读和当前读分别处理幻读问题。",[14,8305,8307],{"id":8306},"二三种并发读取问题","二、三种并发读取问题",[638,8309,8311],{"id":8310},"_1-脏读","1. 脏读",[18,8313,8314],{},"事务 A 读取了事务 B 尚未提交的数据。如果事务 B 最后回滚，事务 A 读到的就是从未真正生效的数据。",[95,8316,8319],{"className":8317,"code":8318,"language":100,"meta":101},[98],"事务 A 事务 B\n 修改余额 100 → 0\n读取余额，得到 0\n ROLLBACK\n",[22,8320,8318],{"__ignoreMap":101},[18,8322,8323,8324,8326],{},"这里的 ",[22,8325,2206],{}," 就是脏数据。",[638,8328,8330],{"id":8329},"_2-不可重复读","2. 不可重复读",[18,8332,8333],{},"同一事务两次读取同一行，得到的字段值不同。",[95,8335,8338],{"className":8336,"code":8337,"language":100,"meta":101},[98],"事务 A 事务 B\n读取 id=1，余额为 100\n 修改余额为 80\n COMMIT\n再次读取 id=1，余额为 80\n",[22,8339,8337],{"__ignoreMap":101},[18,8341,8342],{},"不可重复读关注的是：",[59,8344,8345],{},[18,8346,8347],{},"同一行记录的内容发生了变化。",[638,8349,8351],{"id":8350},"_3-幻读","3. 幻读",[18,8353,8354],{},"同一事务使用相同查询条件执行两次查询，第二次返回的结果集合中出现了第一次不存在的记录，或者原有记录消失。",[95,8356,8359],{"className":8357,"code":8358,"language":100,"meta":101},[98],"事务 A 事务 B\n查询 amount > 100，返回 3 行\n 插入一条 amount=150 的记录\n COMMIT\n再次查询 amount > 100，返回 4 行\n",[22,8360,8358],{"__ignoreMap":101},[18,8362,8363],{},"新增的第 4 行就是幻影行。",[18,8365,8366],{},"幻读关注的是：",[59,8368,8369],{},[18,8370,8371],{},"满足查询条件的记录集合发生了变化。",[18,8373,8374],{},"所以，不可重复读和幻读的区别可以记为：",[114,8376,8377,8380],{},[117,8378,8379],{},"不可重复读：同一行的值变了。",[117,8381,8382],{},"幻读：符合条件的行数或记录集合变了。",[14,8384,8386],{"id":8385},"三四种隔离级别","三、四种隔离级别",[638,8388,8390],{"id":8389},"_1-read-uncommitted读未提交","1. READ UNCOMMITTED：读未提交",[18,8392,8393],{},"事务可以读取其他事务尚未提交的修改，因此可能发生：",[114,8395,8396,8399,8402],{},[117,8397,8398],{},"脏读；",[117,8400,8401],{},"不可重复读；",[117,8403,8404],{},"幻读。",[18,8406,8407],{},"它的隔离性最低，实际业务系统很少使用。",[638,8409,8411],{"id":8410},"_2-read-committed读已提交","2. READ COMMITTED：读已提交",[18,8413,8414],{},"事务只能读取已经提交的数据，因此不会发生脏读。",[18,8416,8417],{},"但在 InnoDB 中，每一次普通一致性读都会创建一个新的 Read View：",[95,8419,8422],{"className":8420,"code":8421,"language":100,"meta":101},[98],"第一次 SELECT → Read View 1\n第二次 SELECT → Read View 2\n第三次 SELECT → Read View 3\n",[22,8423,8421],{"__ignoreMap":101},[18,8425,8426],{},"如果其他事务在两次查询之间提交了修改，后一次查询就可能看到新数据，因此可能发生：",[114,8428,8429,8431],{},[117,8430,8401],{},[117,8432,8404],{},[18,8434,8435,8436,2818,8438,8440],{},"另外，在 READ COMMITTED 下，锁定读、",[22,8437,8146],{},[22,8439,8149],{}," 通常只锁索引记录，不锁记录前面的间隙。除了外键约束检查和重复键检查等情况外，Gap Lock 被禁用，因此其他事务仍可能向间隙插入新记录。",[638,8442,8444],{"id":8443},"_3-repeatable-read可重复读","3. REPEATABLE READ：可重复读",[18,8446,8447],{},"这是 InnoDB 的默认隔离级别。",[18,8449,8450,8451,8453],{},"对于普通 ",[22,8452,8167],{},"，事务中的第一次一致性读会建立 Read View，之后的普通一致性读继续使用该快照：",[95,8455,8458],{"className":8456,"code":8457,"language":100,"meta":101},[98],"第一次普通 SELECT → 创建 Read View\n第二次普通 SELECT → 复用同一个 Read View\n第三次普通 SELECT → 复用同一个 Read View\n",[22,8459,8457],{"__ignoreMap":101},[18,8461,8462],{},"因此，其他事务之后提交的更新、删除或插入不会出现在当前事务的旧快照中。",[18,8464,8465],{},"对于锁定读和数据修改语句，InnoDB 会读取最新可用数据，并根据查询使用的索引范围加锁。范围条件通常会使用 Gap Lock 或 Next-Key Lock，阻止其他事务向被锁定的范围插入新记录。",[638,8467,8469],{"id":8468},"_4-serializable串行化","4. SERIALIZABLE：串行化",[18,8471,8472],{},"SERIALIZABLE 是隔离性最强的级别。",[18,8474,8475,8476,8478],{},"在关闭自动提交的情况下，InnoDB 会把普通 ",[22,8477,8167],{}," 隐式转换为共享锁定读，效果类似：",[95,8480,8484],{"className":8481,"code":8482,"language":8483,"meta":101,"style":101},"language-sql shiki shiki-themes github-light github-dark","SELECT ... FOR SHARE;\n","sql",[22,8485,8486],{"__ignoreMap":101},[141,8487,8488,8490,8493,8496],{"class":143,"line":144},[141,8489,8167],{"class":151},[141,8491,8492],{"class":147}," ... ",[141,8494,8495],{"class":151},"FOR",[141,8497,8498],{"class":147}," SHARE;\n",[18,8500,8501],{},"这样事务之间会产生更多锁等待，能够避免脏读、不可重复读和幻读，但吞吐量通常明显下降。",[18,8503,8504],{},"它适合一致性要求极高、并发量较低，或者确实需要事务串行执行的场景。",[14,8506,8508],{"id":8507},"四快照读与当前读","四、快照读与当前读",[18,8510,8511],{},"理解 InnoDB 如何处理幻读，必须先区分快照读和当前读。",[638,8513,8515],{"id":8514},"_1-快照读","1. 快照读",[18,8517,8518,8519,8521],{},"在 READ COMMITTED 和 REPEATABLE READ 下，普通 ",[22,8520,8167],{}," 通常属于快照读：",[95,8523,8525],{"className":8481,"code":8524,"language":8483,"meta":101,"style":101},"SELECT * FROM orders WHERE amount BETWEEN 100 AND 200;\n",[22,8526,8527],{"__ignoreMap":101},[141,8528,8529,8531,8534,8537,8540,8543,8546,8549,8552,8555,8558],{"class":143,"line":144},[141,8530,8167],{"class":151},[141,8532,8533],{"class":151}," *",[141,8535,8536],{"class":151}," FROM",[141,8538,8539],{"class":147}," orders ",[141,8541,8542],{"class":151},"WHERE",[141,8544,8545],{"class":147}," amount ",[141,8547,8548],{"class":151},"BETWEEN",[141,8550,8551],{"class":428}," 100",[141,8553,8554],{"class":151}," AND",[141,8556,8557],{"class":428}," 200",[141,8559,8560],{"class":147},";\n",[18,8562,8563],{},"快照读：",[114,8565,8566,8569,8572],{},[117,8567,8568],{},"不对查询记录加行锁；",[117,8570,8571],{},"通过 MVCC 读取某个时间点的一致性数据；",[117,8573,8574],{},"其他事务可以继续修改、删除或插入数据。",[18,8576,8577],{},"REPEATABLE READ 下，同一事务中的普通快照读复用同一个 Read View，所以后来提交的记录对当前快照不可见。",[638,8579,8581],{"id":8580},"_2-当前读","2. 当前读",[18,8583,8584],{},"下面这些操作需要读取最新可用的数据，并对数据加锁：",[95,8586,8588],{"className":8481,"code":8587,"language":8483,"meta":101,"style":101},"SELECT ... FOR UPDATE;\nSELECT ... FOR SHARE;\nUPDATE ...;\nDELETE ...;\n",[22,8589,8590,8603,8613,8620],{"__ignoreMap":101},[141,8591,8592,8594,8596,8598,8601],{"class":143,"line":144},[141,8593,8167],{"class":151},[141,8595,8492],{"class":147},[141,8597,8495],{"class":151},[141,8599,8600],{"class":151}," UPDATE",[141,8602,8560],{"class":147},[141,8604,8605,8607,8609,8611],{"class":143,"line":165},[141,8606,8167],{"class":151},[141,8608,8492],{"class":147},[141,8610,8495],{"class":151},[141,8612,8498],{"class":147},[141,8614,8615,8617],{"class":143,"line":210},[141,8616,8146],{"class":151},[141,8618,8619],{"class":147}," ...;\n",[141,8621,8622,8624],{"class":143,"line":219},[141,8623,8149],{"class":151},[141,8625,8619],{"class":147},[18,8627,8628],{},"它们通常被称为当前读或锁定读。",[18,8630,8631],{},"当前读不能只依靠旧快照，因为业务接下来可能要修改数据。它必须在最新数据状态上进行判断，并锁住相关记录或范围，避免判断完成后数据立即被并发事务改变。",[14,8633,8635],{"id":8634},"五快照读如何避免幻读","五、快照读如何避免幻读",[18,8637,8638],{},"假设当前使用 REPEATABLE READ：",[95,8640,8642],{"className":8481,"code":8641,"language":8483,"meta":101,"style":101},"START TRANSACTION;\n\nSELECT * FROM orders\nWHERE amount BETWEEN 100 AND 200;\n",[22,8643,8644,8651,8655,8666],{"__ignoreMap":101},[141,8645,8646,8649],{"class":143,"line":144},[141,8647,8648],{"class":151},"START TRANSACTION",[141,8650,8560],{"class":147},[141,8652,8653],{"class":143,"line":165},[141,8654,207],{"emptyLinePlaceholder":206},[141,8656,8657,8659,8661,8663],{"class":143,"line":210},[141,8658,8167],{"class":151},[141,8660,8533],{"class":151},[141,8662,8536],{"class":151},[141,8664,8665],{"class":147}," orders\n",[141,8667,8668,8670,8672,8674,8676,8678,8680],{"class":143,"line":219},[141,8669,8542],{"class":151},[141,8671,8545],{"class":147},[141,8673,8548],{"class":151},[141,8675,8551],{"class":428},[141,8677,8554],{"class":151},[141,8679,8557],{"class":428},[141,8681,8560],{"class":147},[18,8683,8684,8685,8688],{},"第一次普通查询建立 Read View。此后事务 B 插入一条 ",[22,8686,8687],{},"amount=150"," 的记录并提交：",[95,8690,8692],{"className":8481,"code":8691,"language":8483,"meta":101,"style":101},"INSERT INTO orders(user_id, amount)\nVALUES (10, 150);\n\nCOMMIT;\n",[22,8693,8694,8702,8718,8722],{"__ignoreMap":101},[141,8695,8696,8699],{"class":143,"line":144},[141,8697,8698],{"class":151},"INSERT INTO",[141,8700,8701],{"class":147}," orders(user_id, amount)\n",[141,8703,8704,8707,8709,8711,8713,8716],{"class":143,"line":165},[141,8705,8706],{"class":151},"VALUES",[141,8708,4965],{"class":147},[141,8710,2255],{"class":428},[141,8712,4981],{"class":147},[141,8714,8715],{"class":428},"150",[141,8717,915],{"class":147},[141,8719,8720],{"class":143,"line":210},[141,8721,207],{"emptyLinePlaceholder":206},[141,8723,8724,8727],{"class":143,"line":219},[141,8725,8726],{"class":151},"COMMIT",[141,8728,8560],{"class":147},[18,8730,8731],{},"事务 A 再次执行相同的普通查询：",[95,8733,8735],{"className":8481,"code":8734,"language":8483,"meta":101,"style":101},"SELECT * FROM orders\nWHERE amount BETWEEN 100 AND 200;\n",[22,8736,8737,8747],{"__ignoreMap":101},[141,8738,8739,8741,8743,8745],{"class":143,"line":144},[141,8740,8167],{"class":151},[141,8742,8533],{"class":151},[141,8744,8536],{"class":151},[141,8746,8665],{"class":147},[141,8748,8749,8751,8753,8755,8757,8759,8761],{"class":143,"line":165},[141,8750,8542],{"class":151},[141,8752,8545],{"class":147},[141,8754,8548],{"class":151},[141,8756,8551],{"class":428},[141,8758,8554],{"class":151},[141,8760,8557],{"class":428},[141,8762,8560],{"class":147},[18,8764,8765],{},"由于事务 A 仍然使用原来的 Read View，新插入的记录不在该快照的可见范围内，因此第二次查询不会看到它。",[18,8767,8768],{},"这里需要准确理解：",[59,8770,8771],{},[18,8772,8773],{},"MVCC 没有阻止事务 B 插入记录，只是让这条后来提交的记录对事务 A 的旧快照不可见。",[18,8775,8776],{},"因此，快照读解决的是“当前事务看到什么”，而不是“其他事务能不能写入”。",[14,8778,8780],{"id":8779},"六当前读如何避免幻读","六、当前读如何避免幻读",[18,8782,8783],{},"如果业务需要先锁定一个范围，再根据查询结果修改数据，可以使用：",[95,8785,8787],{"className":8481,"code":8786,"language":8483,"meta":101,"style":101},"START TRANSACTION;\n\nSELECT * FROM orders\nWHERE amount BETWEEN 100 AND 200\nFOR UPDATE;\n",[22,8788,8789,8795,8799,8809,8824],{"__ignoreMap":101},[141,8790,8791,8793],{"class":143,"line":144},[141,8792,8648],{"class":151},[141,8794,8560],{"class":147},[141,8796,8797],{"class":143,"line":165},[141,8798,207],{"emptyLinePlaceholder":206},[141,8800,8801,8803,8805,8807],{"class":143,"line":210},[141,8802,8167],{"class":151},[141,8804,8533],{"class":151},[141,8806,8536],{"class":151},[141,8808,8665],{"class":147},[141,8810,8811,8813,8815,8817,8819,8821],{"class":143,"line":219},[141,8812,8542],{"class":151},[141,8814,8545],{"class":147},[141,8816,8548],{"class":151},[141,8818,8551],{"class":428},[141,8820,8554],{"class":151},[141,8822,8823],{"class":428}," 200\n",[141,8825,8826,8828,8830],{"class":143,"line":234},[141,8827,8495],{"class":151},[141,8829,8600],{"class":151},[141,8831,8560],{"class":147},[18,8833,8834,8835,8838],{},"假设 ",[22,8836,8837],{},"amount"," 上存在普通索引：",[95,8840,8842],{"className":8481,"code":8841,"language":8483,"meta":101,"style":101},"CREATE INDEX idx_orders_amount ON orders(amount);\n",[22,8843,8844],{"__ignoreMap":101},[141,8845,8846,8849,8852,8855,8858],{"class":143,"line":144},[141,8847,8848],{"class":151},"CREATE",[141,8850,8851],{"class":151}," INDEX",[141,8853,8854],{"class":158}," idx_orders_amount",[141,8856,8857],{"class":151}," ON",[141,8859,8860],{"class":147}," orders(amount);\n",[18,8862,8863],{},"在 REPEATABLE READ 下，InnoDB 扫描这个索引范围时，通常会对索引记录及其间隙加 Next-Key Lock。",[18,8865,8866],{},"此时另一个事务尝试插入：",[95,8868,8870],{"className":8481,"code":8869,"language":8483,"meta":101,"style":101},"INSERT INTO orders(user_id, amount)\nVALUES (10, 150);\n",[22,8871,8872,8878],{"__ignoreMap":101},[141,8873,8874,8876],{"class":143,"line":144},[141,8875,8698],{"class":151},[141,8877,8701],{"class":147},[141,8879,8880,8882,8884,8886,8888,8890],{"class":143,"line":165},[141,8881,8706],{"class":151},[141,8883,4965],{"class":147},[141,8885,2255],{"class":428},[141,8887,4981],{"class":147},[141,8889,8715],{"class":428},[141,8891,915],{"class":147},[18,8893,8894,8895,8897],{},"由于 ",[22,8896,8715],{}," 落在已经锁定的索引范围内，该插入通常会被阻塞，直到前一个事务提交或回滚。",[18,8899,8900],{},"这次不是“让新记录不可见”，而是：",[59,8902,8903],{},[18,8904,8905],{},"阻止新记录进入已经锁定的查询范围。",[14,8907,8909],{"id":8908},"七record-lockgap-lock-与-next-key-lock","七、Record Lock、Gap Lock 与 Next-Key Lock",[638,8911,8913],{"id":8912},"_1-record-lock","1. Record Lock",[18,8915,8916],{},"Record Lock 锁住的是索引记录。",[18,8918,1398],{},[95,8920,8922],{"className":8481,"code":8921,"language":8483,"meta":101,"style":101},"SELECT * FROM orders\nWHERE id = 100\nFOR UPDATE;\n",[22,8923,8924,8934,8946],{"__ignoreMap":101},[141,8925,8926,8928,8930,8932],{"class":143,"line":144},[141,8927,8167],{"class":151},[141,8929,8533],{"class":151},[141,8931,8536],{"class":151},[141,8933,8665],{"class":147},[141,8935,8936,8938,8941,8943],{"class":143,"line":165},[141,8937,8542],{"class":151},[141,8939,8940],{"class":147}," id ",[141,8942,152],{"class":151},[141,8944,8945],{"class":428}," 100\n",[141,8947,8948,8950,8952],{"class":143,"line":210},[141,8949,8495],{"class":151},[141,8951,8600],{"class":151},[141,8953,8560],{"class":147},[18,8955,4060,8956,8959],{},[22,8957,8958],{},"id"," 是唯一索引，并且使用唯一等值条件准确定位一条记录，InnoDB 通常只锁找到的索引记录，不需要锁前面的间隙。",[638,8961,8963],{"id":8962},"_2-gap-lock","2. Gap Lock",[18,8965,8966],{},"Gap Lock 锁住的是两个索引记录之间的间隙，而不是某一条已经存在的记录。",[18,8968,8969],{},"假设索引中已有：",[95,8971,8974],{"className":8972,"code":8973,"language":100,"meta":101},[98],"100\n200\n300\n",[22,8975,8973],{"__ignoreMap":101},[18,8977,8978],{},"那么其中存在：",[95,8980,8983],{"className":8981,"code":8982,"language":100,"meta":101},[98],"(-∞, 100)\n(100, 200)\n(200, 300)\n(300, +∞)\n",[22,8984,8982],{"__ignoreMap":101},[18,8986,8987],{},"Gap Lock 的主要作用是限制其他事务在对应间隙插入新索引记录。",[638,8989,8991],{"id":8990},"_3-next-key-lock","3. Next-Key Lock",[18,8993,8994],{},"Next-Key Lock 的准确定义是：",[95,8996,8999],{"className":8997,"code":8998,"language":100,"meta":101},[98],"Next-Key Lock = Record Lock + 该记录前面的 Gap Lock\n",[22,9000,8998],{"__ignoreMap":101},[18,9002,9003],{},"这里的“前面”是指索引排序中的前一个间隙。假设索引值为：",[95,9005,9008],{"className":9006,"code":9007,"language":100,"meta":101},[98],"3\n5\n8\n",[22,9009,9007],{"__ignoreMap":101},[18,9011,9012],{},"可能形成的 Next-Key Lock 区间是：",[95,9014,9017],{"className":9015,"code":9016,"language":100,"meta":101},[98],"(-∞, 3]\n(3, 5]\n(5, 8]\n(8, +∞)\n",[22,9018,9016],{"__ignoreMap":101},[18,9020,9021,9022,9025,9026,9029,9030,9032,9033,6242,9036,9038],{},"例如，对索引记录 ",[22,9023,9024],{},"5"," 加 Next-Key Lock，可以概念性地理解为锁住 ",[22,9027,9028],{},"(3, 5]","：既保护记录 ",[22,9031,9024],{},"，又阻止其他事务向 ",[22,9034,9035],{},"3",[22,9037,9024],{}," 之间插入新索引记录。",[18,9040,9041],{},"这里需要区分单个 Next-Key Lock 和一条 SQL 最终获得的整组锁：",[59,9043,9044],{},[18,9045,9046],{},"一个 Next-Key Lock 只包含当前记录和它前面的间隙，但一条 SQL 可能同时获得多个 Record Lock、Gap Lock 和 Next-Key Lock，最终覆盖查询记录前后的整个范围。",[18,9048,9049],{},"例如，在 REPEATABLE READ 下执行：",[95,9051,9053],{"className":8481,"code":9052,"language":8483,"meta":101,"style":101},"SELECT * FROM orders\nWHERE amount = 5\nFOR UPDATE;\n",[22,9054,9055,9065,9076],{"__ignoreMap":101},[141,9056,9057,9059,9061,9063],{"class":143,"line":144},[141,9058,8167],{"class":151},[141,9060,8533],{"class":151},[141,9062,8536],{"class":151},[141,9064,8665],{"class":147},[141,9066,9067,9069,9071,9073],{"class":143,"line":165},[141,9068,8542],{"class":151},[141,9070,8545],{"class":147},[141,9072,152],{"class":151},[141,9074,9075],{"class":428}," 5\n",[141,9077,9078,9080,9082],{"class":143,"line":210},[141,9079,8495],{"class":151},[141,9081,8600],{"class":151},[141,9083,8560],{"class":147},[18,9085,4060,9086,9088,9089,9092,9093,9096],{},[22,9087,8837],{}," 是普通非唯一索引，并且相邻索引值为 ",[22,9090,9091],{},"3、5、8","，为了防止其他事务再次插入 ",[22,9094,9095],{},"amount=5"," 的记录，最终需要保护：",[95,9098,9101],{"className":9099,"code":9100,"language":100,"meta":101},[98],"记录 5\n记录 5 前面的间隙：(3, 5)\n记录 5 后面的间隙：(5, 8)\n",[22,9102,9100],{"__ignoreMap":101},[18,9104,9105],{},"可以概念性地理解为：",[95,9107,9110],{"className":9108,"code":9109,"language":100,"meta":101},[98],"(3, 5] → 记录 5 的 Next-Key Lock\n(5, 8) → 查询范围结束位置的 Gap Lock\n",[22,9111,9109],{"__ignoreMap":101},[18,9113,9114],{},"所以，“等值查询可能锁住匹配记录及其前后间隙”是对一条 SQL 最终锁定范围的描述；它不代表单个 Next-Key Lock 同时包含记录前后两个间隙。",[18,9116,9117],{},"还要区分以下情况：",[114,9119,9120,9125,9136,9139],{},[117,9121,8164,9122,9124],{},[22,9123,8167],{}," 是快照读，不会因为这个查询条件加 Next-Key Lock。",[117,9126,9127,44,9129,44,9131,2818,9133,9135],{},[22,9128,8140],{},[22,9130,8143],{},[22,9132,8146],{},[22,9134,8149],{}," 才属于锁定读或当前读。",[117,9137,9138],{},"如果使用唯一索引和唯一等值条件，并且准确找到已有记录，InnoDB 通常只加 Record Lock，不需要锁前后间隙。",[117,9140,9141],{},"如果查询条件没有命中唯一记录，或者使用普通非唯一索引，InnoDB 会根据实际扫描范围使用 Gap Lock 或 Next-Key Lock。",[18,9143,9144,9145,9147],{},"具体获得哪些锁，最终还取决于隔离级别、索引类型、查询条件和实际执行计划，不能只根据 ",[22,9146,8542],{}," 条件判断。",[18,9149,9150],{},"InnoDB 还可以锁住最后一条记录之后的间隙，从而保护开放区间查询：",[95,9152,9154],{"className":8481,"code":9153,"language":8483,"meta":101,"style":101},"SELECT * FROM orders\nWHERE amount > 200\nFOR UPDATE;\n",[22,9155,9156,9166,9177],{"__ignoreMap":101},[141,9157,9158,9160,9162,9164],{"class":143,"line":144},[141,9159,8167],{"class":151},[141,9161,8533],{"class":151},[141,9163,8536],{"class":151},[141,9165,8665],{"class":147},[141,9167,9168,9170,9172,9175],{"class":143,"line":165},[141,9169,8542],{"class":151},[141,9171,8545],{"class":147},[141,9173,9174],{"class":151},">",[141,9176,8823],{"class":428},[141,9178,9179,9181,9183],{"class":143,"line":210},[141,9180,8495],{"class":151},[141,9182,8600],{"class":151},[141,9184,8560],{"class":147},[14,9186,9188],{"id":9187},"八索引为什么很重要","八、索引为什么很重要",[18,9190,9191],{},"InnoDB 的行锁本质上是索引记录锁，Next-Key Lock 也是围绕索引扫描范围建立的。",[18,9193,9194],{},"如果查询能够使用合适索引：",[95,9196,9198],{"className":8481,"code":9197,"language":8483,"meta":101,"style":101},"SELECT * FROM orders\nWHERE amount BETWEEN 100 AND 200\nFOR UPDATE;\n",[22,9199,9200,9210,9224],{"__ignoreMap":101},[141,9201,9202,9204,9206,9208],{"class":143,"line":144},[141,9203,8167],{"class":151},[141,9205,8533],{"class":151},[141,9207,8536],{"class":151},[141,9209,8665],{"class":147},[141,9211,9212,9214,9216,9218,9220,9222],{"class":143,"line":165},[141,9213,8542],{"class":151},[141,9215,8545],{"class":147},[141,9217,8548],{"class":151},[141,9219,8551],{"class":428},[141,9221,8554],{"class":151},[141,9223,8823],{"class":428},[141,9225,9226,9228,9230],{"class":143,"line":210},[141,9227,8495],{"class":151},[141,9229,8600],{"class":151},[141,9231,8560],{"class":147},[18,9233,9234],{},"InnoDB 可以更准确地锁定相关索引范围。",[18,9236,9237],{},"如果缺少合适索引，InnoDB 可能需要扫描并锁定大量索引记录，锁的范围会变大，并发能力明显下降。",[18,9239,9240],{},"这里不要简单表述为：",[59,9242,9243],{},[18,9244,9245],{},"没有索引就一定加表锁。",[18,9247,2461],{},[59,9249,9250],{},[18,9251,9252],{},"InnoDB 仍然基于索引记录加锁；缺少可用业务索引时，可能扫描并锁住大量记录，使效果接近大范围锁定。",[18,9254,9255],{},"因此，使用锁定读避免幻读时，需要同时关注：",[114,9257,9258,9261,9264,9267,9270],{},[117,9259,9260],{},"查询条件是否命中索引；",[117,9262,9263],{},"实际执行计划选择了哪个索引；",[117,9265,9266],{},"锁定范围是否超出预期；",[117,9268,9269],{},"事务是否足够短；",[117,9271,9272],{},"是否可能形成死锁。",[14,9274,9276],{"id":9275},"九为什么不能只依赖快照读完成先查后写","九、为什么不能只依赖快照读完成“先查后写”",[18,9278,9279],{},"假设业务要求同一用户只能存在一条有效申请：",[95,9281,9283],{"className":8481,"code":9282,"language":8483,"meta":101,"style":101},"SELECT * FROM applications\nWHERE user_id = 100\n AND status = 'ACTIVE';\n",[22,9284,9285,9296,9307],{"__ignoreMap":101},[141,9286,9287,9289,9291,9293],{"class":143,"line":144},[141,9288,8167],{"class":151},[141,9290,8533],{"class":151},[141,9292,8536],{"class":151},[141,9294,9295],{"class":147}," applications\n",[141,9297,9298,9300,9303,9305],{"class":143,"line":165},[141,9299,8542],{"class":151},[141,9301,9302],{"class":147}," user_id ",[141,9304,152],{"class":151},[141,9306,8945],{"class":428},[141,9308,9309,9312,9315,9317,9320],{"class":143,"line":210},[141,9310,9311],{"class":151}," AND",[141,9313,9314],{"class":151}," status",[141,9316,946],{"class":151},[141,9318,9319],{"class":911}," 'ACTIVE'",[141,9321,8560],{"class":147},[18,9323,9324],{},"两个事务可能同时通过快照读发现“记录不存在”，然后各自插入一条有效申请。",[18,9326,9327],{},"REPEATABLE READ 虽然让两个事务各自的查询结果保持一致，但没有阻止另一个事务执行插入。",[18,9329,9330],{},"因此，业务不变量不能只依赖普通快照读。常见方案是：",[2489,9332,9333,9336,9339,9342],{},[117,9334,9335],{},"建立能够表达业务规则的唯一索引；",[117,9337,9338],{},"在 REPEATABLE READ 下使用合适的锁定读；",[117,9340,9341],{},"捕获重复键或死锁异常，并进行有限重试；",[117,9343,9344],{},"缩短事务时间，避免锁范围长期占用。",[18,9346,9347],{},"例如业务规则能够转换为唯一键时，优先让数据库约束兜底：",[95,9349,9351],{"className":8481,"code":9350,"language":8483,"meta":101,"style":101},"CREATE UNIQUE INDEX uk_user_active\nON applications(user_id, active_flag);\n",[22,9352,9353,9363],{"__ignoreMap":101},[141,9354,9355,9357,9360],{"class":143,"line":144},[141,9356,8848],{"class":151},[141,9358,9359],{"class":151}," UNIQUE INDEX",[141,9361,9362],{"class":158}," uk_user_active\n",[141,9364,9365,9368],{"class":143,"line":165},[141,9366,9367],{"class":151},"ON",[141,9369,9370],{"class":147}," applications(user_id, active_flag);\n",[18,9372,9373],{},"具体索引设计仍要根据数据模型确定，不能为了唯一约束直接照搬示例。",[14,9375,9377],{"id":9376},"十混用快照读和当前读为什么容易困惑","十、混用快照读和当前读为什么容易困惑",[18,9379,9380,9381,9383],{},"在 REPEATABLE READ 事务中，普通 ",[22,9382,8167],{}," 使用旧快照，而锁定读读取最新可用的数据。",[18,9385,9386],{},"可能出现：",[95,9388,9391],{"className":9389,"code":9390,"language":100,"meta":101},[98],"1. 普通 SELECT 没看到某条新记录\n2. 另一个事务插入该记录并提交\n3. SELECT ... FOR UPDATE 却看到了这条记录\n",[22,9392,9390],{"__ignoreMap":101},[18,9394,9395],{},"原因不是隔离级别突然失效，而是两条语句使用了不同的读取机制：",[114,9397,9398,9403],{},[117,9399,8164,9400,9402],{},[22,9401,8167],{},"：读取 Read View 中的一致性快照；",[117,9404,9405,9407],{},[22,9406,8140],{},"：读取最新可用数据并加锁。",[18,9409,9410],{},"MySQL 官方文档也不建议在同一个 REPEATABLE READ 事务中随意混用锁定语句和非锁定查询，因为它们可能呈现两个不同时间状态的数据。",[18,9412,9413],{},"如果业务必须基于最新结果做写入判断，应统一使用锁定读；如果必须获得更严格、容易理解的串行语义，可以评估 SERIALIZABLE，但要接受更高的锁竞争。",[14,9415,9417],{"id":9416},"十一read-committed-下加-for-update-能否避免幻读","十一、READ COMMITTED 下加 FOR UPDATE 能否避免幻读",[18,9419,9420],{},"不能笼统地说可以。",[18,9422,9423,9424,2818,9426,9428],{},"在 READ COMMITTED 下，InnoDB 对锁定读、",[22,9425,8146],{},[22,9427,8149],{}," 通常只锁索引记录，不锁前面的间隙。其他事务仍可以向记录间隙插入新行，因此范围查询仍可能出现幻读。",[18,9430,9431],{},"Gap Lock 在该级别主要保留给：",[114,9433,9434,9437],{},[117,9435,9436],{},"外键约束检查；",[117,9438,9439],{},"重复键检查。",[18,9441,9442],{},"如果业务需要锁住一个尚不存在的范围，应评估：",[114,9444,9445,9448,9451,9454],{},[117,9446,9447],{},"使用 REPEATABLE READ，并通过合适索引和 Next-Key Lock 锁定范围；",[117,9449,9450],{},"使用 SERIALIZABLE；",[117,9452,9453],{},"把业务不变量转换为唯一约束；",[117,9455,9456],{},"调整数据模型，避免依赖无法锁定的“空结果”。",[14,9458,9460],{"id":9459},"十二如何选择隔离级别","十二、如何选择隔离级别",[638,9462,9464],{"id":9463},"选择-read-committed","选择 READ COMMITTED",[18,9466,4130],{},[114,9468,9469,9472,9475,9478],{},[117,9470,9471],{},"希望每次查询都看到最新已提交数据；",[117,9473,9474],{},"可以接受同一事务内两次读取结果不同；",[117,9476,9477],{},"希望减少 Gap Lock 和锁冲突；",[117,9479,9480],{},"业务通过版本号、唯一约束或其他机制保证并发正确性。",[638,9482,9484],{"id":9483},"选择-repeatable-read","选择 REPEATABLE READ",[18,9486,4130],{},[114,9488,9489,9492,9495,9498],{},[117,9490,9491],{},"希望事务中的普通查询保持一致视图；",[117,9493,9494],{},"需要使用 Next-Key Lock 保护范围；",[117,9496,9497],{},"能够控制索引、锁顺序和事务时长；",[117,9499,9500],{},"接受 InnoDB 默认隔离级别。",[638,9502,9504],{"id":9503},"选择-serializable","选择 SERIALIZABLE",[18,9506,4130],{},[114,9508,9509,9512,9515,9518],{},[117,9510,9511],{},"并发量较低；",[117,9513,9514],{},"一致性要求极高；",[117,9516,9517],{},"业务逻辑难以通过更细粒度约束实现；",[117,9519,9520],{},"能够接受更多阻塞、超时和死锁重试。",[18,9522,9523],{},"隔离级别不是越高越好。选择时需要综合评估：",[114,9525,9526,9529,9532,9535,9538,9541],{},[117,9527,9528],{},"一致性要求；",[117,9530,9531],{},"读写比例；",[117,9533,9534],{},"热点数据；",[117,9536,9537],{},"事务持续时间；",[117,9539,9540],{},"可接受的锁等待；",[117,9542,9543],{},"数据库吞吐量。",[14,9545,9547],{"id":9546},"十三查看和设置隔离级别","十三、查看和设置隔离级别",[18,9549,9550],{},"查看当前会话隔离级别：",[95,9552,9554],{"className":8481,"code":9553,"language":8483,"meta":101,"style":101},"SELECT @@SESSION.transaction_isolation;\n",[22,9555,9556],{"__ignoreMap":101},[141,9557,9558,9560,9563,9566,9568,9571],{"class":143,"line":144},[141,9559,8167],{"class":151},[141,9561,9562],{"class":147}," @@",[141,9564,9565],{"class":428},"SESSION",[141,9567,431],{"class":147},[141,9569,9570],{"class":428},"transaction_isolation",[141,9572,8560],{"class":147},[18,9574,9575],{},"查看全局默认隔离级别：",[95,9577,9579],{"className":8481,"code":9578,"language":8483,"meta":101,"style":101},"SELECT @@GLOBAL.transaction_isolation;\n",[22,9580,9581],{"__ignoreMap":101},[141,9582,9583,9585,9587,9590,9592,9594],{"class":143,"line":144},[141,9584,8167],{"class":151},[141,9586,9562],{"class":147},[141,9588,9589],{"class":428},"GLOBAL",[141,9591,431],{"class":147},[141,9593,9570],{"class":428},[141,9595,8560],{"class":147},[18,9597,9598],{},"修改当前会话后续事务的隔离级别：",[95,9600,9602],{"className":8481,"code":9601,"language":8483,"meta":101,"style":101},"SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;\n",[22,9603,9604],{"__ignoreMap":101},[141,9605,9606,9609,9612,9615,9618,9621,9624,9627],{"class":143,"line":144},[141,9607,9608],{"class":151},"SET",[141,9610,9611],{"class":151}," SESSION",[141,9613,9614],{"class":151}," TRANSACTION",[141,9616,9617],{"class":151}," ISOLATION",[141,9619,9620],{"class":151}," LEVEL",[141,9622,9623],{"class":151}," READ",[141,9625,9626],{"class":151}," COMMITTED",[141,9628,8560],{"class":147},[18,9630,9631],{},"设置下一个事务的隔离级别：",[95,9633,9635],{"className":8481,"code":9634,"language":8483,"meta":101,"style":101},"SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;\n",[22,9636,9637],{"__ignoreMap":101},[141,9638,9639,9641,9643,9645,9647,9650,9652],{"class":143,"line":144},[141,9640,9608],{"class":151},[141,9642,9614],{"class":151},[141,9644,9617],{"class":151},[141,9646,9620],{"class":151},[141,9648,9649],{"class":151}," REPEATABLE",[141,9651,9623],{"class":151},[141,9653,8560],{"class":147},[18,9655,9656],{},"开始事务：",[95,9658,9660],{"className":8481,"code":9659,"language":8483,"meta":101,"style":101},"START TRANSACTION;\n",[22,9661,9662],{"__ignoreMap":101},[141,9663,9664,9666],{"class":143,"line":144},[141,9665,8648],{"class":151},[141,9667,8560],{"class":147},[18,9669,9670],{},"线上修改隔离级别前，需要：",[114,9672,9673,9676,9683],{},[117,9674,9675],{},"验证依赖一致性快照、锁定范围和“先查后写”的业务逻辑；",[117,9677,9678,9679,9682],{},"确认 ",[22,9680,9681],{},"binlog_format"," 与目标隔离级别兼容；",[117,9684,9685],{},"观察切换前后的锁等待、死锁率、事务时延和数据库吞吐量。",[18,9687,9688,9689,9692,9693,9696],{},"这里需要确认的不是笼统的“复制方式”，而是二进制日志格式的兼容性。例如 MySQL 的 READ COMMITTED 只支持 Row-Based Logging；如果配置为 ",[22,9690,9691],{},"MIXED","，MySQL 会自动使用行格式记录。系统原本已经使用 ",[22,9694,9695],{},"ROW"," 时，通常不需要为此额外调整。",[18,9698,9699],{},"监控指标也不是选择隔离级别的前置条件，而是用于验证切换产生的实际影响：",[114,9701,9702,9705],{},[117,9703,9704],{},"从 REPEATABLE READ 切换到 READ COMMITTED，Gap Lock 通常减少，锁等待和死锁概率可能下降，但业务会失去事务级固定快照；",[117,9706,9707],{},"切换到更高隔离级别时，锁范围和等待时间可能增加，事务耗时及吞吐量可能受到影响。",[18,9709,9710],{},"因此，不能只根据理论吞吐量直接切换隔离级别。",[14,9712,4293],{"id":4292},[638,9714,9716],{"id":9715},"误区-1mvcc-会阻止其他事务插入","误区 1：MVCC 会阻止其他事务插入",[18,9718,9719],{},"不会。MVCC 主要决定一条记录对当前 Read View 是否可见，不会因为快照读而阻塞其他事务写入。",[638,9721,9723],{"id":9722},"误区-2repeatable-read-只靠-mvcc-避免所有幻读","误区 2：REPEATABLE READ 只靠 MVCC 避免所有幻读",[18,9725,9726],{},"不完整。",[114,9728,9729,9732],{},[117,9730,9731],{},"快照读靠 MVCC 和固定 Read View；",[117,9733,9734],{},"当前读靠 Gap Lock 和 Next-Key Lock。",[638,9736,9738],{"id":9737},"误区-3只要加-for-update-就一定不会幻读","误区 3：只要加 FOR UPDATE 就一定不会幻读",[18,9740,9741],{},"不一定。是否锁住间隙与隔离级别、查询条件、索引类型和实际扫描范围有关。READ COMMITTED 下通常不会为普通范围查询使用 Gap Lock。",[638,9743,9745],{"id":9744},"误区-4next-key-lock-锁的是数据页","误区 4：Next-Key Lock 锁的是数据页",[18,9747,9748],{},"不是。它围绕索引记录和索引记录之间的间隙建立。",[638,9750,9752],{"id":9751},"误区-5没有索引就一定升级为表锁","误区 5：没有索引就一定升级为表锁",[18,9754,9755],{},"这个表述不准确。InnoDB 仍然基于索引进行记录锁定，但缺少合适索引可能导致扫描和锁定大量记录，使并发效果接近大范围锁定。",[638,9757,9759],{"id":9758},"误区-6serializable-一定是最好的选择","误区 6：SERIALIZABLE 一定是最好的选择",[18,9761,9762],{},"它的隔离性最强，但会显著增加锁等待，降低并发能力。多数业务更适合通过合理隔离级别、索引、锁定读和数据库约束共同保证正确性。",[14,9764,5605],{"id":5605},[114,9766,9767,9774,9781,9788,9795],{},[117,9768,9769],{},[73,9770,9773],{"href":9771,"rel":9772},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.4\u002Fen\u002Finnodb-transaction-isolation-levels.html",[1876],"MySQL 8.4 Reference Manual：Transaction Isolation Levels",[117,9775,9776],{},[73,9777,9780],{"href":9778,"rel":9779},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.4\u002Fen\u002Finnodb-consistent-read.html",[1876],"MySQL 8.4 Reference Manual：Consistent Nonlocking Reads",[117,9782,9783],{},[73,9784,9787],{"href":9785,"rel":9786},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.4\u002Fen\u002Finnodb-next-key-locking.html",[1876],"MySQL 8.4 Reference Manual：Phantom Rows",[117,9789,9790],{},[73,9791,9794],{"href":9792,"rel":9793},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.4\u002Fen\u002Finnodb-locking-reads.html",[1876],"MySQL 8.4 Reference Manual：Locking Reads",[117,9796,9797],{},[73,9798,9801],{"href":9799,"rel":9800},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.4\u002Fen\u002Fset-transaction.html",[1876],"MySQL 8.4 Reference Manual：SET TRANSACTION Statement",[1907,9803,9804],{},"html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}",{"title":101,"searchDepth":165,"depth":165,"links":9806},[9807,9810,9811,9812,9813,9818,9824,9828,9829,9830,9835,9836,9837,9838,9839,9844,9845,9853],{"id":16,"depth":165,"text":16,"children":9808},[9809],{"id":8179,"depth":210,"text":8179},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":8200,"depth":165,"text":8201},{"id":8306,"depth":165,"text":8307,"children":9814},[9815,9816,9817],{"id":8310,"depth":210,"text":8311},{"id":8329,"depth":210,"text":8330},{"id":8350,"depth":210,"text":8351},{"id":8385,"depth":165,"text":8386,"children":9819},[9820,9821,9822,9823],{"id":8389,"depth":210,"text":8390},{"id":8410,"depth":210,"text":8411},{"id":8443,"depth":210,"text":8444},{"id":8468,"depth":210,"text":8469},{"id":8507,"depth":165,"text":8508,"children":9825},[9826,9827],{"id":8514,"depth":210,"text":8515},{"id":8580,"depth":210,"text":8581},{"id":8634,"depth":165,"text":8635},{"id":8779,"depth":165,"text":8780},{"id":8908,"depth":165,"text":8909,"children":9831},[9832,9833,9834],{"id":8912,"depth":210,"text":8913},{"id":8962,"depth":210,"text":8963},{"id":8990,"depth":210,"text":8991},{"id":9187,"depth":165,"text":9188},{"id":9275,"depth":165,"text":9276},{"id":9376,"depth":165,"text":9377},{"id":9416,"depth":165,"text":9417},{"id":9459,"depth":165,"text":9460,"children":9840},[9841,9842,9843],{"id":9463,"depth":210,"text":9464},{"id":9483,"depth":210,"text":9484},{"id":9503,"depth":210,"text":9504},{"id":9546,"depth":165,"text":9547},{"id":4292,"depth":165,"text":4293,"children":9846},[9847,9848,9849,9850,9851,9852],{"id":9715,"depth":210,"text":9716},{"id":9722,"depth":210,"text":9723},{"id":9737,"depth":210,"text":9738},{"id":9744,"depth":210,"text":9745},{"id":9751,"depth":210,"text":9752},{"id":9758,"depth":210,"text":9759},{"id":5605,"depth":165,"text":5605},"wiki:java:mysql-transaction-isolation-and-phantom-read","梳理 MySQL InnoDB 的四种事务隔离级别，解释脏读、不可重复读和幻读，并说明 MVCC、Read View、Gap Lock 与 Next-Key Lock 如何共同避免幻读。",{},75,"\u002Fjava\u002Fmysql-transaction-isolation-and-phantom-read",{"title":8110,"description":9855},"java\u002Fmysql-transaction-isolation-and-phantom-read","fQEdrnJPxztc16zbaEZBXfxB2OYyLN5Gdv5shRJ6FbQ",{"id":9863,"title":9864,"body":9865,"commentId":11001,"description":11002,"difficulty":3462,"draft":1943,"extension":1944,"meta":11003,"navigation":206,"order":11004,"path":11005,"section":1948,"seo":11006,"stem":11007,"updated":11008,"__hash__":11009},"java\u002Fjava\u002Fmysql-bplus-tree-vs-btree.md","MySQL 为何采用 B+ 树？B+ 树与 B 树的区别是什么？",{"type":7,"value":9866,"toc":10970},[9867,9869,9872,9875,9889,9892,9895,9897,9902,9904,9913,9915,9919,9926,9946,9949,9951,9965,9969,9972,9975,9978,9984,9987,10004,10011,10015,10018,10021,10027,10030,10046,10049,10063,10067,10171,10174,10177,10181,10184,10187,10190,10196,10199,10206,10211,10215,10220,10223,10228,10231,10237,10240,10246,10249,10255,10258,10262,10265,10268,10274,10277,10280,10283,10289,10292,10298,10301,10306,10315,10319,10322,10359,10366,10372,10375,10381,10384,10387,10429,10432,10436,10439,10442,10448,10451,10458,10462,10465,10480,10483,10486,10536,10539,10542,10559,10562,10565,10569,10572,10575,10590,10593,10599,10602,10628,10631,10634,10638,10641,10647,10650,10674,10677,10710,10715,10721,10724,10727,10757,10760,10769,10773,10776,10779,10785,10788,10791,10795,10798,10815,10818,10822,10825,10828,10834,10837,10840,10854,10857,10861,10865,10868,10872,10875,10879,10882,10886,10889,10893,10904,10908,10911,10917,10923,10928,10930,10967],[14,9868,16],{"id":16},[18,9870,9871],{},"MySQL InnoDB 的普通索引采用通常所说的 B+ 树结构，核心原因是数据库索引需要同时兼顾磁盘或页访问次数、等值查询、范围查询和顺序遍历。",[18,9873,9874],{},"B+ 树与 B 树的主要区别是：",[114,9876,9877,9880,9883,9886],{},[117,9878,9879],{},"B 树的非叶子节点和叶子节点都可以保存数据记录；",[117,9881,9882],{},"B+ 树的非叶子节点主要保存索引键和子页面指针，完整索引记录集中在叶子节点；",[117,9884,9885],{},"B+ 树的叶子节点按照键值顺序连接，适合范围扫描；",[117,9887,9888],{},"由于非叶子节点不保存完整数据，同样大小的页面能够容纳更多目录项，树的扇出更大、高度更低。",[18,9890,9891],{},"InnoDB 默认索引页大小为 16KB。一次读取通常以页为单位，而不是只读取一个键。B+ 树通过较大的扇出，把大量数据组织在较少的层级中，查询通常只需要访问少量页面；定位到范围起点后，还可以沿叶子页顺序扫描，不必反复从根节点查找。",[18,9893,9894],{},"InnoDB 的聚簇索引叶子节点保存完整行数据，二级索引叶子节点保存二级索引键和主键值。通过二级索引查询非覆盖列时，需要先取得主键，再回到聚簇索引查找完整行，这就是常说的回表。",[638,9896,8179],{"id":8179},[59,9898,9899],{},[18,9900,9901],{},"B+ 树让非叶子节点专注于导航，以更大的扇出降低树高，并把有序数据集中在相连的叶子节点中，因此既能减少页面访问，又适合范围查询和顺序扫描。",[14,9903,69],{"id":69},[18,9905,9906],{},[73,9907,9910],{"href":9908,"target":76,"rel":9909},"\u002Fimages\u002Fwiki\u002Fjava\u002Fmysql-btree-vs-bplus-tree.svg",[78,79],[81,9911],{"src":9908,"alt":9912},"B 树与 B+ 树结构对比",[14,9914,86],{"id":86},[14,9916,9918],{"id":9917},"一先明确mysql-文档中的-b-tree-与-b-树","一、先明确：MySQL 文档中的 B-tree 与 B+ 树",[18,9920,9921,9922,9925],{},"MySQL 官方文档通常把 InnoDB 的普通索引统称为 ",[22,9923,9924],{},"B-tree"," 索引。在数据库实现和面试语境中，InnoDB 的这种索引组织通常被称为 B+ 树：",[114,9927,9928,9931,9934,9937,9940,9943],{},[117,9929,9930],{},"索引记录存放在叶子页；",[117,9932,9933],{},"非叶子页负责索引导航；",[117,9935,9936],{},"聚簇索引的叶子页保存行数据；",[117,9938,9939],{},"二级索引的叶子记录保存索引列和主键；",[117,9941,9942],{},"InnoDB 同一层的索引页通过前后页指针双向连接；",[117,9944,9945],{},"叶子页中的索引记录有序，能够进行范围扫描。",[18,9947,9948],{},"因此，“MySQL 使用 B+ 树”通常是在描述 InnoDB 普通索引的具体组织特征；它不代表 MySQL 中所有索引都使用 B+ 树。",[18,9950,1398],{},[114,9952,9953,9956,9959,9962],{},[117,9954,9955],{},"InnoDB 普通索引使用 B-tree 类结构；",[117,9957,9958],{},"空间索引使用 R-tree；",[117,9960,9961],{},"全文索引有独立的倒排索引设计；",[117,9963,9964],{},"InnoDB 还可能使用自适应哈希索引加速部分热点等值访问。",[14,9966,9968],{"id":9967},"二b-树是什么","二、B 树是什么",[18,9970,9971],{},"B 树是一种多路平衡查找树。",[18,9973,9974],{},"“多路”表示一个节点可以拥有多个子节点，而不是像二叉查找树那样最多只有两个子节点。",[18,9976,9977],{},"一个简化的 B 树可以表示为：",[95,9979,9982],{"className":9980,"code":9981,"language":100,"meta":101},[98]," [20 | 50]\n \u002F | \\\n [5 | 10] [30 | 40] [60 | 80]\n",[22,9983,9981],{"__ignoreMap":101},[18,9985,9986],{},"B 树具有以下特点：",[114,9988,9989,9992,9995,9998,10001],{},[117,9990,9991],{},"节点中的键有序；",[117,9993,9994],{},"一个节点可以保存多个键和数据记录；",[117,9996,9997],{},"非叶子节点也可以直接保存数据；",[117,9999,10000],{},"所有叶子节点通常处于同一层；",[117,10002,10003],{},"插入和删除后通过分裂、合并或旋转维持平衡。",[18,10005,10006,10007,10010],{},"查询 ",[22,10008,10009],{},"20"," 时，可能在根节点直接找到数据，不一定需要访问叶子节点。",[14,10012,10014],{"id":10013},"三b-树是什么","三、B+ 树是什么",[18,10016,10017],{},"B+ 树也是多路平衡查找树，但它把导航结构和数据记录进一步分离。",[18,10019,10020],{},"一个简化的 B+ 树可以表示为：",[95,10022,10025],{"className":10023,"code":10024,"language":100,"meta":101},[98]," [20 | 50]\n \u002F | \\\n \u002F | \\\n [5 | 10 | 20] [30 | 40 | 50] [60 | 80]\n ↔ ↔\n 叶子页通过前后页指针双向连接\n",[22,10026,10024],{"__ignoreMap":101},[18,10028,10029],{},"B+ 树具有以下典型特点：",[114,10031,10032,10035,10038,10041,10043],{},[117,10033,10034],{},"非叶子节点主要保存键和子节点指针；",[117,10036,10037],{},"完整的数据记录集中在叶子节点；",[117,10039,10040],{},"所有查询最终都会到达叶子节点；",[117,10042,9942],{},[117,10044,10045],{},"适合从某个键开始连续读取一段数据。",[18,10047,10048],{},"需要注意，示意图中的分隔键可能同时出现在非叶子节点和叶子节点中。非叶子节点中的键用于导航，叶子节点中的索引记录才承载最终数据定位信息。",[18,10050,10051,10052,10055,10056,44,10059,10062],{},"这里的双向链表连接的是",[64,10053,10054],{},"索引页","，并不是说整棵 B+ 树本身就是双向链表。整体结构仍然是一棵多路平衡树：树结构负责快速定位目标页；页面头中的 ",[22,10057,10058],{},"FIL_PAGE_PREV",[22,10060,10061],{},"FIL_PAGE_NEXT"," 字段保存前后页的页号，这些页号相当于逻辑指针，用于前后遍历。单个索引页内部的记录则主要按键值顺序组成单向链表，并由页目录辅助查找。",[14,10064,10066],{"id":10065},"四b-树与-b-树的核心区别","四、B 树与 B+ 树的核心区别",[1309,10068,10069,10081],{},[1312,10070,10071],{},[1315,10072,10073,10075,10078],{},[1318,10074,3582],{},[1318,10076,10077],{},"B 树",[1318,10079,10080],{},"B+ 树",[1328,10082,10083,10094,10105,10116,10127,10138,10149,10160],{},[1315,10084,10085,10088,10091],{},[1333,10086,10087],{},"数据记录位置",[1333,10089,10090],{},"非叶子节点和叶子节点都可以保存",[1333,10092,10093],{},"完整索引记录集中在叶子节点",[1315,10095,10096,10099,10102],{},[1333,10097,10098],{},"非叶子节点职责",[1333,10100,10101],{},"导航，同时可能保存数据",[1333,10103,10104],{},"主要负责导航",[1315,10106,10107,10110,10113],{},[1333,10108,10109],{},"单个节点可容纳的键",[1333,10111,10112],{},"相对较少",[1333,10114,10115],{},"通常更多",[1315,10117,10118,10121,10124],{},[1333,10119,10120],{},"树的扇出",[1333,10122,10123],{},"相对较小",[1333,10125,10126],{},"通常更大",[1315,10128,10129,10132,10135],{},[1333,10130,10131],{},"树高",[1333,10133,10134],{},"相同数据量下可能更高",[1333,10136,10137],{},"相同数据量下通常更低",[1315,10139,10140,10143,10146],{},[1333,10141,10142],{},"等值查询",[1333,10144,10145],{},"可能在非叶子节点提前结束",[1333,10147,10148],{},"通常需要走到叶子节点",[1315,10150,10151,10154,10157],{},[1333,10152,10153],{},"范围查询",[1333,10155,10156],{},"可能需要在树中多次定位",[1333,10158,10159],{},"定位起点后可顺序扫描叶子节点",[1315,10161,10162,10165,10168],{},[1333,10163,10164],{},"查询路径",[1333,10166,10167],{},"不同记录的结束层级可能不同",[1333,10169,10170],{},"通常都到叶子层，路径更稳定",[18,10172,10173],{},"不能简单得出“B+ 树在所有场景都比 B 树快”的结论。",[18,10175,10176],{},"如果整个数据结构都在内存中，而且只做等值查询，B 树可能在非叶子节点提前命中。但数据库索引更关心页面访问、范围扫描和批量读取，B+ 树的整体特性更适合这类负载。",[14,10178,10180],{"id":10179},"五为什么数据库关心页面访问次数","五、为什么数据库关心页面访问次数",[18,10182,10183],{},"InnoDB 管理数据的基本单位是页，默认页面大小为 16KB。",[18,10185,10186],{},"查询一个索引键时，底层不是只从磁盘读取这个键对应的几个字节，而是把相关页面读入 Buffer Pool，再在页内查找。",[18,10188,10189],{},"因此，索引设计要尽量做到：",[95,10191,10194],{"className":10192,"code":10193,"language":100,"meta":101},[98],"更少的树层级\n ↓\n更少的页面访问\n ↓\n更低的 I\u002FO 和缓存查找成本\n",[22,10195,10193],{"__ignoreMap":101},[18,10197,10198],{},"即使相关页面已经在 Buffer Pool 中，查询仍然需要逐层定位索引页、在页内比较目录项，并在必要时获取页面 Latch。树高较低通常意味着遍历的页面更少，但此时节省的主要是内存中的索引导航成本，而不是磁盘 I\u002FO。",[18,10200,10201,10202,10205],{},"所以分析 B+ 树时，不应只背诵时间复杂度 ",[22,10203,10204],{},"O(log N)","，还要关注：",[59,10207,10208],{},[18,10209,10210],{},"这个对数以多大的扇出为底，以及一次查询需要访问多少个页面。",[14,10212,10214],{"id":10213},"六扇出是什么","六、扇出是什么",[18,10216,10217],{},[64,10218,10219],{},"扇出（Fan-out）是一个非叶子节点能够直接指向的子节点数量。",[18,10221,10222],{},"在 InnoDB 中，可以把它理解为：",[59,10224,10225],{},[18,10226,10227],{},"一个非叶子索引页能够直接导航到多少个下层索引页。",[18,10229,10230],{},"例如，某个非叶子页保存了大量“索引值 + 子页面指针”目录项，并能够据此导航到约 1,000 个子页面，那么可以近似地说这个节点的扇出约为 1,000。",[18,10232,10233,10234,4878],{},"扇出不是整棵树的记录总数，也不是一个叶子页能够保存的行数。它描述的是",[64,10235,10236],{},"单个非叶子节点向下一层分出的分支数量",[18,10238,10239],{},"对于相同数量的数据，树高可以粗略理解为：",[95,10241,10244],{"className":10242,"code":10243,"language":100,"meta":101},[98],"树高 ≈ log(扇出)(需要管理的页面数)\n",[22,10245,10243],{"__ignoreMap":101},[18,10247,10248],{},"扇出越大，每增加一层能够覆盖的页面数增长得越快，因此管理相同数据量所需的层级通常越少：",[95,10250,10253],{"className":10251,"code":10252,"language":100,"meta":101},[98],"扇出为 2： 2 → 4 → 8 → 16\n扇出为 1,000： 1,000 → 1,000,000 → 1,000,000,000\n",[22,10254,10252],{"__ignoreMap":101},[18,10256,10257],{},"这里的数字只用于说明增长速度。真实扇出会受到索引键长度、页面格式、记录头、页面填充率等因素影响。",[14,10259,10261],{"id":10260},"七b-树如何通过更大的扇出降低树高","七、B+ 树如何通过更大的扇出降低树高",[18,10263,10264],{},"假设一个非叶子页既保存键，又保存完整行数据，那么每个目录项会比较大，一个页面能够容纳的目录项就比较少。",[18,10266,10267],{},"如果非叶子页只保存：",[95,10269,10272],{"className":10270,"code":10271,"language":100,"meta":101},[98],"索引键 + 子页面指针\n",[22,10273,10271],{"__ignoreMap":101},[18,10275,10276],{},"每个目录项更小，同一个 16KB 页面就能容纳更多目录项，一个节点可以指向更多子页面。",[18,10278,10279],{},"由于单个目录项更紧凑，同一个页面可以保存更多目录项、指向更多子页面，这就是 B+ 树扇出更大的原因。",[18,10281,10282],{},"例如，仅用于理解数量级，假设一个非叶子目录项平均占用 16 字节，忽略页头、槽目录、填充率和其他开销：",[95,10284,10287],{"className":10285,"code":10286,"language":100,"meta":101},[98],"16KB ÷ 16B ≈ 1024\n",[22,10288,10286],{"__ignoreMap":101},[18,10290,10291],{},"一个非叶子页理论上可以导航约一千个子页面：",[95,10293,10296],{"className":10294,"code":10295,"language":100,"meta":101},[98],"根节点：约 1,000 个分支\n第二层：约 1,000 × 1,000 个分支\n第三层：继续扩大\n",[22,10297,10295],{"__ignoreMap":101},[18,10299,10300],{},"真实容量会受到键长度、页格式、记录头、填充率等因素影响，不能直接按这个示例计算生产容量。但它能说明：",[59,10302,10303],{},[18,10304,10305],{},"多路树的扇出很大，少量层级就可以管理大量记录。",[18,10307,10308],{},[73,10309,10312],{"href":10310,"target":76,"rel":10311},"\u002Fimages\u002Fwiki\u002Fjava\u002Fmysql-bplus-tree-fanout.svg",[78,79],[81,10313],{"src":10310,"alt":10314},"B+ 树通过大扇出降低树高",[14,10316,10318],{"id":10317},"八为什么-b-树适合范围查询","八、为什么 B+ 树适合范围查询",[18,10320,10321],{},"假设执行：",[95,10323,10325],{"className":8481,"code":10324,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nWHERE id BETWEEN 1000 AND 2000;\n",[22,10326,10327,10334,10341],{"__ignoreMap":101},[141,10328,10329,10331],{"class":143,"line":144},[141,10330,8167],{"class":151},[141,10332,10333],{"class":151}," *\n",[141,10335,10336,10339],{"class":143,"line":165},[141,10337,10338],{"class":151},"FROM",[141,10340,8665],{"class":147},[141,10342,10343,10345,10347,10349,10352,10354,10357],{"class":143,"line":210},[141,10344,8542],{"class":151},[141,10346,8940],{"class":147},[141,10348,8548],{"class":151},[141,10350,10351],{"class":428}," 1000",[141,10353,8554],{"class":151},[141,10355,10356],{"class":428}," 2000",[141,10358,8560],{"class":147},[18,10360,10361,10362,10365],{},"B+ 树可以先从根节点定位到 ",[22,10363,10364],{},"id=1000"," 附近的叶子页：",[95,10367,10370],{"className":10368,"code":10369,"language":100,"meta":101},[98],"根页\n ↓\n非叶子页\n ↓\n包含 1000 的叶子页\n",[22,10371,10369],{"__ignoreMap":101},[18,10373,10374],{},"定位范围起点以后，可以沿叶子页顺序扫描：",[95,10376,10379],{"className":10377,"code":10378,"language":100,"meta":101},[98],"[1000 ... 1200] ↔ [1201 ... 1500] ↔ [1501 ... 1800] ↔ [1801 ... 2000]\n",[22,10380,10378],{"__ignoreMap":101},[18,10382,10383],{},"不需要为范围中的每一条记录重新从根节点查找。",[18,10385,10386],{},"因此，B+ 树天然适合：",[114,10388,10389,10401,10405,10411,10417,10426],{},[117,10390,10391,44,10393,44,10396,44,10398,2159],{},[22,10392,9174],{},[22,10394,10395],{},">=",[22,10397,3101],{},[22,10399,10400],{},"\u003C=",[117,10402,10403,2159],{},[22,10404,8548],{},[117,10406,10407,10408,2159],{},"有效前缀的 ",[22,10409,10410],{},"LIKE 'abc%'",[117,10412,10413,10414,2159],{},"按索引顺序执行的 ",[22,10415,10416],{},"ORDER BY",[117,10418,10419,10420,44,10423,2159],{},"部分 ",[22,10421,10422],{},"MIN",[22,10424,10425],{},"MAX",[117,10427,10428],{},"范围扫描和顺序分页。",[18,10430,10431],{},"能否真正使用索引顺序，还取决于联合索引结构、最左前缀、排序方向和执行计划，不能因为底层是 B+ 树就认为所有范围条件都会高效。",[14,10433,10435],{"id":10434},"九为什么不用二叉查找树或红黑树","九、为什么不用二叉查找树或红黑树",[18,10437,10438],{},"二叉查找树和红黑树的扇出通常是 2。",[18,10440,10441],{},"即使红黑树能够保持近似平衡，管理大量数据时树高仍然明显高于多路树：",[95,10443,10446],{"className":10444,"code":10445,"language":100,"meta":101},[98],"二叉树：\n每个节点最多 2 个分支\n\nB+ 树：\n每个页面可以拥有数百甚至更多分支\n",[22,10447,10445],{"__ignoreMap":101},[18,10449,10450],{},"如果每层节点可能位于不同页面，树越高，查询可能需要访问的页面越多。",[18,10452,10453,10454,10457],{},"红黑树很适合内存中的集合和映射，例如 Java 的 ",[22,10455,10456],{},"TreeMap","；数据库索引需要尽量减少页面 I\u002FO，并支持大范围顺序扫描，因此多路 B+ 树更加合适。",[14,10459,10461],{"id":10460},"十为什么不直接使用哈希索引","十、为什么不直接使用哈希索引",[18,10463,10464],{},"哈希结构擅长等值查询：",[95,10466,10468],{"className":8481,"code":10467,"language":8483,"meta":101,"style":101},"WHERE id = 100\n",[22,10469,10470],{"__ignoreMap":101},[141,10471,10472,10474,10476,10478],{"class":143,"line":144},[141,10473,8542],{"class":151},[141,10475,8940],{"class":147},[141,10477,152],{"class":151},[141,10479,8945],{"class":428},[18,10481,10482],{},"理想情况下可以根据哈希值直接定位桶。",[18,10484,10485],{},"但哈希值不保留原始键的顺序，因此不适合：",[95,10487,10489],{"className":8481,"code":10488,"language":8483,"meta":101,"style":101},"WHERE id > 100;\nWHERE id BETWEEN 100 AND 200;\nORDER BY id;\nLIKE 'abc%';\n",[22,10490,10491,10503,10519,10526],{"__ignoreMap":101},[141,10492,10493,10495,10497,10499,10501],{"class":143,"line":144},[141,10494,8542],{"class":151},[141,10496,8940],{"class":147},[141,10498,9174],{"class":151},[141,10500,8551],{"class":428},[141,10502,8560],{"class":147},[141,10504,10505,10507,10509,10511,10513,10515,10517],{"class":143,"line":165},[141,10506,8542],{"class":151},[141,10508,8940],{"class":147},[141,10510,8548],{"class":151},[141,10512,8551],{"class":428},[141,10514,8554],{"class":151},[141,10516,8557],{"class":428},[141,10518,8560],{"class":147},[141,10520,10521,10523],{"class":143,"line":210},[141,10522,10416],{"class":151},[141,10524,10525],{"class":147}," id;\n",[141,10527,10528,10531,10534],{"class":143,"line":219},[141,10529,10530],{"class":151},"LIKE",[141,10532,10533],{"class":911}," 'abc%'",[141,10535,8560],{"class":147},[18,10537,10538],{},"哈希索引还需要处理哈希冲突，也无法自然支持联合索引的有序最左前缀扫描。",[18,10540,10541],{},"B+ 树虽然等值查找通常需要沿树下降，但同时支持：",[114,10543,10544,10547,10550,10553,10556],{},[117,10545,10546],{},"等值查询；",[117,10548,10549],{},"范围查询；",[117,10551,10552],{},"顺序扫描；",[117,10554,10555],{},"排序；",[117,10557,10558],{},"联合索引前缀匹配。",[18,10560,10561],{},"因此它的通用性更强。",[18,10563,10564],{},"InnoDB 的自适应哈希索引可以为部分热点 B-tree 页面建立哈希访问路径，但它属于内部优化，不会替代原有 B+ 树索引。",[14,10566,10568],{"id":10567},"十一innodb-聚簇索引如何组织数据","十一、InnoDB 聚簇索引如何组织数据",[18,10570,10571],{},"每张 InnoDB 表都有一个聚簇索引。",[18,10573,10574],{},"聚簇索引的选择顺序通常是：",[2489,10576,10577,10580,10587],{},[117,10578,10579],{},"显式定义的主键；",[117,10581,10582,10583,10586],{},"第一个所有列均为 ",[22,10584,10585],{},"NOT NULL"," 的唯一索引；",[117,10588,10589],{},"InnoDB 自动生成的隐藏行 ID。",[18,10591,10592],{},"聚簇索引可以简化为：",[95,10594,10597],{"className":10595,"code":10596,"language":100,"meta":101},[98],"非叶子节点：\n主键 + 子页面指针\n\n叶子节点：\n主键 + 完整行数据\n",[22,10598,10596],{"__ignoreMap":101},[18,10600,10601],{},"因此，通过主键查询：",[95,10603,10605],{"className":8481,"code":10604,"language":8483,"meta":101,"style":101},"SELECT * FROM users WHERE id = 100;\n",[22,10606,10607],{"__ignoreMap":101},[141,10608,10609,10611,10613,10615,10618,10620,10622,10624,10626],{"class":143,"line":144},[141,10610,8167],{"class":151},[141,10612,8533],{"class":151},[141,10614,8536],{"class":151},[141,10616,10617],{"class":147}," users ",[141,10619,8542],{"class":151},[141,10621,8940],{"class":147},[141,10623,152],{"class":151},[141,10625,8551],{"class":428},[141,10627,8560],{"class":147},[18,10629,10630],{},"沿聚簇索引找到叶子记录时，通常已经取得了完整行数据。",[18,10632,10633],{},"这也是为什么官方文档把 InnoDB 表称为按聚簇索引组织的数据结构。",[14,10635,10637],{"id":10636},"十二innodb-二级索引如何组织数据","十二、InnoDB 二级索引如何组织数据",[18,10639,10640],{},"二级索引的叶子记录不直接保存完整行，而是保存：",[95,10642,10645],{"className":10643,"code":10644,"language":100,"meta":101},[98],"二级索引列 + 主键值\n",[22,10646,10644],{"__ignoreMap":101},[18,10648,10649],{},"假设存在：",[95,10651,10653],{"className":8481,"code":10652,"language":8483,"meta":101,"style":101},"CREATE INDEX idx_users_name ON users(name);\n",[22,10654,10655],{"__ignoreMap":101},[141,10656,10657,10659,10661,10664,10666,10669,10672],{"class":143,"line":144},[141,10658,8848],{"class":151},[141,10660,8851],{"class":151},[141,10662,10663],{"class":158}," idx_users_name",[141,10665,8857],{"class":151},[141,10667,10668],{"class":147}," users(",[141,10670,10671],{"class":151},"name",[141,10673,915],{"class":147},[18,10675,10676],{},"执行：",[95,10678,10680],{"className":8481,"code":10679,"language":8483,"meta":101,"style":101},"SELECT age\nFROM users\nWHERE name = 'Tom';\n",[22,10681,10682,10689,10696],{"__ignoreMap":101},[141,10683,10684,10686],{"class":143,"line":144},[141,10685,8167],{"class":151},[141,10687,10688],{"class":147}," age\n",[141,10690,10691,10693],{"class":143,"line":165},[141,10692,10338],{"class":151},[141,10694,10695],{"class":147}," users\n",[141,10697,10698,10700,10703,10705,10708],{"class":143,"line":210},[141,10699,8542],{"class":151},[141,10701,10702],{"class":151}," name",[141,10704,946],{"class":151},[141,10706,10707],{"class":911}," 'Tom'",[141,10709,8560],{"class":147},[18,10711,4060,10712,10714],{},[22,10713,2356],{}," 不在二级索引中，查询过程通常是：",[95,10716,10719],{"className":10717,"code":10718,"language":100,"meta":101},[98],"idx_users_name B+ 树\n ↓\n找到 name='Tom' 对应的主键\n ↓\n回到聚簇索引 B+ 树\n ↓\n根据主键取得完整行和 age\n",[22,10720,10718],{"__ignoreMap":101},[18,10722,10723],{},"这就是回表。",[18,10725,10726],{},"如果查询所需列都能从二级索引叶子记录中取得：",[95,10728,10730],{"className":8481,"code":10729,"language":8483,"meta":101,"style":101},"SELECT id\nFROM users\nWHERE name = 'Tom';\n",[22,10731,10732,10739,10745],{"__ignoreMap":101},[141,10733,10734,10736],{"class":143,"line":144},[141,10735,8167],{"class":151},[141,10737,10738],{"class":147}," id\n",[141,10740,10741,10743],{"class":143,"line":165},[141,10742,10338],{"class":151},[141,10744,10695],{"class":147},[141,10746,10747,10749,10751,10753,10755],{"class":143,"line":210},[141,10748,8542],{"class":151},[141,10750,10702],{"class":151},[141,10752,946],{"class":151},[141,10754,10707],{"class":911},[141,10756,8560],{"class":147},[18,10758,10759],{},"那么可能直接通过二级索引完成查询，不需要回到聚簇索引，这就是覆盖索引。",[18,10761,10762],{},[73,10763,10766],{"href":10764,"target":76,"rel":10765},"\u002Fimages\u002Fwiki\u002Fjava\u002Fmysql-innodb-index-lookup.svg",[78,79],[81,10767],{"src":10764,"alt":10768},"InnoDB 聚簇索引、二级索引与回表",[14,10770,10772],{"id":10771},"十三为什么主键不宜过长","十三、为什么主键不宜过长",[18,10774,10775],{},"InnoDB 的每条二级索引记录都包含主键值。",[18,10777,10778],{},"如果主键很长：",[95,10780,10783],{"className":10781,"code":10782,"language":100,"meta":101},[98],"每条二级索引记录更大\n ↓\n一个索引页容纳的记录更少\n ↓\n索引占用空间增加\n ↓\n缓存命中率和扇出可能下降\n",[22,10784,10782],{"__ignoreMap":101},[18,10786,10787],{},"因此，在满足业务要求的前提下，较短且稳定的主键通常更有利于 InnoDB 索引组织。",[18,10789,10790],{},"这并不意味着所有表都必须使用自增整数主键。是否采用自增 ID、分布式 ID 或业务主键，还要考虑写入热点、分库分表、数据合并和业务语义。",[14,10792,10794],{"id":10793},"十四叶子节点有序带来的其他收益","十四、叶子节点有序带来的其他收益",[18,10796,10797],{},"除了范围查询，叶子节点按键值有序还可以帮助：",[114,10799,10800,10803,10806,10809,10812],{},[117,10801,10802],{},"按索引顺序输出数据，减少额外排序；",[117,10804,10805],{},"快速定位最小值和最大值；",[117,10807,10808],{},"连续读取相邻索引记录；",[117,10810,10811],{},"对联合索引执行最左前缀扫描；",[117,10813,10814],{},"利用页预读和 Buffer Pool 提高连续访问效率。",[18,10816,10817],{},"但“逻辑有序”不等于“所有叶子页在磁盘上永远物理连续”。页面分裂、删除、合并和长期更新都会产生碎片，同层索引页主要依靠页面头中保存的前后页页号维持逻辑顺序。这些页号发挥逻辑指针的作用，并不是进程内存地址意义上的裸指针。",[14,10819,10821],{"id":10820},"十五b-树的写入代价","十五、B+ 树的写入代价",[18,10823,10824],{},"B+ 树并不是只有优点。",[18,10826,10827],{},"插入新记录时，需要先找到目标叶子页。如果页面空间不足，可能发生页分裂：",[95,10829,10832],{"className":10830,"code":10831,"language":100,"meta":101},[98],"一个满页\n ↓\n分裂为两个页\n ↓\n更新父节点目录项\n",[22,10833,10831],{"__ignoreMap":101},[18,10835,10836],{},"删除大量记录后，也可能触发页面合并或树结构收缩。",[18,10838,10839],{},"随机主键写入容易把数据分散到不同叶子页，可能带来：",[114,10841,10842,10845,10848,10851],{},[117,10843,10844],{},"更多随机页面访问；",[117,10846,10847],{},"页分裂；",[117,10849,10850],{},"页面利用率下降；",[117,10852,10853],{},"Buffer Pool 压力增加。",[18,10855,10856],{},"顺序递增键通常更容易写入索引右侧页面，但高并发场景下也可能形成右侧热点。主键选择需要结合实际写入模式评估。",[14,10858,10860],{"id":10859},"十六常见误区","十六、常见误区",[638,10862,10864],{"id":10863},"误区-1mysql-所有索引都是-b-树","误区 1：MySQL 所有索引都是 B+ 树",[18,10866,10867],{},"不准确。这里主要讨论 InnoDB 的普通索引。空间索引、全文索引和内部自适应哈希索引采用不同结构或机制。",[638,10869,10871],{"id":10870},"误区-2b-树的所有数据都只存在叶子节点","误区 2：B+ 树的所有数据都只存在叶子节点",[18,10873,10874],{},"需要区分“完整索引记录”和“分隔键”。非叶子节点也会保存用于导航的键，但完整索引记录集中在叶子节点。",[638,10876,10878],{"id":10877},"误区-3b-树一定比-b-树快","误区 3：B+ 树一定比 B 树快",[18,10880,10881],{},"不一定。纯内存、单次等值查询中，B 树可能提前在非叶子节点命中。B+ 树的优势主要体现在页面扇出、稳定查询路径和范围扫描。",[638,10883,10885],{"id":10884},"误区-4使用-b-树后查询一定只需要三次-io","误区 4：使用 B+ 树后查询一定只需要三次 I\u002FO",[18,10887,10888],{},"树高不是固定值，取决于页面大小、键长度、记录大小、填充率和数据量。页面还可能已经位于 Buffer Pool 中，因此树层访问次数也不能直接等同于磁盘 I\u002FO 次数。",[638,10890,10892],{"id":10891},"误区-5建立索引就一定能提高性能","误区 5：建立索引就一定能提高性能",[18,10894,10895,10896,44,10899,44,10901,10903],{},"索引会占用空间并增加 ",[22,10897,10898],{},"INSERT",[22,10900,8146],{},[22,10902,8149],{}," 的维护成本。低选择性索引、无法满足最左前缀的查询或返回大量数据的查询，也可能不使用索引。",[14,10905,10907],{"id":10906},"十七回答时可以怎样组织","十七、回答时可以怎样组织",[18,10909,10910],{},"面试时可以按照以下顺序回答：",[95,10912,10915],{"className":10913,"code":10914,"language":100,"meta":101},[98],"先说结构差异\n ↓\n再说数据库按页读取\n ↓\n解释扇出更大、树高更低\n ↓\n解释叶子节点有序，适合范围扫描\n ↓\n结合 InnoDB 聚簇索引和二级索引\n",[22,10916,10914],{"__ignoreMap":101},[18,10918,10919,10920,10922],{},"重点不是只说“B+ 树查询复杂度是 ",[22,10921,10204],{},"”，而是说明：",[59,10924,10925],{},[18,10926,10927],{},"InnoDB 通过页组织索引，B+ 树让一个非叶子页保存更多导航项，从而用较少层级管理大量数据；定位到叶子页后，又能沿有序叶子页完成范围扫描。",[14,10929,5605],{"id":5605},[114,10931,10932,10939,10946,10953,10960],{},[117,10933,10934],{},[73,10935,10938],{"href":10936,"rel":10937},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.4\u002Fen\u002Finnodb-index-types.html",[1876],"MySQL 8.4 Reference Manual：Clustered and Secondary Indexes",[117,10940,10941],{},[73,10942,10945],{"href":10943,"rel":10944},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.4\u002Fen\u002Finnodb-physical-structure.html",[1876],"MySQL 8.4 Reference Manual：The Physical Structure of an InnoDB Index",[117,10947,10948],{},[73,10949,10952],{"href":10950,"rel":10951},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.4\u002Fen\u002Fcolumn-indexes.html",[1876],"MySQL 8.4 Reference Manual：Column Indexes",[117,10954,10955],{},[73,10956,10959],{"href":10957,"rel":10958},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.4\u002Fen\u002Findex-btree-hash.html",[1876],"MySQL 8.4 Reference Manual：Comparison of B-Tree and Hash Indexes",[117,10961,10962],{},[73,10963,10966],{"href":10964,"rel":10965},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.4\u002Fen\u002Finnodb-file-space.html",[1876],"MySQL 8.4 Reference Manual：File Space Management",[1907,10968,10969],{},"html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}",{"title":101,"searchDepth":165,"depth":165,"links":10971},[10972,10975,10976,10977,10978,10979,10980,10981,10982,10983,10984,10985,10986,10987,10988,10989,10990,10991,10992,10999,11000],{"id":16,"depth":165,"text":16,"children":10973},[10974],{"id":8179,"depth":210,"text":8179},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":9917,"depth":165,"text":9918},{"id":9967,"depth":165,"text":9968},{"id":10013,"depth":165,"text":10014},{"id":10065,"depth":165,"text":10066},{"id":10179,"depth":165,"text":10180},{"id":10213,"depth":165,"text":10214},{"id":10260,"depth":165,"text":10261},{"id":10317,"depth":165,"text":10318},{"id":10434,"depth":165,"text":10435},{"id":10460,"depth":165,"text":10461},{"id":10567,"depth":165,"text":10568},{"id":10636,"depth":165,"text":10637},{"id":10771,"depth":165,"text":10772},{"id":10793,"depth":165,"text":10794},{"id":10820,"depth":165,"text":10821},{"id":10859,"depth":165,"text":10860,"children":10993},[10994,10995,10996,10997,10998],{"id":10863,"depth":210,"text":10864},{"id":10870,"depth":210,"text":10871},{"id":10877,"depth":210,"text":10878},{"id":10884,"depth":210,"text":10885},{"id":10891,"depth":210,"text":10892},{"id":10906,"depth":165,"text":10907},{"id":5605,"depth":165,"text":5605},"wiki:java:mysql-bplus-tree-vs-btree","从磁盘页、树高、扇出、范围查询和 InnoDB 索引组织方式出发，解释 MySQL 为何采用 B+ 树，并对比 B 树、红黑树与哈希索引。",{},76,"\u002Fjava\u002Fmysql-bplus-tree-vs-btree",{"title":9864,"description":11002},"java\u002Fmysql-bplus-tree-vs-btree","2026-07-25","jndYWwP27t-baJwZJsdJfVBgvgmQyLB_Z7vIQtvgXow",{"id":11011,"title":11012,"body":11013,"commentId":15746,"description":15747,"difficulty":3462,"draft":1943,"extension":1944,"meta":15748,"navigation":206,"order":15749,"path":15750,"section":1948,"seo":15751,"stem":15752,"updated":11008,"__hash__":15753},"java\u002Fjava\u002Fmysql-index-failure-scenarios.md","MySQL 索引在什么情况下会失效？",{"type":7,"value":11014,"toc":15679},[11015,11018,11020,11023,11053,11056,11099,11121,11123,11128,11130,11139,11141,11145,11148,11152,11155,11158,11171,11174,11205,11208,11212,11215,11217,11229,11232,11288,11303,11312,11316,11319,11325,11328,11331,11335,11338,11348,11365,11368,11374,11377,11458,11471,11474,11517,11520,11523,11527,11530,11535,11538,11541,11551,11553,11585,11588,11612,11615,11625,11629,11635,11647,11650,11684,11694,11697,11738,11741,11797,11800,11816,11819,11822,11834,11839,11845,11848,11868,11883,11886,11902,11905,11932,11935,11953,11956,12001,12003,12017,12021,12024,12052,12055,12072,12075,12091,12094,12097,12111,12114,12117,12122,12126,12128,12144,12147,12164,12171,12174,12201,12204,12207,12218,12228,12232,12239,12281,12288,12291,12311,12316,12320,12327,12330,12354,12356,12395,12398,12404,12410,12416,12419,12483,12489,12499,12541,12544,12550,12555,12562,12576,12585,12588,12611,12614,12618,12625,12635,12637,12662,12665,12681,12684,12687,12691,12694,12744,12747,12752,12755,12761,12764,12770,12774,12777,12806,12811,12817,12820,12823,12847,12851,12857,12860,12870,12872,12906,12915,12918,12941,12946,12949,12966,12969,12971,12981,12984,13028,13037,13043,13048,13081,13092,13098,13111,13114,13157,13172,13175,13178,13265,13279,13285,13295,13308,13311,13314,13317,13339,13342,13375,13378,13381,13398,13405,13425,13428,13445,13448,13453,13459,13471,13477,13481,13484,13498,13501,13504,13520,13523,13526,13530,13533,13567,13570,13662,13669,13681,13684,13689,13692,13698,13701,13703,13729,13739,13747,13755,13758,13764,13770,13776,13781,13784,13849,13852,13881,13884,13915,13918,13924,13929,13944,13971,13974,13989,13994,13999,14004,14012,14017,14024,14026,14076,14129,14140,14146,14153,14160,14205,14211,14216,14218,14233,14261,14267,14273,14279,14284,14300,14314,14317,14322,14365,14380,14387,14392,14395,14435,14438,14444,14450,14488,14490,14518,14526,14529,14555,14558,14564,14573,14579,14587,14590,14609,14614,14620,14626,14630,14633,14636,14646,14648,14696,14704,14707,14713,14721,14727,14730,14735,14742,14748,14751,14765,14768,14775,14780,14787,14792,14798,14810,14812,14823,14841,14851,14854,14860,14865,14868,14891,14899,14907,14914,14919,14922,14928,14931,14952,14954,14984,14989,14995,14998,15017,15023,15027,15167,15172,15177,15181,15188,15220,15230,15235,15269,15272,15278,15281,15313,15316,15391,15396,15402,15405,15408,15422,15429,15432,15438,15447,15450,15456,15459,15462,15468,15473,15476,15507,15509,15512,15559,15563,15567,15570,15574,15577,15587,15590,15596,15599,15603,15606,15613,15616,15618,15676],[10,11016,11012],{"id":11017},"mysql-索引在什么情况下会失效",[14,11019,16],{"id":16},[18,11021,11022],{},"所谓“索引失效”并不是 MySQL 的正式术语，实际需要区分三种情况：",[2489,11024,11025,11031,11050],{},[117,11026,11027,11028,11030],{},"SQL 写法或索引结构决定了索引无法用于快速定位，例如联合索引没有满足最左前缀、查询的是索引列的计算结果但索引只保存原始列值、",[22,11029,10530],{}," 以通配符开头。",[117,11032,11033,11034,11037,11038,11041,11042,11045,11046,11049],{},"索引可以使用，但只能使用其中一部分。例如联合索引 ",[22,11035,11036],{},"(a,b,c)"," 查询 ",[22,11039,11040],{},"a=1 AND b>10 AND c=3"," 时，通常可以用 ",[22,11043,11044],{},"a、b"," 确定扫描范围，",[22,11047,11048],{},"c"," 可能通过索引条件下推继续过滤，却不能进一步缩小连续的索引扫描区间。",[117,11051,11052],{},"索引具备使用条件，但优化器估算全表扫描成本更低，于是主动不选。例如查询返回大量数据、索引选择性很低或回表成本过高。",[18,11054,11055],{},"常见场景包括：",[114,11057,11058,11061,11064,11067,11076,11082,11093,11096],{},[117,11059,11060],{},"联合索引不满足最左前缀；",[117,11062,11063],{},"在索引列上执行函数、计算或不匹配的表达式；",[117,11065,11066],{},"比较两侧数据类型、字符集或排序规则不兼容，引发隐式转换；",[117,11068,11069,6067,11072,11075],{},[22,11070,11071],{},"LIKE '%keyword'",[22,11073,11074],{},"LIKE '%keyword%'"," 以通配符开头；",[117,11077,11078,11081],{},[22,11079,11080],{},"OR"," 的某个分支缺少可用索引，且优化器无法采用合适的 Index Merge；",[117,11083,11084,44,11086,44,11089,11092],{},[22,11085,4702],{},[22,11087,11088],{},"NOT IN",[22,11090,11091],{},"IS NOT NULL"," 等条件命中数据过多；",[117,11094,11095],{},"查询需要返回表中很大比例的数据，优化器认为全表扫描更便宜；",[117,11097,11098],{},"索引统计信息不准确，导致优化器成本估算偏差。",[18,11100,11101,11102,11105,11106,6067,11109,11112,11113,11116,11117,11120],{},"判断索引是否真正有效，不能只看 ",[22,11103,11104],{},"possible_keys","，应使用 ",[22,11107,11108],{},"EXPLAIN",[22,11110,11111],{},"EXPLAIN ANALYZE","，重点观察实际选择的 ",[22,11114,11115],{},"key","、访问类型 ",[22,11118,11119],{},"type","、预计或实际扫描行数，以及是否发生大量回表。",[638,11122,8179],{"id":8179},[59,11124,11125],{},[18,11126,11127],{},"索引失效要区分“不能用、只用一部分、能用但优化器不选”；排查时先看索引结构和 SQL 写法，再用执行计划验证实际扫描成本。",[14,11129,69],{"id":69},[18,11131,11132],{},[73,11133,11136],{"href":11134,"target":76,"rel":11135},"\u002Fimages\u002Fwiki\u002Fjava\u002Fmysql-index-failure-scenarios.svg",[78,79],[81,11137],{"src":11134,"alt":11138},"MySQL 索引失效的三类情况与排查路径",[14,11140,86],{"id":86},[14,11142,11144],{"id":11143},"一先区分三种索引失效","一、先区分三种“索引失效”",[18,11146,11147],{},"日常讨论经常把所有没有达到预期性能的情况都叫作“索引失效”，但这会掩盖真正的问题。",[638,11149,11151],{"id":11150},"_1-索引无法用于定位","1. 索引无法用于定位",[18,11153,11154],{},"索引的有序结构与查询条件不匹配，MySQL 无法根据该条件确定一个有效的索引查找范围。",[18,11156,11157],{},"例如索引为：",[95,11159,11161],{"className":8481,"code":11160,"language":8483,"meta":101,"style":101},"KEY idx_user_time (user_id, created_at)\n",[22,11162,11163],{"__ignoreMap":101},[141,11164,11165,11168],{"class":143,"line":144},[141,11166,11167],{"class":151},"KEY",[141,11169,11170],{"class":147}," idx_user_time (user_id, created_at)\n",[18,11172,11173],{},"查询只使用第二列：",[95,11175,11177],{"className":8481,"code":11176,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nWHERE created_at >= '2026-07-01';\n",[22,11178,11179,11185,11191],{"__ignoreMap":101},[141,11180,11181,11183],{"class":143,"line":144},[141,11182,8167],{"class":151},[141,11184,10333],{"class":151},[141,11186,11187,11189],{"class":143,"line":165},[141,11188,10338],{"class":151},[141,11190,8665],{"class":147},[141,11192,11193,11195,11198,11200,11203],{"class":143,"line":210},[141,11194,8542],{"class":151},[141,11196,11197],{"class":147}," created_at ",[141,11199,10395],{"class":151},[141,11201,11202],{"class":911}," '2026-07-01'",[141,11204,8560],{"class":147},[18,11206,11207],{},"传统的联合索引范围查找无法绕过第一列，直接按照第二列定位连续区间。",[638,11209,11211],{"id":11210},"_2-只使用了部分索引能力","2. 只使用了部分索引能力",[18,11213,11214],{},"SQL 使用了索引，但索引没有把扫描范围缩小到预期程度。",[18,11216,1398],{},[95,11218,11220],{"className":8481,"code":11219,"language":8483,"meta":101,"style":101},"KEY idx_abc (a, b, c)\n",[22,11221,11222],{"__ignoreMap":101},[141,11223,11224,11226],{"class":143,"line":144},[141,11225,11167],{"class":151},[141,11227,11228],{"class":147}," idx_abc (a, b, c)\n",[18,11230,11231],{},"查询：",[95,11233,11235],{"className":8481,"code":11234,"language":8483,"meta":101,"style":101},"SELECT *\nFROM t\nWHERE a = 1\n AND b > 10\n AND c = 3;\n",[22,11236,11237,11243,11250,11262,11274],{"__ignoreMap":101},[141,11238,11239,11241],{"class":143,"line":144},[141,11240,8167],{"class":151},[141,11242,10333],{"class":151},[141,11244,11245,11247],{"class":143,"line":165},[141,11246,10338],{"class":151},[141,11248,11249],{"class":147}," t\n",[141,11251,11252,11254,11257,11259],{"class":143,"line":210},[141,11253,8542],{"class":151},[141,11255,11256],{"class":147}," a ",[141,11258,152],{"class":151},[141,11260,11261],{"class":428}," 1\n",[141,11263,11264,11266,11269,11271],{"class":143,"line":219},[141,11265,9311],{"class":151},[141,11267,11268],{"class":147}," b ",[141,11270,9174],{"class":151},[141,11272,11273],{"class":428}," 10\n",[141,11275,11276,11278,11281,11283,11286],{"class":143,"line":234},[141,11277,9311],{"class":151},[141,11279,11280],{"class":147}," c ",[141,11282,152],{"class":151},[141,11284,11285],{"class":428}," 3",[141,11287,8560],{"class":147},[18,11289,11290,11291,11294,11295,11298,11299,11302],{},"通常可以使用 ",[22,11292,11293],{},"a=1 AND b>10"," 构造索引扫描范围。由于 ",[22,11296,11297],{},"b"," 是范围条件，",[22,11300,11301],{},"c=3"," 一般不能继续把这个范围切成更小的连续区间。",[18,11304,11305,11306,11308,11309,11311],{},"但这不等于 ",[22,11307,11048],{}," 完全没用。满足条件时，MySQL 可以通过索引条件下推（Index Condition Pushdown，ICP），在索引层先判断 ",[22,11310,11301],{},"，减少回表数量。",[638,11313,11315],{"id":11314},"_3-优化器主动不选择索引","3. 优化器主动不选择索引",[18,11317,11318],{},"索引本身可用，但 MySQL 优化器根据统计信息估算：",[95,11320,11323],{"className":11321,"code":11322,"language":100,"meta":101},[98],"使用二级索引扫描 + 大量回表\n >\n顺序扫描整张表\n",[22,11324,11322],{"__ignoreMap":101},[18,11326,11327],{},"于是执行计划选择全表扫描。",[18,11329,11330],{},"这种情况不是索引结构失效，而是成本选择。强行使用索引不一定更快。",[14,11332,11334],{"id":11333},"二联合索引不满足最左前缀","二、联合索引不满足最左前缀",[18,11336,11337],{},"假设存在联合索引：",[95,11339,11340],{"className":8481,"code":11219,"language":8483,"meta":101,"style":101},[22,11341,11342],{"__ignoreMap":101},[141,11343,11344,11346],{"class":143,"line":144},[141,11345,11167],{"class":151},[141,11347,11228],{"class":147},[18,11349,11350,11351,11353,11354,11356,11357,11353,11359,11361,11362,11364],{},"B+ 树中的记录首先按 ",[22,11352,73],{}," 排序；",[22,11355,73],{}," 相同时，再按 ",[22,11358,11297],{},[22,11360,11044],{}," 都相同时，才按 ",[22,11363,11048],{}," 排序。",[18,11366,11367],{},"可以近似理解为：",[95,11369,11372],{"className":11370,"code":11371,"language":100,"meta":101},[98],"(a=1, b=1, c=1)\n(a=1, b=1, c=5)\n(a=1, b=2, c=2)\n(a=2, b=1, c=3)\n",[22,11373,11371],{"__ignoreMap":101},[18,11375,11376],{},"因此以下条件通常能够使用联合索引定位：",[95,11378,11380],{"className":8481,"code":11379,"language":8483,"meta":101,"style":101},"WHERE a = 1\nWHERE a = 1 AND b = 2\nWHERE a = 1 AND b = 2 AND c = 3\nWHERE a = 1 AND c = 3\n",[22,11381,11382,11392,11412,11440],{"__ignoreMap":101},[141,11383,11384,11386,11388,11390],{"class":143,"line":144},[141,11385,8542],{"class":151},[141,11387,11256],{"class":147},[141,11389,152],{"class":151},[141,11391,11261],{"class":428},[141,11393,11394,11396,11398,11400,11403,11405,11407,11409],{"class":143,"line":165},[141,11395,8542],{"class":151},[141,11397,11256],{"class":147},[141,11399,152],{"class":151},[141,11401,11402],{"class":428}," 1",[141,11404,8554],{"class":151},[141,11406,11268],{"class":147},[141,11408,152],{"class":151},[141,11410,11411],{"class":428}," 2\n",[141,11413,11414,11416,11418,11420,11422,11424,11426,11428,11431,11433,11435,11437],{"class":143,"line":210},[141,11415,8542],{"class":151},[141,11417,11256],{"class":147},[141,11419,152],{"class":151},[141,11421,11402],{"class":428},[141,11423,8554],{"class":151},[141,11425,11268],{"class":147},[141,11427,152],{"class":151},[141,11429,11430],{"class":428}," 2",[141,11432,8554],{"class":151},[141,11434,11280],{"class":147},[141,11436,152],{"class":151},[141,11438,11439],{"class":428}," 3\n",[141,11441,11442,11444,11446,11448,11450,11452,11454,11456],{"class":143,"line":219},[141,11443,8542],{"class":151},[141,11445,11256],{"class":147},[141,11447,152],{"class":151},[141,11449,11402],{"class":428},[141,11451,8554],{"class":151},[141,11453,11280],{"class":147},[141,11455,152],{"class":151},[141,11457,11439],{"class":428},[18,11459,11460,11461,11464,11465,11467,11468,11470],{},"最后一个条件仍然可以通过 ",[22,11462,11463],{},"a=1"," 定位范围，只是缺少 ",[22,11466,11297],{}," 后，",[22,11469,11301],{}," 通常不能继续缩小查找区间。",[18,11472,11473],{},"以下查询没有使用最左列：",[95,11475,11477],{"className":8481,"code":11476,"language":8483,"meta":101,"style":101},"WHERE b = 2\nWHERE c = 3\nWHERE b = 2 AND c = 3\n",[22,11478,11479,11489,11499],{"__ignoreMap":101},[141,11480,11481,11483,11485,11487],{"class":143,"line":144},[141,11482,8542],{"class":151},[141,11484,11268],{"class":147},[141,11486,152],{"class":151},[141,11488,11411],{"class":428},[141,11490,11491,11493,11495,11497],{"class":143,"line":165},[141,11492,8542],{"class":151},[141,11494,11280],{"class":147},[141,11496,152],{"class":151},[141,11498,11439],{"class":428},[141,11500,11501,11503,11505,11507,11509,11511,11513,11515],{"class":143,"line":210},[141,11502,8542],{"class":151},[141,11504,11268],{"class":147},[141,11506,152],{"class":151},[141,11508,11430],{"class":428},[141,11510,8554],{"class":151},[141,11512,11280],{"class":147},[141,11514,152],{"class":151},[141,11516,11439],{"class":428},[18,11518,11519],{},"它们通常无法使用传统的最左前缀方式直接定位。",[18,11521,11522],{},"需要注意，MySQL 8.0 在满足条件时可能使用 Skip Scan，把缺失的最左列按多个可能值分别扫描。因此“缺少最左列一定完全不用索引”也不是绝对结论，最终必须以执行计划为准。",[14,11524,11526],{"id":11525},"三范围条件之后的列还能不能使用","三、范围条件之后的列还能不能使用",[18,11528,11529],{},"常见说法是：",[59,11531,11532],{},[18,11533,11534],{},"联合索引遇到范围查询后，后面的列全部失效。",[18,11536,11537],{},"这个说法过于绝对。",[18,11539,11540],{},"索引为：",[95,11542,11543],{"className":8481,"code":11219,"language":8483,"meta":101,"style":101},[22,11544,11545],{"__ignoreMap":101},[141,11546,11547,11549],{"class":143,"line":144},[141,11548,11167],{"class":151},[141,11550,11228],{"class":147},[18,11552,11231],{},[95,11554,11556],{"className":8481,"code":11555,"language":8483,"meta":101,"style":101},"WHERE a = 1 AND b > 10 AND c = 3\n",[22,11557,11558],{"__ignoreMap":101},[141,11559,11560,11562,11564,11566,11568,11570,11572,11574,11577,11579,11581,11583],{"class":143,"line":144},[141,11561,8542],{"class":151},[141,11563,11256],{"class":147},[141,11565,152],{"class":151},[141,11567,11402],{"class":428},[141,11569,8554],{"class":151},[141,11571,11268],{"class":147},[141,11573,9174],{"class":151},[141,11575,11576],{"class":428}," 10",[141,11578,8554],{"class":151},[141,11580,11280],{"class":147},[141,11582,152],{"class":151},[141,11584,11439],{"class":428},[18,11586,11587],{},"更准确的理解是：",[114,11589,11590,11598,11603,11609],{},[117,11591,11592,2818,11594,11597],{},[22,11593,11463],{},[22,11595,11596],{},"b>10"," 可以共同确定扫描范围；",[117,11599,11600,11602],{},[22,11601,11301],{}," 通常不能继续缩小这个连续范围；",[117,11604,11605,11606,11608],{},"如果启用了 ICP，",[22,11607,11301],{}," 仍可能在索引层参与过滤；",[117,11610,11611],{},"如果查询列都包含在索引中，还可能形成覆盖索引，避免回表。",[18,11613,11614],{},"所以“能否参与范围定位”“能否参与索引层过滤”和“能否避免回表”是三个不同问题。",[18,11616,11617,11618,11621,11622,11624],{},"另外，",[22,11619,11620],{},"IN"," 在很多情况下会被转换成多个等值范围，不应简单地把所有 ",[22,11623,11620],{}," 都视为遇到范围后索引失效。",[14,11626,11628],{"id":11627},"四在索引列上进行函数或计算","四、在索引列上进行函数或计算",[18,11630,8834,11631,11634],{},[22,11632,11633],{},"created_at"," 上有普通索引：",[95,11636,11638],{"className":8481,"code":11637,"language":8483,"meta":101,"style":101},"KEY idx_created_at (created_at)\n",[22,11639,11640],{"__ignoreMap":101},[141,11641,11642,11644],{"class":143,"line":144},[141,11643,11167],{"class":151},[141,11645,11646],{"class":147}," idx_created_at (created_at)\n",[18,11648,11649],{},"下面的写法把函数作用在索引列上：",[95,11651,11653],{"className":8481,"code":11652,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nWHERE DATE(created_at) = '2026-07-25';\n",[22,11654,11655,11661,11667],{"__ignoreMap":101},[141,11656,11657,11659],{"class":143,"line":144},[141,11658,8167],{"class":151},[141,11660,10333],{"class":151},[141,11662,11663,11665],{"class":143,"line":165},[141,11664,10338],{"class":151},[141,11666,8665],{"class":147},[141,11668,11669,11671,11674,11677,11679,11682],{"class":143,"line":210},[141,11670,8542],{"class":151},[141,11672,11673],{"class":151}," DATE",[141,11675,11676],{"class":147},"(created_at) ",[141,11678,152],{"class":151},[141,11680,11681],{"class":911}," '2026-07-25'",[141,11683,8560],{"class":147},[18,11685,11686,11687,11689,11690,11693],{},"普通索引保存的是原始 ",[22,11688,11633],{}," 值，而不是 ",[22,11691,11692],{},"DATE(created_at)"," 的计算结果。MySQL 通常无法直接根据普通索引定位函数结果。",[18,11695,11696],{},"可以改写为范围条件：",[95,11698,11700],{"className":8481,"code":11699,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nWHERE created_at >= '2026-07-25 00:00:00'\n AND created_at \u003C '2026-07-26 00:00:00';\n",[22,11701,11702,11708,11714,11725],{"__ignoreMap":101},[141,11703,11704,11706],{"class":143,"line":144},[141,11705,8167],{"class":151},[141,11707,10333],{"class":151},[141,11709,11710,11712],{"class":143,"line":165},[141,11711,10338],{"class":151},[141,11713,8665],{"class":147},[141,11715,11716,11718,11720,11722],{"class":143,"line":210},[141,11717,8542],{"class":151},[141,11719,11197],{"class":147},[141,11721,10395],{"class":151},[141,11723,11724],{"class":911}," '2026-07-25 00:00:00'\n",[141,11726,11727,11729,11731,11733,11736],{"class":143,"line":219},[141,11728,9311],{"class":151},[141,11730,11197],{"class":147},[141,11732,3101],{"class":151},[141,11734,11735],{"class":911}," '2026-07-26 00:00:00'",[141,11737,8560],{"class":147},[18,11739,11740],{},"类似问题还包括：",[95,11742,11744],{"className":8481,"code":11743,"language":8483,"meta":101,"style":101},"WHERE amount + 1 = 100\nWHERE LOWER(username) = 'tom'\nWHERE CAST(order_no AS UNSIGNED) = 1001\n",[22,11745,11746,11761,11776],{"__ignoreMap":101},[141,11747,11748,11750,11752,11755,11757,11759],{"class":143,"line":144},[141,11749,8542],{"class":151},[141,11751,8545],{"class":147},[141,11753,11754],{"class":151},"+",[141,11756,11402],{"class":428},[141,11758,946],{"class":151},[141,11760,8945],{"class":428},[141,11762,11763,11765,11768,11771,11773],{"class":143,"line":165},[141,11764,8542],{"class":151},[141,11766,11767],{"class":428}," LOWER",[141,11769,11770],{"class":147},"(username) ",[141,11772,152],{"class":151},[141,11774,11775],{"class":911}," 'tom'\n",[141,11777,11778,11780,11783,11786,11789,11792,11794],{"class":143,"line":210},[141,11779,8542],{"class":151},[141,11781,11782],{"class":428}," CAST",[141,11784,11785],{"class":147},"(order_no ",[141,11787,11788],{"class":151},"AS",[141,11790,11791],{"class":147}," UNSIGNED) ",[141,11793,152],{"class":151},[141,11795,11796],{"class":428}," 1001\n",[18,11798,11799],{},"应优先把运算移动到常量一侧：",[95,11801,11803],{"className":8481,"code":11802,"language":8483,"meta":101,"style":101},"WHERE amount = 99\n",[22,11804,11805],{"__ignoreMap":101},[141,11806,11807,11809,11811,11813],{"class":143,"line":144},[141,11808,8542],{"class":151},[141,11810,8545],{"class":147},[141,11812,152],{"class":151},[141,11814,11815],{"class":428}," 99\n",[18,11817,11818],{},"这里所说的“对索引列进行未建立函数索引的运算”，可以用下面的例子理解。",[18,11820,11821],{},"普通索引：",[95,11823,11825],{"className":8481,"code":11824,"language":8483,"meta":101,"style":101},"KEY idx_amount (amount)\n",[22,11826,11827],{"__ignoreMap":101},[141,11828,11829,11831],{"class":143,"line":144},[141,11830,11167],{"class":151},[141,11832,11833],{"class":147}," idx_amount (amount)\n",[18,11835,11836,11837,4039],{},"保存并排序的是原始 ",[22,11838,8837],{},[95,11840,11843],{"className":11841,"code":11842,"language":100,"meta":101},[98],"10 → 20 → 30 → 40\n",[22,11844,11842],{"__ignoreMap":101},[18,11846,11847],{},"查询条件却是：",[95,11849,11851],{"className":8481,"code":11850,"language":8483,"meta":101,"style":101},"WHERE amount + 1 = 31\n",[22,11852,11853],{"__ignoreMap":101},[141,11854,11855,11857,11859,11861,11863,11865],{"class":143,"line":144},[141,11856,8542],{"class":151},[141,11858,8545],{"class":147},[141,11860,11754],{"class":151},[141,11862,11402],{"class":428},[141,11864,946],{"class":151},[141,11866,11867],{"class":428}," 31\n",[18,11869,11870,11871,11874,11875,11878,11879,11882],{},"MySQL 需要比较的是 ",[22,11872,11873],{},"amount + 1"," 的结果，而普通索引中没有保存这个结果。它通常无法直接在 ",[22,11876,11877],{},"idx_amount"," 中查找 ",[22,11880,11881],{},"31","，而需要对候选记录计算表达式。",[18,11884,11885],{},"这个条件可以直接改写为：",[95,11887,11889],{"className":8481,"code":11888,"language":8483,"meta":101,"style":101},"WHERE amount = 30\n",[22,11890,11891],{"__ignoreMap":101},[141,11892,11893,11895,11897,11899],{"class":143,"line":144},[141,11894,8542],{"class":151},[141,11896,8545],{"class":147},[141,11898,152],{"class":151},[141,11900,11901],{"class":428}," 30\n",[18,11903,11904],{},"如果业务确实需要长期按照某个表达式查询，MySQL 8.0.13 及以上版本支持函数索引：",[95,11906,11908],{"className":8481,"code":11907,"language":8483,"meta":101,"style":101},"CREATE INDEX idx_amount_plus_one\nON orders ((amount + 1));\n",[22,11909,11910,11919],{"__ignoreMap":101},[141,11911,11912,11914,11916],{"class":143,"line":144},[141,11913,8848],{"class":151},[141,11915,8851],{"class":151},[141,11917,11918],{"class":158}," idx_amount_plus_one\n",[141,11920,11921,11923,11926,11928,11930],{"class":143,"line":165},[141,11922,9367],{"class":151},[141,11924,11925],{"class":147}," orders ((amount ",[141,11927,11754],{"class":151},[141,11929,11402],{"class":428},[141,11931,5007],{"class":147},[18,11933,11934],{},"之后与索引表达式匹配的查询才可以直接检索表达式结果：",[95,11936,11937],{"className":8481,"code":11850,"language":8483,"meta":101,"style":101},[22,11938,11939],{"__ignoreMap":101},[141,11940,11941,11943,11945,11947,11949,11951],{"class":143,"line":144},[141,11942,8542],{"class":151},[141,11944,8545],{"class":147},[141,11946,11754],{"class":151},[141,11948,11402],{"class":428},[141,11950,946],{"class":151},[141,11952,11867],{"class":428},[18,11954,11955],{},"也可以创建生成列，再为生成列建立索引：",[95,11957,11959],{"className":8481,"code":11958,"language":8483,"meta":101,"style":101},"ALTER TABLE orders\nADD COLUMN order_date DATE AS (DATE(created_at)),\nADD INDEX idx_order_date (order_date);\n",[22,11960,11961,11971,11992],{"__ignoreMap":101},[141,11962,11963,11966,11969],{"class":143,"line":144},[141,11964,11965],{"class":151},"ALTER",[141,11967,11968],{"class":151}," TABLE",[141,11970,8665],{"class":147},[141,11972,11973,11976,11979,11982,11985,11987,11989],{"class":143,"line":165},[141,11974,11975],{"class":151},"ADD",[141,11977,11978],{"class":147}," COLUMN order_date ",[141,11980,11981],{"class":151},"DATE",[141,11983,11984],{"class":151}," AS",[141,11986,4965],{"class":147},[141,11988,11981],{"class":151},[141,11990,11991],{"class":147},"(created_at)),\n",[141,11993,11994,11996,11998],{"class":143,"line":210},[141,11995,11975],{"class":151},[141,11997,8851],{"class":151},[141,11999,12000],{"class":147}," idx_order_date (order_date);\n",[18,12002,4629],{},[114,12004,12005,12008,12011,12014],{},[117,12006,12007],{},"函数索引保存的是表达式计算结果，不是让任意函数都自动使用原列索引；",[117,12009,12010],{},"查询中的表达式需要与索引定义匹配；",[117,12012,12013],{},"函数索引会占用空间，也会增加写入和更新成本；",[117,12015,12016],{},"能通过等价范围条件改写的 SQL，通常优先改写，未必需要新增索引。",[14,12018,12020],{"id":12019},"五隐式类型转换","五、隐式类型转换",[18,12022,12023],{},"假设订单号是字符串：",[95,12025,12027],{"className":8481,"code":12026,"language":8483,"meta":101,"style":101},"order_no VARCHAR(32),\nKEY idx_order_no (order_no)\n",[22,12028,12029,12045],{"__ignoreMap":101},[141,12030,12031,12034,12037,12039,12042],{"class":143,"line":144},[141,12032,12033],{"class":147},"order_no ",[141,12035,12036],{"class":151},"VARCHAR",[141,12038,908],{"class":147},[141,12040,12041],{"class":428},"32",[141,12043,12044],{"class":147},"),\n",[141,12046,12047,12049],{"class":143,"line":165},[141,12048,11167],{"class":151},[141,12050,12051],{"class":147}," idx_order_no (order_no)\n",[18,12053,12054],{},"推荐使用相同类型进行比较：",[95,12056,12058],{"className":8481,"code":12057,"language":8483,"meta":101,"style":101},"WHERE order_no = '10001'\n",[22,12059,12060],{"__ignoreMap":101},[141,12061,12062,12064,12067,12069],{"class":143,"line":144},[141,12063,8542],{"class":151},[141,12065,12066],{"class":147}," order_no ",[141,12068,152],{"class":151},[141,12070,12071],{"class":911}," '10001'\n",[18,12073,12074],{},"如果写成：",[95,12076,12078],{"className":8481,"code":12077,"language":8483,"meta":101,"style":101},"WHERE order_no = 10001\n",[22,12079,12080],{"__ignoreMap":101},[141,12081,12082,12084,12086,12088],{"class":143,"line":144},[141,12083,8542],{"class":151},[141,12085,12066],{"class":147},[141,12087,152],{"class":151},[141,12089,12090],{"class":428}," 10001\n",[18,12092,12093],{},"MySQL 需要按照类型转换规则比较字符串与数字，可能对索引列执行转换，导致无法按原有字符串顺序高效定位。",[18,12095,12096],{},"排查时要检查：",[114,12098,12099,12102,12105,12108],{},[117,12100,12101],{},"数字列是否与字符串参数比较；",[117,12103,12104],{},"字符串列的字符集是否一致；",[117,12106,12107],{},"字符串列的排序规则是否兼容；",[117,12109,12110],{},"JOIN 两侧字段的类型、长度、字符集和排序规则是否匹配。",[18,12112,12113],{},"例如两个字符串列字符集不兼容时，即使两侧都有索引，也可能无法高效使用索引完成连接。",[18,12115,12116],{},"最稳妥的原则是：",[59,12118,12119],{},[18,12120,12121],{},"SQL 参数类型应与索引列类型一致，JOIN 字段的类型和字符规则也应保持一致。",[14,12123,12125],{"id":12124},"六like-以通配符开头","六、LIKE 以通配符开头",[18,12127,11540],{},[95,12129,12131],{"className":8481,"code":12130,"language":8483,"meta":101,"style":101},"KEY idx_name (name)\n",[22,12132,12133],{"__ignoreMap":101},[141,12134,12135,12137,12140,12142],{"class":143,"line":144},[141,12136,11167],{"class":151},[141,12138,12139],{"class":147}," idx_name (",[141,12141,10671],{"class":151},[141,12143,1481],{"class":147},[18,12145,12146],{},"以下前缀匹配通常可以利用 B+ 树的有序性：",[95,12148,12150],{"className":8481,"code":12149,"language":8483,"meta":101,"style":101},"WHERE name LIKE 'zhizhi%'\n",[22,12151,12152],{"__ignoreMap":101},[141,12153,12154,12156,12158,12161],{"class":143,"line":144},[141,12155,8542],{"class":151},[141,12157,10702],{"class":151},[141,12159,12160],{"class":151}," LIKE",[141,12162,12163],{"class":911}," 'zhizhi%'\n",[18,12165,12166,12167,12170],{},"MySQL 可以定位到以 ",[22,12168,12169],{},"zhizhi"," 开头的索引范围。",[18,12172,12173],{},"以下写法无法确定字符串起始位置：",[95,12175,12177],{"className":8481,"code":12176,"language":8483,"meta":101,"style":101},"WHERE name LIKE '%zhizhi'\nWHERE name LIKE '%zhizhi%'\n",[22,12178,12179,12190],{"__ignoreMap":101},[141,12180,12181,12183,12185,12187],{"class":143,"line":144},[141,12182,8542],{"class":151},[141,12184,10702],{"class":151},[141,12186,12160],{"class":151},[141,12188,12189],{"class":911}," '%zhizhi'\n",[141,12191,12192,12194,12196,12198],{"class":143,"line":165},[141,12193,8542],{"class":151},[141,12195,10702],{"class":151},[141,12197,12160],{"class":151},[141,12199,12200],{"class":911}," '%zhizhi%'\n",[18,12202,12203],{},"普通 B+ 树索引通常无法据此快速定位范围。",[18,12205,12206],{},"如果查询是高频的任意位置文本搜索，应根据业务考虑：",[114,12208,12209,12212,12215],{},[117,12210,12211],{},"FULLTEXT 全文索引；",[117,12213,12214],{},"Elasticsearch 等搜索系统；",[117,12216,12217],{},"调整业务模型，保存可索引的前缀或结构化字段。",[18,12219,12220,12221,12223,12224,12227],{},"需要注意，如果查询需要的列全部包含在索引中，优化器仍可能选择扫描整个索引，因为索引比数据行更窄。此时执行计划中的 ",[22,12222,11119],{}," 可能是 ",[22,12225,12226],{},"index","，但这仍然是全索引扫描，并不是高效的范围查找。",[14,12229,12231],{"id":12230},"七or-中存在无法使用索引的分支","七、OR 中存在无法使用索引的分支",[18,12233,12234,12235,12238],{},"假设只有 ",[22,12236,12237],{},"user_id"," 有索引：",[95,12240,12242],{"className":8481,"code":12241,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nWHERE user_id = 100\n OR remark = 'manual';\n",[22,12243,12244,12250,12256,12266],{"__ignoreMap":101},[141,12245,12246,12248],{"class":143,"line":144},[141,12247,8167],{"class":151},[141,12249,10333],{"class":151},[141,12251,12252,12254],{"class":143,"line":165},[141,12253,10338],{"class":151},[141,12255,8665],{"class":147},[141,12257,12258,12260,12262,12264],{"class":143,"line":210},[141,12259,8542],{"class":151},[141,12261,9302],{"class":147},[141,12263,152],{"class":151},[141,12265,8945],{"class":428},[141,12267,12268,12271,12274,12276,12279],{"class":143,"line":219},[141,12269,12270],{"class":151}," OR",[141,12272,12273],{"class":147}," remark ",[141,12275,152],{"class":151},[141,12277,12278],{"class":911}," 'manual'",[141,12280,8560],{"class":147},[18,12282,12283,12284,12287],{},"即使第一部分能够使用索引，为了找出满足 ",[22,12285,12286],{},"remark='manual'"," 的记录，MySQL 仍可能需要扫描大量数据，最终选择全表扫描。",[18,12289,12290],{},"常见优化方式包括：",[2489,12292,12293,12296,12302,12308],{},[117,12294,12295],{},"为确实需要的条件建立合适索引；",[117,12297,12298,12299,2159],{},"在语义允许且执行计划更优时拆成两个查询并使用 ",[22,12300,12301],{},"UNION ALL",[117,12303,12304,12305,12307],{},"检查重复数据处理，不能为了用索引直接把 ",[22,12306,11080],{}," 改坏；",[117,12309,12310],{},"观察优化器是否采用 Index Merge，而不是假设多个单列索引一定会被组合。",[18,12312,4060,12313,12315],{},[22,12314,11080],{}," 两侧分别有可用索引，MySQL 可能选择 Index Merge，也可能根据成本选择其他计划。",[638,12317,12319],{"id":12318},"index-merge-是什么","Index Merge 是什么",[18,12321,12322,12323,12326],{},"Index Merge 是 MySQL 在",[64,12324,12325],{},"同一张表","上分别扫描多个索引，再合并这些索引扫描结果的访问方式。",[18,12328,12329],{},"假设存在两个单列索引：",[95,12331,12333],{"className":8481,"code":12332,"language":8483,"meta":101,"style":101},"KEY idx_user_id (user_id),\nKEY idx_status (status)\n",[22,12334,12335,12342],{"__ignoreMap":101},[141,12336,12337,12339],{"class":143,"line":144},[141,12338,11167],{"class":151},[141,12340,12341],{"class":147}," idx_user_id (user_id),\n",[141,12343,12344,12346,12349,12352],{"class":143,"line":165},[141,12345,11167],{"class":151},[141,12347,12348],{"class":147}," idx_status (",[141,12350,12351],{"class":151},"status",[141,12353,1481],{"class":147},[18,12355,11231],{},[95,12357,12359],{"className":8481,"code":12358,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nWHERE user_id = 100\n OR status = 1;\n",[22,12360,12361,12367,12373,12383],{"__ignoreMap":101},[141,12362,12363,12365],{"class":143,"line":144},[141,12364,8167],{"class":151},[141,12366,10333],{"class":151},[141,12368,12369,12371],{"class":143,"line":165},[141,12370,10338],{"class":151},[141,12372,8665],{"class":147},[141,12374,12375,12377,12379,12381],{"class":143,"line":210},[141,12376,8542],{"class":151},[141,12378,9302],{"class":147},[141,12380,152],{"class":151},[141,12382,8945],{"class":428},[141,12384,12385,12387,12389,12391,12393],{"class":143,"line":219},[141,12386,12270],{"class":151},[141,12388,9314],{"class":151},[141,12390,946],{"class":151},[141,12392,11402],{"class":428},[141,12394,8560],{"class":147},[18,12396,12397],{},"MySQL 可以分别得到：",[95,12399,12402],{"className":12400,"code":12401,"language":100,"meta":101},[98],"idx_user_id 扫描结果：满足 user_id=100 的行 ID\nidx_status 扫描结果：满足 status=1 的行 ID\n ↓\n 合并并去重\n ↓\n 读取完整记录\n",[22,12403,12401],{"__ignoreMap":101},[18,12405,12406,12407,12409],{},"在 ",[22,12408,11108],{}," 中通常表现为：",[95,12411,12414],{"className":12412,"code":12413,"language":100,"meta":101},[98],"type: index_merge\nkey: idx_user_id,idx_status\nExtra: Using union(...)\n",[22,12415,12413],{"__ignoreMap":101},[18,12417,12418],{},"Index Merge 主要有三种合并方式：",[1309,12420,12421,12434],{},[1312,12422,12423],{},[1315,12424,12425,12428,12431],{},[1318,12426,12427],{},"方式",[1318,12429,12430],{},"适用逻辑",[1318,12432,12433],{},"处理方式",[1328,12435,12436,12453,12467],{},[1315,12437,12438,12443,12450],{},[1333,12439,12440],{},[22,12441,12442],{},"Using intersect(...)",[1333,12444,12445,12446,12449],{},"多个条件用 ",[22,12447,12448],{},"AND"," 连接",[1333,12451,12452],{},"取多个索引结果的交集",[1315,12454,12455,12460,12464],{},[1333,12456,12457],{},[22,12458,12459],{},"Using union(...)",[1333,12461,12445,12462,12449],{},[22,12463,11080],{},[1333,12465,12466],{},"取多个索引结果的并集",[1315,12468,12469,12474,12480],{},[1333,12470,12471],{},[22,12472,12473],{},"Using sort_union(...)",[1333,12475,12476,12477,12479],{},"多个范围条件用 ",[22,12478,11080],{}," 连接，但不能直接使用 union 算法",[1333,12481,12482],{},"收集全部行 ID，排序、去重后再读取记录",[638,12484,12486,12488],{"id":12485},"using-sort_union-是什么意思",[22,12487,12473],{}," 是什么意思",[18,12490,12491,12492,2818,12495,12498],{},"先看一个典型查询。假设 ",[22,12493,12494],{},"key_col1",[22,12496,12497],{},"key_col2"," 分别建立了单列索引：",[95,12500,12502],{"className":8481,"code":12501,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nWHERE key_col1 \u003C 10\n OR key_col2 \u003C 20;\n",[22,12503,12504,12510,12516,12527],{"__ignoreMap":101},[141,12505,12506,12508],{"class":143,"line":144},[141,12507,8167],{"class":151},[141,12509,10333],{"class":151},[141,12511,12512,12514],{"class":143,"line":165},[141,12513,10338],{"class":151},[141,12515,8665],{"class":147},[141,12517,12518,12520,12523,12525],{"class":143,"line":210},[141,12519,8542],{"class":151},[141,12521,12522],{"class":147}," key_col1 ",[141,12524,3101],{"class":151},[141,12526,11273],{"class":428},[141,12528,12529,12531,12534,12536,12539],{"class":143,"line":219},[141,12530,12270],{"class":151},[141,12532,12533],{"class":147}," key_col2 ",[141,12535,3101],{"class":151},[141,12537,12538],{"class":428}," 20",[141,12540,8560],{"class":147},[18,12542,12543],{},"优化器可以分别扫描两个索引，但这两个范围扫描产生的行 ID 不能直接按 union 算法边扫描边归并。此时可能采用 sort-union：",[95,12545,12548],{"className":12546,"code":12547,"language":100,"meta":101},[98],"扫描 key_col1 \u003C 10，收集行 ID\n \\\n → 汇总全部行 ID → 按行 ID 排序 → 去重 → 读取完整记录\n \u002F\n扫描 key_col2 \u003C 20，收集行 ID\n",[22,12549,12547],{"__ignoreMap":101},[18,12551,12552,12553,4878],{},"以 InnoDB 二级索引为例，这里的“行 ID”通常可以理解为索引记录中携带的主键值。排序的对象是这些用于定位记录的标识，不是对最终查询结果执行 ",[22,12554,10416],{},[18,12556,12557,6242,12559,12561],{},[22,12558,12459],{},[22,12560,12473],{}," 的关键区别是：",[114,12563,12564,12570],{},[117,12565,12566,12569],{},[22,12567,12568],{},"union"," 可以对多个索引扫描产生的有序行 ID 流直接归并；",[117,12571,12572,12575],{},[22,12573,12574],{},"sort_union"," 需要先收集所有行 ID，再排序和去重，因此在完成收集与排序前不能开始返回记录。",[18,12577,12578,12579,12581,12582,12584],{},"所以 ",[22,12580,12574],{}," 通常比直接的 ",[22,12583,12568],{}," 多出行 ID 缓冲、排序和去重成本。候选记录很多时，优化器也可能认为全表扫描更便宜，最终不选择 Index Merge。",[18,12586,12587],{},"需要特别区分：",[114,12589,12590,12595,12602],{},[117,12591,12592,12594],{},[22,12593,12473],{}," 是同一张表内部多个索引扫描结果的合并算法；",[117,12596,12597,12598,12601],{},"SQL 的 ",[22,12599,12600],{},"UNION"," 是多个查询结果集的集合运算；",[117,12603,12604,12607,12608,12610],{},[22,12605,12606],{},"Using filesort"," 通常表示为了满足 ",[22,12609,10416],{}," 等要求进行额外排序。",[18,12612,12613],{},"这三者不是一回事。",[638,12615,12617],{"id":12616},"index-merge-从哪个版本开始支持","Index Merge 从哪个版本开始支持",[18,12619,12620,12621,12624],{},"Index Merge 从 ",[64,12622,12623],{},"MySQL 5.0"," 开始引入。在此之前，一张表在一次查询访问中通常至多选择一个索引；MySQL 5.0 开始可以在同一张表上扫描多个索引并合并结果。",[18,12626,12627,12628,44,12631,12634],{},"需要注意，Index Merge 本身是 MySQL 5.0 就有的访问方式，而用于显式影响它的 ",[22,12629,12630],{},"INDEX_MERGE",[22,12632,12633],{},"NO_INDEX_MERGE"," 优化器 Hint 是后续版本才增加的能力，不应把两者的版本混为一谈。",[18,12636,1398],{},[95,12638,12640],{"className":8481,"code":12639,"language":8483,"meta":101,"style":101},"WHERE user_id = 100\n AND status = 1\n",[22,12641,12642,12652],{"__ignoreMap":101},[141,12643,12644,12646,12648,12650],{"class":143,"line":144},[141,12645,8542],{"class":151},[141,12647,9302],{"class":147},[141,12649,152],{"class":151},[141,12651,8945],{"class":428},[141,12653,12654,12656,12658,12660],{"class":143,"line":165},[141,12655,9311],{"class":151},[141,12657,9314],{"class":151},[141,12659,946],{"class":151},[141,12661,11261],{"class":428},[18,12663,12664],{},"优化器可能分别扫描两个索引后取交集。不过，很多情况下建立符合查询模式的联合索引：",[95,12666,12668],{"className":8481,"code":12667,"language":8483,"meta":101,"style":101},"KEY idx_user_status (user_id, status)\n",[22,12669,12670],{"__ignoreMap":101},[141,12671,12672,12674,12677,12679],{"class":143,"line":144},[141,12673,11167],{"class":151},[141,12675,12676],{"class":147}," idx_user_status (user_id, ",[141,12678,12351],{"class":151},[141,12680,1481],{"class":147},[18,12682,12683],{},"会比扫描并合并两个单列索引更直接。",[18,12685,12686],{},"因此 Index Merge 是优化器可选择的一种方案，不代表“多个单列索引一定等价于联合索引”。它也只合并同一张表上的索引扫描，不负责合并不同表的索引。",[14,12688,12690],{"id":12689},"八否定条件和低选择性条件","八、否定条件和低选择性条件",[18,12692,12693],{},"以下条件经常返回大量记录：",[95,12695,12697],{"className":8481,"code":12696,"language":8483,"meta":101,"style":101},"WHERE status != 1\nWHERE type NOT IN (1, 2)\nWHERE deleted_at IS NOT NULL\n",[22,12698,12699,12710,12734],{"__ignoreMap":101},[141,12700,12701,12703,12705,12708],{"class":143,"line":144},[141,12702,8542],{"class":151},[141,12704,9314],{"class":151},[141,12706,12707],{"class":151}," !=",[141,12709,11261],{"class":428},[141,12711,12712,12714,12717,12720,12723,12725,12727,12729,12732],{"class":143,"line":165},[141,12713,8542],{"class":151},[141,12715,12716],{"class":151}," type",[141,12718,12719],{"class":151}," NOT",[141,12721,12722],{"class":151}," IN",[141,12724,4965],{"class":147},[141,12726,2225],{"class":428},[141,12728,4981],{"class":147},[141,12730,12731],{"class":428},"2",[141,12733,1481],{"class":147},[141,12735,12736,12738,12741],{"class":143,"line":210},[141,12737,8542],{"class":151},[141,12739,12740],{"class":147}," deleted_at ",[141,12742,12743],{"class":151},"IS NOT NULL\n",[18,12745,12746],{},"这些操作符并不意味着语法上绝对不能使用索引。真正的问题通常是选择性：",[59,12748,12749],{},[18,12750,12751],{},"如果条件会命中表中大部分记录，使用二级索引定位后再逐条回表，可能比全表扫描更贵。",[18,12753,12754],{},"同理，以下字段即使有索引，也可能因为区分度太低而不被选择：",[95,12756,12759],{"className":12757,"code":12758,"language":100,"meta":101},[98],"性别\n是否删除\n只有少量枚举值的状态\n大量相同值的业务类型\n",[22,12760,12758],{"__ignoreMap":101},[18,12762,12763],{},"低基数字段并非永远不适合索引。如果它与其他字段组成联合索引、查询命中比例很低，或者能够形成覆盖索引，依然可能产生价值。",[18,12765,11617,12766,12769],{},[22,12767,12768],{},"IS NULL"," 可以使用索引，不应把它列为固定的索引失效规则。",[14,12771,12773],{"id":12772},"九查询返回数据过多","九、查询返回数据过多",[18,12775,12776],{},"假设表中有 100 万行，而条件预计返回 80 万行：",[95,12778,12780],{"className":8481,"code":12779,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nWHERE status = 1;\n",[22,12781,12782,12788,12794],{"__ignoreMap":101},[141,12783,12784,12786],{"class":143,"line":144},[141,12785,8167],{"class":151},[141,12787,10333],{"class":151},[141,12789,12790,12792],{"class":143,"line":165},[141,12791,10338],{"class":151},[141,12793,8665],{"class":147},[141,12795,12796,12798,12800,12802,12804],{"class":143,"line":210},[141,12797,8542],{"class":151},[141,12799,9314],{"class":151},[141,12801,946],{"class":151},[141,12803,11402],{"class":428},[141,12805,8560],{"class":147},[18,12807,4060,12808,12810],{},[22,12809,12351],{}," 是二级索引，执行过程可能是：",[95,12812,12815],{"className":12813,"code":12814,"language":100,"meta":101},[98],"扫描大量二级索引记录\n ↓\n根据主键逐条回表\n ↓\n读取完整行\n",[22,12816,12814],{"__ignoreMap":101},[18,12818,12819],{},"大量离散回表的成本可能高于直接扫描聚簇索引，因此优化器会主动选择全表扫描。",[18,12821,12822],{},"可以从以下方向优化：",[114,12824,12825,12828,12831,12834,12837,12840],{},[117,12826,12827],{},"确认业务是否真的需要返回如此多的数据；",[117,12829,12830],{},"增加更有区分度的查询条件；",[117,12832,12833],{},"建立符合查询模式的联合索引；",[117,12835,12836],{},"只查询必要字段，评估覆盖索引；",[117,12838,12839],{},"分页或分批处理；",[117,12841,12842,12843,12846],{},"避免用 ",[22,12844,12845],{},"FORCE INDEX"," 掩盖不合理的数据访问方式。",[14,12848,12850],{"id":12849},"十order-by-或-group-by-没有匹配索引顺序","十、ORDER BY 或 GROUP BY 没有匹配索引顺序",[18,12852,12853,12854,12856],{},"索引不仅可以用于 ",[22,12855,8542],{}," 过滤，也可以帮助排序和分组，但需要满足相应的顺序条件。",[18,12858,12859],{},"例如索引：",[95,12861,12862],{"className":8481,"code":11160,"language":8483,"meta":101,"style":101},[22,12863,12864],{"__ignoreMap":101},[141,12865,12866,12868],{"class":143,"line":144},[141,12867,11167],{"class":151},[141,12869,11170],{"class":147},[18,12871,11231],{},[95,12873,12875],{"className":8481,"code":12874,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nWHERE user_id = 100\nORDER BY created_at;\n",[22,12876,12877,12883,12889,12899],{"__ignoreMap":101},[141,12878,12879,12881],{"class":143,"line":144},[141,12880,8167],{"class":151},[141,12882,10333],{"class":151},[141,12884,12885,12887],{"class":143,"line":165},[141,12886,10338],{"class":151},[141,12888,8665],{"class":147},[141,12890,12891,12893,12895,12897],{"class":143,"line":210},[141,12892,8542],{"class":151},[141,12894,9302],{"class":147},[141,12896,152],{"class":151},[141,12898,8945],{"class":428},[141,12900,12901,12903],{"class":143,"line":219},[141,12902,10416],{"class":151},[141,12904,12905],{"class":147}," created_at;\n",[18,12907,12908,12909,12911,12912,12914],{},"通常可以利用索引中同一 ",[22,12910,12237],{}," 下 ",[22,12913,11633],{}," 有序的特点。",[18,12916,12917],{},"但下面的查询未限定最左列：",[95,12919,12921],{"className":8481,"code":12920,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nORDER BY created_at;\n",[22,12922,12923,12929,12935],{"__ignoreMap":101},[141,12924,12925,12927],{"class":143,"line":144},[141,12926,8167],{"class":151},[141,12928,10333],{"class":151},[141,12930,12931,12933],{"class":143,"line":165},[141,12932,10338],{"class":151},[141,12934,8665],{"class":147},[141,12936,12937,12939],{"class":143,"line":210},[141,12938,10416],{"class":151},[141,12940,12905],{"class":147},[18,12942,12943,12945],{},[22,12944,11633],{}," 在整棵联合索引中并不是全局连续有序，通常无法直接利用该索引消除排序。",[18,12947,12948],{},"以下情况也可能无法直接使用索引顺序：",[114,12950,12951,12954,12957,12960,12963],{},[117,12952,12953],{},"排序列顺序与联合索引不匹配；",[117,12955,12956],{},"联合索引中，排序列前面存在没有被固定为常量的索引列；",[117,12958,12959],{},"对排序列执行表达式或函数；",[117,12961,12962],{},"多张表连接后按非驱动表字段排序；",[117,12964,12965],{},"混合升降序与索引定义不匹配。",[638,12967,12968],{"id":12968},"过滤条件如何影响索引顺序",[18,12970,11337],{},[95,12972,12973],{"className":8481,"code":11219,"language":8483,"meta":101,"style":101},[22,12974,12975],{"__ignoreMap":101},[141,12976,12977,12979],{"class":143,"line":144},[141,12978,11167],{"class":151},[141,12980,11228],{"class":147},[18,12982,12983],{},"下面的查询可以利用索引顺序：",[95,12985,12987],{"className":8481,"code":12986,"language":8483,"meta":101,"style":101},"SELECT *\nFROM t\nWHERE a = 1\n AND b = 2\nORDER BY c;\n",[22,12988,12989,12995,13001,13011,13021],{"__ignoreMap":101},[141,12990,12991,12993],{"class":143,"line":144},[141,12992,8167],{"class":151},[141,12994,10333],{"class":151},[141,12996,12997,12999],{"class":143,"line":165},[141,12998,10338],{"class":151},[141,13000,11249],{"class":147},[141,13002,13003,13005,13007,13009],{"class":143,"line":210},[141,13004,8542],{"class":151},[141,13006,11256],{"class":147},[141,13008,152],{"class":151},[141,13010,11261],{"class":428},[141,13012,13013,13015,13017,13019],{"class":143,"line":219},[141,13014,9311],{"class":151},[141,13016,11268],{"class":147},[141,13018,152],{"class":151},[141,13020,11411],{"class":428},[141,13022,13023,13025],{"class":143,"line":234},[141,13024,10416],{"class":151},[141,13026,13027],{"class":147}," c;\n",[18,13029,13030,13031,13033,13034,13036],{},"因为 ",[22,13032,11044],{}," 都固定为常量，剩余记录天然按照 ",[22,13035,11048],{}," 排序：",[95,13038,13041],{"className":13039,"code":13040,"language":100,"meta":101},[98],"(a=1, b=2, c=1)\n(a=1, b=2, c=2)\n(a=1, b=2, c=3)\n",[22,13042,13040],{"__ignoreMap":101},[18,13044,13045,13046,4039],{},"如果只固定 ",[22,13047,73],{},[95,13049,13051],{"className":8481,"code":13050,"language":8483,"meta":101,"style":101},"SELECT *\nFROM t\nWHERE a = 1\nORDER BY c;\n",[22,13052,13053,13059,13065,13075],{"__ignoreMap":101},[141,13054,13055,13057],{"class":143,"line":144},[141,13056,8167],{"class":151},[141,13058,10333],{"class":151},[141,13060,13061,13063],{"class":143,"line":165},[141,13062,10338],{"class":151},[141,13064,11249],{"class":147},[141,13066,13067,13069,13071,13073],{"class":143,"line":210},[141,13068,8542],{"class":151},[141,13070,11256],{"class":147},[141,13072,152],{"class":151},[141,13074,11261],{"class":428},[141,13076,13077,13079],{"class":143,"line":219},[141,13078,10416],{"class":151},[141,13080,13027],{"class":147},[18,13082,13083,13084,13086,13087,13089,13090,13036],{},"索引记录先按照 ",[22,13085,11297],{}," 排序，再在相同 ",[22,13088,11297],{}," 中按照 ",[22,13091,11048],{},[95,13093,13096],{"className":13094,"code":13095,"language":100,"meta":101},[98],"(a=1, b=1, c=1)\n(a=1, b=1, c=9)\n(a=1, b=2, c=2)\n(a=1, b=2, c=8)\n",[22,13097,13095],{"__ignoreMap":101},[18,13099,13100,13101,13103,13104,13107,13108,4878],{},"从整体看，",[22,13102,11048],{}," 的顺序是 ",[22,13105,13106],{},"1、9、2、8","，并不是全局有序，因此通常仍需 ",[22,13109,13110],{},"filesort",[18,13112,13113],{},"范围条件也可能产生类似效果：",[95,13115,13117],{"className":8481,"code":13116,"language":8483,"meta":101,"style":101},"SELECT *\nFROM t\nWHERE a = 1\n AND b > 10\nORDER BY c;\n",[22,13118,13119,13125,13131,13141,13151],{"__ignoreMap":101},[141,13120,13121,13123],{"class":143,"line":144},[141,13122,8167],{"class":151},[141,13124,10333],{"class":151},[141,13126,13127,13129],{"class":143,"line":165},[141,13128,10338],{"class":151},[141,13130,11249],{"class":147},[141,13132,13133,13135,13137,13139],{"class":143,"line":210},[141,13134,8542],{"class":151},[141,13136,11256],{"class":147},[141,13138,152],{"class":151},[141,13140,11261],{"class":428},[141,13142,13143,13145,13147,13149],{"class":143,"line":219},[141,13144,9311],{"class":151},[141,13146,11268],{"class":147},[141,13148,9174],{"class":151},[141,13150,11273],{"class":428},[141,13152,13153,13155],{"class":143,"line":234},[141,13154,10416],{"class":151},[141,13156,13027],{"class":147},[18,13158,13159,13160,13162,13163,13165,13166,13168,13169,13171],{},"扫描结果首先按不同的 ",[22,13161,11297],{}," 值分组，每个 ",[22,13164,11297],{}," 内部才按 ",[22,13167,11048],{}," 排序，所以不能直接保证全局 ",[22,13170,11048],{}," 有序。",[638,13173,13174],{"id":13174},"为什么按非驱动表字段排序通常需要额外排序",[18,13176,13177],{},"假设查询：",[95,13179,13181],{"className":8481,"code":13180,"language":8483,"meta":101,"style":101},"SELECT o.id, u.name\nFROM orders o\nJOIN users u ON u.id = o.user_id\nWHERE o.created_at >= '2026-07-01'\nORDER BY u.name;\n",[22,13182,13183,13204,13211,13237,13253],{"__ignoreMap":101},[141,13184,13185,13187,13190,13192,13194,13196,13199,13201],{"class":143,"line":144},[141,13186,8167],{"class":151},[141,13188,13189],{"class":428}," o",[141,13191,431],{"class":147},[141,13193,8958],{"class":428},[141,13195,4981],{"class":147},[141,13197,13198],{"class":428},"u",[141,13200,431],{"class":147},[141,13202,13203],{"class":428},"name\n",[141,13205,13206,13208],{"class":143,"line":165},[141,13207,10338],{"class":151},[141,13209,13210],{"class":147}," orders o\n",[141,13212,13213,13216,13219,13221,13224,13226,13228,13230,13232,13234],{"class":143,"line":210},[141,13214,13215],{"class":151},"JOIN",[141,13217,13218],{"class":147}," users u ",[141,13220,9367],{"class":151},[141,13222,13223],{"class":428}," u",[141,13225,431],{"class":147},[141,13227,8958],{"class":428},[141,13229,946],{"class":151},[141,13231,13189],{"class":428},[141,13233,431],{"class":147},[141,13235,13236],{"class":428},"user_id\n",[141,13238,13239,13241,13243,13245,13247,13250],{"class":143,"line":219},[141,13240,8542],{"class":151},[141,13242,13189],{"class":428},[141,13244,431],{"class":147},[141,13246,11633],{"class":428},[141,13248,13249],{"class":151}," >=",[141,13251,13252],{"class":911}," '2026-07-01'\n",[141,13254,13255,13257,13259,13261,13263],{"class":143,"line":234},[141,13256,10416],{"class":151},[141,13258,13223],{"class":428},[141,13260,431],{"class":147},[141,13262,10671],{"class":428},[141,13264,8560],{"class":147},[18,13266,13267,13268,13271,13272,13275,13276,13278],{},"假设优化器选择 ",[22,13269,13270],{},"orders"," 作为第一个非 ",[22,13273,13274],{},"const"," 表，也就是先按订单时间读取订单，再逐条根据 ",[22,13277,12237],{}," 查询用户：",[95,13280,13283],{"className":13281,"code":13282,"language":100,"meta":101},[98],"按 orders.created_at 读取订单\n ↓\n逐条查找对应 users\n ↓\n得到的 u.name 没有全局顺序\n ↓\n对连接结果执行 filesort\n",[22,13284,13282],{"__ignoreMap":101},[18,13286,176,13287,13290,13291,13294],{},[22,13288,13289],{},"users.name"," 上有索引，这个索引也只保证从 ",[22,13292,13293],{},"users"," 出发扫描时的姓名顺序，不能保证“先读取订单、再查用户”得到的连接结果按姓名有序。",[18,13296,13297,13298,13300,13301,13303,13304,13307],{},"如果优化器能够把 ",[22,13299,13293],{}," 调整为驱动表，并且从 ",[22,13302,13289],{}," 索引按顺序读取，再连接订单，就可能利用该顺序。但是否能够这样执行，还取决于过滤条件、连接关系、成本估算和 ",[22,13305,13306],{},"LIMIT"," 等因素。",[638,13309,13310],{"id":13310},"索引方向与查询方向如何匹配",[18,13312,13313],{},"MySQL 8.0 支持降序索引，也支持反向扫描 B+ 树索引。",[18,13315,13316],{},"索引：",[95,13318,13320],{"className":8481,"code":13319,"language":8483,"meta":101,"style":101},"KEY idx_ab (a ASC, b ASC)\n",[22,13321,13322],{"__ignoreMap":101},[141,13323,13324,13326,13329,13332,13335,13337],{"class":143,"line":144},[141,13325,11167],{"class":151},[141,13327,13328],{"class":147}," idx_ab (a ",[141,13330,13331],{"class":151},"ASC",[141,13333,13334],{"class":147},", b ",[141,13336,13331],{"class":151},[141,13338,1481],{"class":147},[18,13340,13341],{},"通常可以支持：",[95,13343,13345],{"className":8481,"code":13344,"language":8483,"meta":101,"style":101},"ORDER BY a ASC, b ASC\nORDER BY a DESC, b DESC\n",[22,13346,13347,13361],{"__ignoreMap":101},[141,13348,13349,13351,13353,13355,13358],{"class":143,"line":144},[141,13350,10416],{"class":151},[141,13352,11256],{"class":147},[141,13354,13331],{"class":151},[141,13356,13357],{"class":147},", b ",[141,13359,13360],{"class":151},"ASC\n",[141,13362,13363,13365,13367,13370,13372],{"class":143,"line":165},[141,13364,10416],{"class":151},[141,13366,11256],{"class":147},[141,13368,13369],{"class":151},"DESC",[141,13371,13334],{"class":147},[141,13373,13374],{"class":151},"DESC\n",[18,13376,13377],{},"第二条可以通过整体反向扫描完成。",[18,13379,13380],{},"但混合方向：",[95,13382,13384],{"className":8481,"code":13383,"language":8483,"meta":101,"style":101},"ORDER BY a ASC, b DESC\n",[22,13385,13386],{"__ignoreMap":101},[141,13387,13388,13390,13392,13394,13396],{"class":143,"line":144},[141,13389,10416],{"class":151},[141,13391,11256],{"class":147},[141,13393,13331],{"class":151},[141,13395,13334],{"class":147},[141,13397,13374],{"class":151},[18,13399,13400,13401,13404],{},"与 ",[22,13402,13403],{},"(a ASC, b ASC)"," 的排序关系不同。要直接使用索引顺序，应建立方向相匹配的索引：",[95,13406,13408],{"className":8481,"code":13407,"language":8483,"meta":101,"style":101},"KEY idx_ab_mixed (a ASC, b DESC)\n",[22,13409,13410],{"__ignoreMap":101},[141,13411,13412,13414,13417,13419,13421,13423],{"class":143,"line":144},[141,13413,11167],{"class":151},[141,13415,13416],{"class":147}," idx_ab_mixed (a ",[141,13418,13331],{"class":151},[141,13420,13334],{"class":147},[141,13422,13369],{"class":151},[141,13424,1481],{"class":147},[18,13426,13427],{},"这个索引也可以通过整体反向扫描支持：",[95,13429,13431],{"className":8481,"code":13430,"language":8483,"meta":101,"style":101},"ORDER BY a DESC, b ASC\n",[22,13432,13433],{"__ignoreMap":101},[141,13434,13435,13437,13439,13441,13443],{"class":143,"line":144},[141,13436,10416],{"class":151},[141,13438,11256],{"class":147},[141,13440,13369],{"class":151},[141,13442,13334],{"class":147},[141,13444,13360],{"class":151},[18,13446,13447],{},"所以更准确的规则是：",[59,13449,13450],{},[18,13451,13452],{},"所有列同向时，升序索引可以正向或反向扫描；升降序混合时，索引各列的方向关系需要与查询一致，或者与查询整体相反。",[18,13454,13455,13456,13458],{},"MySQL 5.7 及更早版本虽然允许在索引定义中书写 ",[22,13457,13369],{},"，但通常不会真正按降序存储键值。讨论索引方向时必须结合实际 MySQL 版本。",[18,13460,13461,13462,13464,13465,13468,13469,4878],{},"此时 ",[22,13463,11108],{}," 的 ",[22,13466,13467],{},"Extra"," 中可能出现 ",[22,13470,12606],{},[18,13472,13473,13474,13476],{},"需要注意，",[22,13475,12606],{}," 表示没有直接利用索引顺序完成排序，并不保证真的使用磁盘文件；数据较小时也可能在内存中排序。",[14,13478,13480],{"id":13479},"十一索引统计信息不准确","十一、索引统计信息不准确",[18,13482,13483],{},"MySQL 优化器依赖统计信息估算：",[114,13485,13486,13489,13492,13495],{},[117,13487,13488],{},"条件会命中多少行；",[117,13490,13491],{},"不同索引的选择性；",[117,13493,13494],{},"扫描和回表成本；",[117,13496,13497],{},"JOIN 的顺序及成本。",[18,13499,13500],{},"如果数据分布发生剧烈变化，而统计信息未能反映真实情况，优化器可能选错索引或改用全表扫描。",[18,13502,13503],{},"可以先通过执行计划验证估算行数与实际行数是否偏差明显，再根据情况评估：",[95,13505,13507],{"className":8481,"code":13506,"language":8483,"meta":101,"style":101},"ANALYZE TABLE orders;\n",[22,13508,13509],{"__ignoreMap":101},[141,13510,13511,13514,13517],{"class":143,"line":144},[141,13512,13513],{"class":147},"ANALYZE ",[141,13515,13516],{"class":151},"TABLE",[141,13518,13519],{"class":147}," orders;\n",[18,13521,13522],{},"MySQL 8.0 还可以使用直方图帮助优化器理解非索引列或数据分布不均匀字段的值分布。",[18,13524,13525],{},"不要在没有验证的情况下频繁更新统计信息，也不要把所有执行计划问题都归因于统计信息。",[14,13527,13529],{"id":13528},"十二如何用-explain-判断","十二、如何用 EXPLAIN 判断",[18,13531,13532],{},"基础排查可以执行：",[95,13534,13536],{"className":8481,"code":13535,"language":8483,"meta":101,"style":101},"EXPLAIN\nSELECT *\nFROM orders\nWHERE user_id = 100;\n",[22,13537,13538,13543,13549,13555],{"__ignoreMap":101},[141,13539,13540],{"class":143,"line":144},[141,13541,13542],{"class":147},"EXPLAIN\n",[141,13544,13545,13547],{"class":143,"line":165},[141,13546,8167],{"class":151},[141,13548,10333],{"class":151},[141,13550,13551,13553],{"class":143,"line":210},[141,13552,10338],{"class":151},[141,13554,8665],{"class":147},[141,13556,13557,13559,13561,13563,13565],{"class":143,"line":219},[141,13558,8542],{"class":151},[141,13560,9302],{"class":147},[141,13562,152],{"class":151},[141,13564,8551],{"class":428},[141,13566,8560],{"class":147},[18,13568,13569],{},"重点观察：",[1309,13571,13572,13581],{},[1312,13573,13574],{},[1315,13575,13576,13578],{},[1318,13577,2344],{},[1318,13579,13580],{},"关注点",[1328,13582,13583,13592,13601,13611,13633,13643,13653],{},[1315,13584,13585,13589],{},[1333,13586,13587],{},[22,13588,11104],{},[1333,13590,13591],{},"理论上可能使用哪些索引",[1315,13593,13594,13598],{},[1333,13595,13596],{},[22,13597,11115],{},[1333,13599,13600],{},"优化器最终选择了哪个索引",[1315,13602,13603,13608],{},[1333,13604,13605],{},[22,13606,13607],{},"key_len",[1333,13609,13610],{},"实际使用的索引长度，可辅助判断联合索引用到哪一部分",[1315,13612,13613,13617],{},[1333,13614,13615],{},[22,13616,11119],{},[1333,13618,13619,13620,44,13622,44,13625,44,13628,44,13630],{},"访问方式，如 ",[22,13621,13274],{},[22,13623,13624],{},"ref",[22,13626,13627],{},"range",[22,13629,12226],{},[22,13631,13632],{},"ALL",[1315,13634,13635,13640],{},[1333,13636,13637],{},[22,13638,13639],{},"rows",[1333,13641,13642],{},"预计需要检查的行数",[1315,13644,13645,13650],{},[1333,13646,13647],{},[22,13648,13649],{},"filtered",[1333,13651,13652],{},"经过表条件过滤后预计保留的百分比",[1315,13654,13655,13659],{},[1333,13656,13657],{},[22,13658,13467],{},[1333,13660,13661],{},"是否覆盖索引、ICP、额外排序或临时表等",[638,13663,13665,13666,13668],{"id":13664},"_1-type-到底表示什么","1. ",[22,13667,11119],{}," 到底表示什么",[18,13670,13671,13673,13674,13677,13678,4878],{},[22,13672,11119],{}," 表示 MySQL 访问当前表中记录的方式。在 ",[22,13675,13676],{},"EXPLAIN FORMAT=JSON"," 中，对应字段名是 ",[22,13679,13680],{},"access_type",[18,13682,13683],{},"它回答的不是“有没有索引”这么简单，而是：",[59,13685,13686],{},[18,13687,13688],{},"MySQL 准备通过唯一键直接取一行、按普通索引查一组记录、扫描一个索引范围，还是扫描整棵索引或整张表？",[18,13690,13691],{},"官方文档通常按照下面的顺序描述常见访问类型：",[95,13693,13696],{"className":13694,"code":13695,"language":100,"meta":101},[98],"system\n ↓\nconst\n ↓\neq_ref\n ↓\nref\n ↓\nrange\n ↓\nindex\n ↓\nALL\n",[22,13697,13695],{"__ignoreMap":101},[18,13699,13700],{},"越靠前通常代表定位越精确，但这不是脱离数据量的绝对性能排名。",[18,13702,1398],{},[114,13704,13705,13711,13719,13724],{},[117,13706,13707,13708,13710],{},"小表使用 ",[22,13709,13632],{}," 可能只扫描几十行，成本很低；",[117,13712,13713,13715,13716,13718],{},[22,13714,13624],{}," 虽然比 ",[22,13717,13627],{}," 靠前，但如果某个值匹配几十万行，仍然可能很慢；",[117,13720,13721,13723],{},[22,13722,13627],{}," 如果只扫描十行，通常会非常高效；",[117,13725,13726,13728],{},[22,13727,12226],{}," 虽然使用了索引，却可能把整个索引扫描一遍。",[18,13730,13731,13732,13734,13735,13738],{},"所以查看 ",[22,13733,11119],{}," 后，还必须结合 ",[22,13736,13737],{},"key、rows、filtered、Extra"," 以及实际耗时判断。",[638,13740,13742,13743,13746],{"id":13741},"_2-system表中只有一行","2. ",[22,13744,13745],{},"system","：表中只有一行",[18,13748,13749,13751,13752,13754],{},[22,13750,13745],{}," 是 ",[22,13753,13274],{}," 的特殊情况，表示优化器判断当前表只有一行。",[18,13756,13757],{},"访问过程可以理解为：",[95,13759,13762],{"className":13760,"code":13761,"language":100,"meta":101},[98],"整张表只有一行\n ↓\n直接读取这一行\n",[22,13763,13761],{"__ignoreMap":101},[18,13765,13766,13767,13769],{},"它在普通 InnoDB 业务表的执行计划中并不常见。看到 ",[22,13768,13745],{}," 时，不需要把它理解成某种特殊索引；它表达的是表规模已经确定为单行，因此没有查找范围可言。",[638,13771,6239,13773,13775],{"id":13772},"_3-const通过主键或唯一键最多定位一行",[22,13774,13274],{},"：通过主键或唯一键最多定位一行",[18,13777,13778,13780],{},[22,13779,13274],{}," 表示当前表最多只有一条记录满足条件，并且这条记录在查询开始时只需要读取一次。",[18,13782,13783],{},"典型场景是使用常量匹配主键或完整唯一索引：",[95,13785,13787],{"className":8481,"code":13786,"language":8483,"meta":101,"style":101},"CREATE TABLE users (\n id BIGINT PRIMARY KEY,\n email VARCHAR(128) NOT NULL,\n UNIQUE KEY uk_email (email)\n);\n",[22,13788,13789,13801,13815,13834,13845],{"__ignoreMap":101},[141,13790,13791,13793,13795,13798],{"class":143,"line":144},[141,13792,8848],{"class":151},[141,13794,11968],{"class":151},[141,13796,13797],{"class":158}," users",[141,13799,13800],{"class":147}," (\n",[141,13802,13803,13806,13809,13812],{"class":143,"line":165},[141,13804,13805],{"class":147}," id ",[141,13807,13808],{"class":151},"BIGINT",[141,13810,13811],{"class":151}," PRIMARY KEY",[141,13813,13814],{"class":147},",\n",[141,13816,13817,13820,13822,13824,13827,13830,13832],{"class":143,"line":210},[141,13818,13819],{"class":147}," email ",[141,13821,12036],{"class":151},[141,13823,908],{"class":147},[141,13825,13826],{"class":428},"128",[141,13828,13829],{"class":147},") ",[141,13831,10585],{"class":151},[141,13833,13814],{"class":147},[141,13835,13836,13839,13842],{"class":143,"line":219},[141,13837,13838],{"class":151}," UNIQUE",[141,13840,13841],{"class":151}," KEY",[141,13843,13844],{"class":147}," uk_email (email)\n",[141,13846,13847],{"class":143,"line":234},[141,13848,915],{"class":147},[18,13850,13851],{},"查询主键：",[95,13853,13855],{"className":8481,"code":13854,"language":8483,"meta":101,"style":101},"SELECT *\nFROM users\nWHERE id = 100;\n",[22,13856,13857,13863,13869],{"__ignoreMap":101},[141,13858,13859,13861],{"class":143,"line":144},[141,13860,8167],{"class":151},[141,13862,10333],{"class":151},[141,13864,13865,13867],{"class":143,"line":165},[141,13866,10338],{"class":151},[141,13868,10695],{"class":147},[141,13870,13871,13873,13875,13877,13879],{"class":143,"line":210},[141,13872,8542],{"class":151},[141,13874,8940],{"class":147},[141,13876,152],{"class":151},[141,13878,8551],{"class":428},[141,13880,8560],{"class":147},[18,13882,13883],{},"或者查询唯一键：",[95,13885,13887],{"className":8481,"code":13886,"language":8483,"meta":101,"style":101},"SELECT *\nFROM users\nWHERE email = 'tom@example.com';\n",[22,13888,13889,13895,13901],{"__ignoreMap":101},[141,13890,13891,13893],{"class":143,"line":144},[141,13892,8167],{"class":151},[141,13894,10333],{"class":151},[141,13896,13897,13899],{"class":143,"line":165},[141,13898,10338],{"class":151},[141,13900,10695],{"class":147},[141,13902,13903,13905,13908,13910,13913],{"class":143,"line":210},[141,13904,8542],{"class":151},[141,13906,13907],{"class":147}," email ",[141,13909,152],{"class":151},[141,13911,13912],{"class":911}," 'tom@example.com'",[141,13914,8560],{"class":147},[18,13916,13917],{},"由于主键或唯一键能够保证最多返回一行，MySQL 可以直接定位目标记录：",[95,13919,13922],{"className":13920,"code":13921,"language":100,"meta":101},[98],"常量值\n ↓\n主键或唯一索引查找\n ↓\n最多一条记录\n",[22,13923,13921],{"__ignoreMap":101},[18,13925,13926,13927,4039],{},"如果是联合唯一索引，需要把能够确定唯一记录的索引列完整匹配，才容易形成 ",[22,13928,13274],{},[95,13930,13932],{"className":8481,"code":13931,"language":8483,"meta":101,"style":101},"UNIQUE KEY uk_tenant_order (tenant_id, order_no)\n",[22,13933,13934],{"__ignoreMap":101},[141,13935,13936,13939,13941],{"class":143,"line":144},[141,13937,13938],{"class":151},"UNIQUE",[141,13940,13841],{"class":151},[141,13942,13943],{"class":147}," uk_tenant_order (tenant_id, order_no)\n",[95,13945,13947],{"className":8481,"code":13946,"language":8483,"meta":101,"style":101},"WHERE tenant_id = 10\n AND order_no = 'A1001'\n",[22,13948,13949,13960],{"__ignoreMap":101},[141,13950,13951,13953,13956,13958],{"class":143,"line":144},[141,13952,8542],{"class":151},[141,13954,13955],{"class":147}," tenant_id ",[141,13957,152],{"class":151},[141,13959,11273],{"class":428},[141,13961,13962,13964,13966,13968],{"class":143,"line":165},[141,13963,9311],{"class":151},[141,13965,12066],{"class":147},[141,13967,152],{"class":151},[141,13969,13970],{"class":911}," 'A1001'\n",[18,13972,13973],{},"如果只查询：",[95,13975,13977],{"className":8481,"code":13976,"language":8483,"meta":101,"style":101},"WHERE tenant_id = 10\n",[22,13978,13979],{"__ignoreMap":101},[141,13980,13981,13983,13985,13987],{"class":143,"line":144},[141,13982,8542],{"class":151},[141,13984,13955],{"class":147},[141,13986,152],{"class":151},[141,13988,11273],{"class":428},[18,13990,13991,13992,4878],{},"可能返回多行，通常就不是 ",[22,13993,13274],{},[18,13995,13996,13998],{},[22,13997,13274],{}," 的核心不是“使用了等号”，而是：",[59,14000,14001],{},[18,14002,14003],{},"通过常量和唯一约束，能够确定当前表最多只返回一条记录。",[638,14005,14007,14008,14011],{"id":14006},"_4-eq_refjoin-时每条前表记录最多匹配一行","4. ",[22,14009,14010],{},"eq_ref","：JOIN 时每条前表记录最多匹配一行",[18,14013,14014,14016],{},[22,14015,14010],{}," 最常见于多表 JOIN。",[18,14018,14019,14020,14023],{},"它表示对于前面表产生的每一条记录，MySQL 都通过主键或 ",[22,14021,14022],{},"UNIQUE NOT NULL"," 索引，在当前表中最多查到一条记录。",[18,14025,1398],{},[95,14027,14029],{"className":8481,"code":14028,"language":8483,"meta":101,"style":101},"CREATE TABLE orders (\n id BIGINT PRIMARY KEY,\n user_id BIGINT NOT NULL,\n KEY idx_user_id (user_id)\n);\n",[22,14030,14031,14042,14052,14064,14072],{"__ignoreMap":101},[141,14032,14033,14035,14037,14040],{"class":143,"line":144},[141,14034,8848],{"class":151},[141,14036,11968],{"class":151},[141,14038,14039],{"class":158}," orders",[141,14041,13800],{"class":147},[141,14043,14044,14046,14048,14050],{"class":143,"line":165},[141,14045,13805],{"class":147},[141,14047,13808],{"class":151},[141,14049,13811],{"class":151},[141,14051,13814],{"class":147},[141,14053,14054,14057,14059,14062],{"class":143,"line":210},[141,14055,14056],{"class":147}," user_id ",[141,14058,13808],{"class":151},[141,14060,14061],{"class":151}," NOT NULL",[141,14063,13814],{"class":147},[141,14065,14066,14069],{"class":143,"line":219},[141,14067,14068],{"class":151}," KEY",[141,14070,14071],{"class":147}," idx_user_id (user_id)\n",[141,14073,14074],{"class":143,"line":234},[141,14075,915],{"class":147},[95,14077,14079],{"className":8481,"code":14078,"language":8483,"meta":101,"style":101},"SELECT o.id, u.name\nFROM orders o\nJOIN users u ON u.id = o.user_id;\n",[22,14080,14081,14099,14105],{"__ignoreMap":101},[141,14082,14083,14085,14087,14089,14091,14093,14095,14097],{"class":143,"line":144},[141,14084,8167],{"class":151},[141,14086,13189],{"class":428},[141,14088,431],{"class":147},[141,14090,8958],{"class":428},[141,14092,4981],{"class":147},[141,14094,13198],{"class":428},[141,14096,431],{"class":147},[141,14098,13203],{"class":428},[141,14100,14101,14103],{"class":143,"line":165},[141,14102,10338],{"class":151},[141,14104,13210],{"class":147},[141,14106,14107,14109,14111,14113,14115,14117,14119,14121,14123,14125,14127],{"class":143,"line":210},[141,14108,13215],{"class":151},[141,14110,13218],{"class":147},[141,14112,9367],{"class":151},[141,14114,13223],{"class":428},[141,14116,431],{"class":147},[141,14118,8958],{"class":428},[141,14120,946],{"class":151},[141,14122,13189],{"class":428},[141,14124,431],{"class":147},[141,14126,12237],{"class":428},[141,14128,8560],{"class":147},[18,14130,14131,14132,14134,14135,11037,14138,4039],{},"假设执行顺序是先读取 ",[22,14133,13270],{},"，再根据 ",[22,14136,14137],{},"o.user_id",[22,14139,13293],{},[95,14141,14144],{"className":14142,"code":14143,"language":100,"meta":101},[98],"orders 的一条记录\n ↓\nu.id = o.user_id\n ↓\n通过 users 主键最多定位一行\n",[22,14145,14143],{"__ignoreMap":101},[18,14147,13461,14148,14150,14151,4878],{},[22,14149,13293],{}," 表的访问类型可能是 ",[22,14152,14010],{},[18,14154,14155,2818,14157,14159],{},[22,14156,13274],{},[22,14158,14010],{}," 的区别是：",[1309,14161,14162,14175],{},[1312,14163,14164],{},[1315,14165,14166,14169,14172],{},[1318,14167,14168],{},"类型",[1318,14170,14171],{},"查找值来自哪里",[1318,14173,14174],{},"典型场景",[1328,14176,14177,14191],{},[1315,14178,14179,14183,14186],{},[1333,14180,14181],{},[22,14182,13274],{},[1333,14184,14185],{},"SQL 中的常量",[1333,14187,14188],{},[22,14189,14190],{},"WHERE id = 100",[1315,14192,14193,14197,14200],{},[1333,14194,14195],{},[22,14196,14010],{},[1333,14198,14199],{},"前面表的列值",[1333,14201,14202],{},[22,14203,14204],{},"u.id = o.user_id",[638,14206,4891,14208,14210],{"id":14207},"_5-ref通过非唯一索引等值查找一组记录",[22,14209,13624],{},"：通过非唯一索引等值查找一组记录",[18,14212,14213,14215],{},[22,14214,13624],{}," 表示使用普通索引或联合索引的非唯一前缀进行等值查找，可能返回多条具有相同索引值的记录。",[18,14217,1398],{},[95,14219,14221],{"className":8481,"code":14220,"language":8483,"meta":101,"style":101},"KEY idx_status (status)\n",[22,14222,14223],{"__ignoreMap":101},[141,14224,14225,14227,14229,14231],{"class":143,"line":144},[141,14226,11167],{"class":151},[141,14228,12348],{"class":147},[141,14230,12351],{"class":151},[141,14232,1481],{"class":147},[95,14234,14235],{"className":8481,"code":12779,"language":8483,"meta":101,"style":101},[22,14236,14237,14243,14249],{"__ignoreMap":101},[141,14238,14239,14241],{"class":143,"line":144},[141,14240,8167],{"class":151},[141,14242,10333],{"class":151},[141,14244,14245,14247],{"class":143,"line":165},[141,14246,10338],{"class":151},[141,14248,8665],{"class":147},[141,14250,14251,14253,14255,14257,14259],{"class":143,"line":210},[141,14252,8542],{"class":151},[141,14254,9314],{"class":151},[141,14256,946],{"class":151},[141,14258,11402],{"class":428},[141,14260,8560],{"class":147},[18,14262,4060,14263,14266],{},[22,14264,14265],{},"status=1"," 对应多条订单，访问过程是：",[95,14268,14271],{"className":14269,"code":14270,"language":100,"meta":101},[98],"在 idx_status 中定位 status=1 的起点\n ↓\n连续读取所有 status=1 的索引记录\n ↓\n按需回表\n",[22,14272,14270],{"__ignoreMap":101},[18,14274,14275,14276,14278],{},"因此，",[22,14277,13624],{}," 不代表只读取一行。它可能读取几行，也可能读取几十万行，实际成本取决于索引选择性和回表数量。",[18,14280,14281,14282,4039],{},"联合索引只使用左侧一部分时，也可能出现 ",[22,14283,13624],{},[95,14285,14287],{"className":8481,"code":14286,"language":8483,"meta":101,"style":101},"KEY idx_tenant_status (tenant_id, status)\n",[22,14288,14289],{"__ignoreMap":101},[141,14290,14291,14293,14296,14298],{"class":143,"line":144},[141,14292,11167],{"class":151},[141,14294,14295],{"class":147}," idx_tenant_status (tenant_id, ",[141,14297,12351],{"class":151},[141,14299,1481],{"class":147},[95,14301,14302],{"className":8481,"code":13976,"language":8483,"meta":101,"style":101},[22,14303,14304],{"__ignoreMap":101},[141,14305,14306,14308,14310,14312],{"class":143,"line":144},[141,14307,8542],{"class":151},[141,14309,13955],{"class":147},[141,14311,152],{"class":151},[141,14313,11273],{"class":428},[18,14315,14316],{},"虽然使用了索引最左列，但同一个租户可能有大量记录，所以仍然是非唯一匹配。",[18,14318,14319,14320,4039],{},"JOIN 中如果使用普通索引关联，也常见 ",[22,14321,13624],{},[95,14323,14325],{"className":8481,"code":14324,"language":8483,"meta":101,"style":101},"SELECT *\nFROM users u\nJOIN orders o ON o.user_id = u.id;\n",[22,14326,14327,14333,14340],{"__ignoreMap":101},[141,14328,14329,14331],{"class":143,"line":144},[141,14330,8167],{"class":151},[141,14332,10333],{"class":151},[141,14334,14335,14337],{"class":143,"line":165},[141,14336,10338],{"class":151},[141,14338,14339],{"class":147}," users u\n",[141,14341,14342,14344,14347,14349,14351,14353,14355,14357,14359,14361,14363],{"class":143,"line":210},[141,14343,13215],{"class":151},[141,14345,14346],{"class":147}," orders o ",[141,14348,9367],{"class":151},[141,14350,13189],{"class":428},[141,14352,431],{"class":147},[141,14354,12237],{"class":428},[141,14356,946],{"class":151},[141,14358,13223],{"class":428},[141,14360,431],{"class":147},[141,14362,8958],{"class":428},[141,14364,8560],{"class":147},[18,14366,14367,14368,14371,14372,14374,14375,14377,14378,4878],{},"对于每个用户，普通索引 ",[22,14369,14370],{},"orders.idx_user_id"," 可能匹配多条订单，因此 ",[22,14373,13270],{}," 的访问类型可能是 ",[22,14376,13624],{},"，而不是 ",[22,14379,14010],{},[638,14381,14383,14384,14386],{"id":14382},"_6-range扫描索引中的一个或多个区间","6. ",[22,14385,13627],{},"：扫描索引中的一个或多个区间",[18,14388,14389,14391],{},[22,14390,13627],{}," 表示 MySQL 先根据条件确定一个或多个索引区间，然后只扫描这些区间中的记录。",[18,14393,14394],{},"典型范围查询：",[95,14396,14398],{"className":8481,"code":14397,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nWHERE created_at >= '2026-07-01'\n AND created_at \u003C '2026-08-01';\n",[22,14399,14400,14406,14412,14422],{"__ignoreMap":101},[141,14401,14402,14404],{"class":143,"line":144},[141,14403,8167],{"class":151},[141,14405,10333],{"class":151},[141,14407,14408,14410],{"class":143,"line":165},[141,14409,10338],{"class":151},[141,14411,8665],{"class":147},[141,14413,14414,14416,14418,14420],{"class":143,"line":210},[141,14415,8542],{"class":151},[141,14417,11197],{"class":147},[141,14419,10395],{"class":151},[141,14421,13252],{"class":911},[141,14423,14424,14426,14428,14430,14433],{"class":143,"line":219},[141,14425,9311],{"class":151},[141,14427,11197],{"class":147},[141,14429,3101],{"class":151},[141,14431,14432],{"class":911}," '2026-08-01'",[141,14434,8560],{"class":147},[18,14436,14437],{},"索引访问过程可以理解为：",[95,14439,14442],{"className":14440,"code":14441,"language":100,"meta":101},[98],"定位 2026-07-01 的索引位置\n ↓\n沿叶子节点向后扫描\n ↓\n到达 2026-08-01 时停止\n",[22,14443,14441],{"__ignoreMap":101},[18,14445,14446,14447,14449],{},"常见能够形成 ",[22,14448,13627],{}," 的条件包括：",[114,14451,14452,14462,14466,14472,14476,14481],{},[117,14453,14454,44,14456,44,14458,44,14460,2159],{},[22,14455,9174],{},[22,14457,10395],{},[22,14459,3101],{},[22,14461,10400],{},[117,14463,14464,2159],{},[22,14465,8548],{},[117,14467,14468,14471],{},[22,14469,14470],{},"IN (...)"," 形成多个离散范围；",[117,14473,14474,2159],{},[22,14475,12768],{},[117,14477,14478,14479,2159],{},"能确定前缀范围的 ",[22,14480,10410],{},[117,14482,14483,14484,14487],{},"某些 ",[22,14485,14486],{},"\u003C>"," 或其他可转化为索引区间的条件。",[18,14489,1398],{},[95,14491,14493],{"className":8481,"code":14492,"language":8483,"meta":101,"style":101},"WHERE id IN (10, 20, 30)\n",[22,14494,14495],{"__ignoreMap":101},[141,14496,14497,14499,14501,14503,14505,14507,14509,14511,14513,14516],{"class":143,"line":144},[141,14498,8542],{"class":151},[141,14500,8940],{"class":147},[141,14502,11620],{"class":151},[141,14504,4965],{"class":147},[141,14506,2255],{"class":428},[141,14508,4981],{"class":147},[141,14510,10009],{"class":428},[141,14512,4981],{"class":147},[141,14514,14515],{"class":428},"30",[141,14517,1481],{"class":147},[18,14519,14520,14521,14523,14524,4878],{},"虽然使用的是多个等值条件，优化器也可能把它组织成多个索引范围，因此 ",[22,14522,11119],{}," 显示为 ",[22,14525,13627],{},[18,14527,14528],{},"具体来说，范围优化器可以把：",[95,14530,14531],{"className":8481,"code":14492,"language":8483,"meta":101,"style":101},[22,14532,14533],{"__ignoreMap":101},[141,14534,14535,14537,14539,14541,14543,14545,14547,14549,14551,14553],{"class":143,"line":144},[141,14536,8542],{"class":151},[141,14538,8940],{"class":147},[141,14540,11620],{"class":151},[141,14542,4965],{"class":147},[141,14544,2255],{"class":428},[141,14546,4981],{"class":147},[141,14548,10009],{"class":428},[141,14550,4981],{"class":147},[141,14552,14515],{"class":428},[141,14554,1481],{"class":147},[18,14556,14557],{},"转换为同一个索引上的三个单点区间：",[95,14559,14562],{"className":14560,"code":14561,"language":100,"meta":101},[98],"[10, 10]\n∪\n[20, 20]\n∪\n[30, 30]\n",[22,14563,14561],{"__ignoreMap":101},[18,14565,14566,14567,14569,14570,14572],{},"执行时并不是从 ",[22,14568,2255],{}," 一直扫描到 ",[22,14571,14515],{},"，而是分别在同一棵 B+ 树中定位这些单点范围，再合并访问结果：",[95,14574,14577],{"className":14575,"code":14576,"language":100,"meta":101},[98],"定位 id=10\n定位 id=20\n定位 id=30\n ↓\n返回三个范围的记录\n",[22,14578,14576],{"__ignoreMap":101},[18,14580,14581,14582,14584,14585,4878],{},"因此，SQL 语义上虽然是多个等值条件，物理访问方式仍属于“扫描一个或多个索引范围”，",[22,14583,11119],{}," 可以显示为 ",[22,14586,13627],{},[18,14588,14589],{},"这与 Index Merge 不同：",[114,14591,14592,14602],{},[117,14593,14594,14597,14598,14601],{},[22,14595,14596],{},"IN (10,20,30)"," 通常是在",[64,14599,14600],{},"同一个索引","上构造多个范围；",[117,14603,14604,14605,14608],{},"Index Merge 是扫描",[64,14606,14607],{},"同一张表的多个索引","，再合并结果。",[18,14610,14611,14613],{},[22,14612,13627],{}," 是否高效，主要看范围大小：",[95,14615,14618],{"className":14616,"code":14617,"language":100,"meta":101},[98],"扫描 10 条索引记录 → 通常很快\n扫描 80 万条索引记录 → 仍可能很慢\n",[22,14619,14617],{"__ignoreMap":101},[18,14621,14622,14623,14625],{},"所以不能看到 ",[22,14624,13627],{}," 就直接认定 SQL 已经优化完成。",[638,14627,14629],{"id":14628},"_7-icp在回表前用索引中的字段过滤","7. ICP：在回表前用索引中的字段过滤",[18,14631,14632],{},"ICP 全称是 Index Condition Pushdown，中文通常称为“索引条件下推”。",[18,14634,14635],{},"仍然使用联合索引：",[95,14637,14638],{"className":8481,"code":11219,"language":8483,"meta":101,"style":101},[22,14639,14640],{"__ignoreMap":101},[141,14641,14642,14644],{"class":143,"line":144},[141,14643,11167],{"class":151},[141,14645,11228],{"class":147},[18,14647,11231],{},[95,14649,14650],{"className":8481,"code":11234,"language":8483,"meta":101,"style":101},[22,14651,14652,14658,14664,14674,14684],{"__ignoreMap":101},[141,14653,14654,14656],{"class":143,"line":144},[141,14655,8167],{"class":151},[141,14657,10333],{"class":151},[141,14659,14660,14662],{"class":143,"line":165},[141,14661,10338],{"class":151},[141,14663,11249],{"class":147},[141,14665,14666,14668,14670,14672],{"class":143,"line":210},[141,14667,8542],{"class":151},[141,14669,11256],{"class":147},[141,14671,152],{"class":151},[141,14673,11261],{"class":428},[141,14675,14676,14678,14680,14682],{"class":143,"line":219},[141,14677,9311],{"class":151},[141,14679,11268],{"class":147},[141,14681,9174],{"class":151},[141,14683,11273],{"class":428},[141,14685,14686,14688,14690,14692,14694],{"class":143,"line":234},[141,14687,9311],{"class":151},[141,14689,11280],{"class":147},[141,14691,152],{"class":151},[141,14693,11285],{"class":428},[141,14695,8560],{"class":147},[18,14697,14698,14700,14701,14703],{},[22,14699,11293],{}," 可以确定索引扫描范围，但 ",[22,14702,11301],{}," 通常不能继续缩小这个连续范围。",[18,14705,14706],{},"没有 ICP 时，过程近似为：",[95,14708,14711],{"className":14709,"code":14710,"language":100,"meta":101},[98],"扫描满足 a=1、b>10 的二级索引记录\n ↓\n每一条都根据主键回表\n ↓\n取得完整行后判断 c=3\n",[22,14712,14710],{"__ignoreMap":101},[18,14714,14715,14716,14718,14719,4039],{},"开启 ICP 后，由于 ",[22,14717,11048],{}," 也存储在联合索引中，存储引擎可以先检查索引记录中的 ",[22,14720,11048],{},[95,14722,14725],{"className":14723,"code":14724,"language":100,"meta":101},[98],"扫描满足 a=1、b>10 的二级索引记录\n ↓\n直接在索引记录中判断 c=3\n ├─ 不满足：跳过，不回表\n └─ 满足：根据主键回表\n",[22,14726,14724],{"__ignoreMap":101},[18,14728,14729],{},"它的主要收益是：",[59,14731,14732],{},[18,14733,14734],{},"减少不必要的聚簇索引回表，而不是进一步缩小最初的索引扫描范围。",[18,14736,12406,14737,13464,14739,14741],{},[22,14738,11108],{},[22,14740,13467],{}," 中通常显示：",[95,14743,14746],{"className":14744,"code":14745,"language":100,"meta":101},[98],"Using index condition\n",[22,14747,14745],{"__ignoreMap":101},[18,14749,14750],{},"ICP 与覆盖索引也不同：",[114,14752,14753,14756],{},[117,14754,14755],{},"ICP：仍可能需要回表，只是先在索引层过滤；",[117,14757,14758,14759,14761,14762,4878],{},"覆盖索引：查询所需数据全部在索引中，最终也不需要回表，",[22,14760,13467],{}," 常见 ",[22,14763,14764],{},"Using index",[18,14766,14767],{},"只有能够利用当前索引记录判断的条件，才适合下推到存储引擎；依赖其他表、存储函数或无法从索引记录取得的数据，通常不能这样处理。",[638,14769,14771,14772,14774],{"id":14770},"_8-index把整棵索引扫描一遍","8. ",[22,14773,12226],{},"：把整棵索引扫描一遍",[18,14776,14777,14779],{},[22,14778,12226],{}," 很容易被误解为“查询已经通过索引精准定位”。",[18,14781,14782,14783,14786],{},"实际上，",[22,14784,14785],{},"type=index"," 通常表示：",[59,14788,14789],{},[18,14790,14791],{},"MySQL 没有通过索引条件缩小扫描区间，而是把选中的整棵索引从头到尾扫描一遍。",[18,14793,14794,14795,14797],{},"它与 ",[22,14796,13632],{}," 的共同点是都可能读取全部记录；区别在于：",[114,14799,14800,14805],{},[117,14801,14802,14804],{},[22,14803,12226],{}," 扫描索引树；",[117,14806,14807,14809],{},[22,14808,13632],{}," 扫描表数据。",[18,14811,1398],{},[95,14813,14815],{"className":8481,"code":14814,"language":8483,"meta":101,"style":101},"KEY idx_user_id (user_id)\n",[22,14816,14817],{"__ignoreMap":101},[141,14818,14819,14821],{"class":143,"line":144},[141,14820,11167],{"class":151},[141,14822,14071],{"class":147},[95,14824,14826],{"className":8481,"code":14825,"language":8483,"meta":101,"style":101},"SELECT user_id\nFROM orders;\n",[22,14827,14828,14835],{"__ignoreMap":101},[141,14829,14830,14832],{"class":143,"line":144},[141,14831,8167],{"class":151},[141,14833,14834],{"class":147}," user_id\n",[141,14836,14837,14839],{"class":143,"line":165},[141,14838,10338],{"class":151},[141,14840,13519],{"class":147},[18,14842,14843,14844,14846,14847,14850],{},"如果查询只需要 ",[22,14845,12237],{},"，二级索引已经包含全部所需数据，MySQL 可以扫描更窄的 ",[22,14848,14849],{},"idx_user_id","，而不必扫描保存完整行的聚簇索引。",[18,14852,14853],{},"执行计划可能显示：",[95,14855,14858],{"className":14856,"code":14857,"language":100,"meta":101},[98],"type: index\nkey: idx_user_id\nExtra: Using index\n",[22,14859,14857],{"__ignoreMap":101},[18,14861,8323,14862,14864],{},[22,14863,14764],{}," 表示覆盖索引：查询需要的数据可以直接从索引取得，不需要回表。",[18,14866,14867],{},"另一个常见场景是利用索引顺序避免额外排序：",[95,14869,14871],{"className":8481,"code":14870,"language":8483,"meta":101,"style":101},"SELECT id\nFROM orders\nORDER BY created_at;\n",[22,14872,14873,14879,14885],{"__ignoreMap":101},[141,14874,14875,14877],{"class":143,"line":144},[141,14876,8167],{"class":151},[141,14878,10738],{"class":147},[141,14880,14881,14883],{"class":143,"line":165},[141,14882,10338],{"class":151},[141,14884,8665],{"class":147},[141,14886,14887,14889],{"class":143,"line":210},[141,14888,10416],{"class":151},[141,14890,12905],{"class":147},[18,14892,14893,14894,14896,14897,4878],{},"如果存在适合的 ",[22,14895,11633],{}," 索引，优化器可能按索引顺序扫描全部记录，以避免 ",[22,14898,13110],{},[18,14900,14901,14903,14904,14906],{},[22,14902,12226],{}," 可能比 ",[22,14905,13632],{}," 快，因为二级索引通常更窄，缓存命中和读取的数据量更小；但它本质上仍是全索引扫描，数据量大时成本依然很高。",[638,14908,14910,14911,14913],{"id":14909},"_9-all扫描整张表","9. ",[22,14912,13632],{},"：扫描整张表",[18,14915,14916,14918],{},[22,14917,13632],{}," 表示全表扫描。",[18,14920,14921],{},"对于 InnoDB，可以把它近似理解为扫描保存完整行数据的聚簇索引：",[95,14923,14926],{"className":14924,"code":14925,"language":100,"meta":101},[98],"聚簇索引第一条记录\n ↓\n逐条向后读取\n ↓\n检查 WHERE 条件\n ↓\n直到最后一条记录\n",[22,14927,14925],{"__ignoreMap":101},[18,14929,14930],{},"典型原因包括：",[114,14932,14933,14936,14939,14943,14946,14949],{},[117,14934,14935],{},"查询条件没有可用索引；",[117,14937,14938],{},"在索引列上进行了导致无法定位的函数或转换；",[117,14940,14941,11075],{},[22,14942,10530],{},[117,14944,14945],{},"条件会返回表中大部分数据；",[117,14947,14948],{},"表很小，全表扫描成本更低；",[117,14950,14951],{},"优化器根据统计信息判断使用索引加回表更贵。",[18,14953,1398],{},[95,14955,14957],{"className":8481,"code":14956,"language":8483,"meta":101,"style":101},"SELECT *\nFROM orders\nWHERE remark LIKE '%manual%';\n",[22,14958,14959,14965,14971],{"__ignoreMap":101},[141,14960,14961,14963],{"class":143,"line":144},[141,14962,8167],{"class":151},[141,14964,10333],{"class":151},[141,14966,14967,14969],{"class":143,"line":165},[141,14968,10338],{"class":151},[141,14970,8665],{"class":147},[141,14972,14973,14975,14977,14979,14982],{"class":143,"line":210},[141,14974,8542],{"class":151},[141,14976,12273],{"class":147},[141,14978,10530],{"class":151},[141,14980,14981],{"class":911}," '%manual%'",[141,14983,8560],{"class":147},[18,14985,14986,14987,4878],{},"普通 B+ 树索引无法按照任意位置包含关系定位，执行计划很可能是 ",[22,14988,13632],{},[18,14990,14991,14992,14994],{},"但 ",[22,14993,13632],{}," 不等于必须立刻创建索引。",[18,14996,14997],{},"如果表只有几十行，或者查询本来就要读取 80% 的数据，全表扫描可能是合理选择。真正需要关注的是：",[114,14999,15000,15003,15008,15011,15014],{},[117,15001,15002],{},"表有多大；",[117,15004,15005,15007],{},[22,15006,13639],{}," 预计扫描多少行；",[117,15009,15010],{},"查询执行频率多高；",[117,15012,15013],{},"是否处于 JOIN 的内层并被重复扫描；",[117,15015,15016],{},"实际耗时和资源消耗是否不可接受。",[18,15018,15019,15020,15022],{},"特别是在 JOIN 中，如果前表返回一万行，而后表对每条前表记录都执行一次 ",[22,15021,13632],{},"，成本可能被放大得非常严重。",[638,15024,15026],{"id":15025},"_10-常见类型对比","10. 常见类型对比",[1309,15028,15029,15049],{},[1312,15030,15031],{},[1315,15032,15033,15037,15040,15043,15046],{},[1318,15034,15035],{},[22,15036,11119],{},[1318,15038,15039],{},"核心含义",[1318,15041,15042],{"align":8227},"是否精准定位",[1318,15044,15045],{"align":8227},"可能读取的记录数",[1318,15047,15048],{},"常见场景",[1328,15050,15051,15069,15089,15109,15132,15150],{},[1315,15052,15053,15057,15060,15063,15066],{},[1333,15054,15055],{},[22,15056,13745],{},[1333,15058,15059],{},"表中只有一行",[1333,15061,15062],{"align":8227},"无需查找",[1333,15064,15065],{"align":8227},"1 行",[1333,15067,15068],{},"单行表",[1315,15070,15071,15075,15078,15081,15084],{},[1333,15072,15073],{},[22,15074,13274],{},[1333,15076,15077],{},"通过常量匹配主键或唯一键",[1333,15079,15080],{"align":8227},"是",[1333,15082,15083],{"align":8227},"最多 1 行",[1333,15085,15086],{},[22,15087,15088],{},"WHERE id=100",[1315,15090,15091,15095,15098,15101,15104],{},[1333,15092,15093],{},[22,15094,13624],{},[1333,15096,15097],{},"通过普通索引做等值查找",[1333,15099,15100],{"align":8227},"是，但结果不唯一",[1333,15102,15103],{"align":8227},"1 行到大量记录",[1333,15105,15106],{},[22,15107,15108],{},"WHERE status=1",[1315,15110,15111,15115,15118,15121,15124],{},[1333,15112,15113],{},[22,15114,13627],{},[1333,15116,15117],{},"扫描一个或多个索引区间",[1333,15119,15120],{"align":8227},"定位区间",[1333,15122,15123],{"align":8227},"取决于范围大小",[1333,15125,15126,44,15128,44,15130],{},[22,15127,8548],{},[22,15129,11620],{},[22,15131,9174],{},[1315,15133,15134,15138,15141,15144,15147],{},[1333,15135,15136],{},[22,15137,12226],{},[1333,15139,15140],{},"扫描整棵索引",[1333,15142,15143],{"align":8227},"否",[1333,15145,15146],{"align":8227},"通常为整个索引",[1333,15148,15149],{},"覆盖索引全扫描、按索引顺序遍历",[1315,15151,15152,15156,15159,15161,15164],{},[1333,15153,15154],{},[22,15155,13632],{},[1333,15157,15158],{},"扫描整张表",[1333,15160,15143],{"align":8227},[1333,15162,15163],{"align":8227},"通常为整张表",[1333,15165,15166],{},"无可用索引或全表扫描更便宜",[18,15168,15169,15170,4039],{},"还应单独记住 JOIN 中的 ",[22,15171,14010],{},[59,15173,15174],{},[18,15175,15176],{},"对前表的每一条记录，通过当前表的主键或唯一非空索引最多匹配一行。",[638,15178,15180],{"id":15179},"_11-explain-与-explain-analyze-的区别","11. EXPLAIN 与 EXPLAIN ANALYZE 的区别",[18,15182,15183,15185,15186,4039],{},[22,15184,11108],{}," 只展示优化器计划如何执行 SQL，并不会真正执行普通 ",[22,15187,8167],{},[95,15189,15190],{"className":8481,"code":13535,"language":8483,"meta":101,"style":101},[22,15191,15192,15196,15202,15208],{"__ignoreMap":101},[141,15193,15194],{"class":143,"line":144},[141,15195,13542],{"class":147},[141,15197,15198,15200],{"class":143,"line":165},[141,15199,8167],{"class":151},[141,15201,10333],{"class":151},[141,15203,15204,15206],{"class":143,"line":210},[141,15205,10338],{"class":151},[141,15207,8665],{"class":147},[141,15209,15210,15212,15214,15216,15218],{"class":143,"line":219},[141,15211,8542],{"class":151},[141,15213,9302],{"class":147},[141,15215,152],{"class":151},[141,15217,8551],{"class":428},[141,15219,8560],{"class":147},[18,15221,15222,15223,15226,15227,4878],{},"其中的 ",[22,15224,15225],{},"rows、filtered、cost"," 等主要来自统计信息和成本模型，是",[64,15228,15229],{},"估算值",[18,15231,15232,15234],{},[22,15233,11111],{}," 会真正执行查询，并在执行计划中同时展示估算值和实际运行数据：",[95,15236,15238],{"className":8481,"code":15237,"language":8483,"meta":101,"style":101},"EXPLAIN ANALYZE\nSELECT *\nFROM orders\nWHERE user_id = 100;\n",[22,15239,15240,15245,15251,15257],{"__ignoreMap":101},[141,15241,15242],{"class":143,"line":144},[141,15243,15244],{"class":147},"EXPLAIN ANALYZE\n",[141,15246,15247,15249],{"class":143,"line":165},[141,15248,8167],{"class":151},[141,15250,10333],{"class":151},[141,15252,15253,15255],{"class":143,"line":210},[141,15254,10338],{"class":151},[141,15256,8665],{"class":147},[141,15258,15259,15261,15263,15265,15267],{"class":143,"line":219},[141,15260,8542],{"class":151},[141,15262,9302],{"class":147},[141,15264,152],{"class":151},[141,15266,8551],{"class":428},[141,15268,8560],{"class":147},[18,15270,15271],{},"典型输出片段：",[95,15273,15276],{"className":15274,"code":15275,"language":100,"meta":101},[98],"Index lookup on orders using idx_user_id\n (cost=10.2 rows=20)\n (actual time=0.08..0.15 rows=350 loops=1)\n",[22,15277,15275],{"__ignoreMap":101},[18,15279,15280],{},"可以重点对比：",[114,15282,15283,15289,15295,15301,15307],{},[117,15284,15285,15288],{},[22,15286,15287],{},"cost","：优化器估算成本；",[117,15290,15291,15292,15294],{},"前一个 ",[22,15293,13639],{},"：预计返回行数；",[117,15296,15297,15300],{},[22,15298,15299],{},"actual time","：实际首行时间和完成时间；",[117,15302,15303,15304,15306],{},"后一个 ",[22,15305,13639],{},"：每次循环实际返回行数；",[117,15308,15309,15312],{},[22,15310,15311],{},"loops","：该执行节点实际执行次数。",[18,15314,15315],{},"两者的核心区别：",[1309,15317,15318,15332],{},[1312,15319,15320],{},[1315,15321,15322,15324,15328],{},[1318,15323,3582],{},[1318,15325,15326],{},[22,15327,11108],{},[1318,15329,15330],{},[22,15331,11111],{},[1328,15333,15334,15347,15358,15369,15380],{},[1315,15335,15336,15339,15344],{},[1333,15337,15338],{},"是否真正执行查询",[1333,15340,8164,15341,15343],{},[22,15342,8167],{}," 不执行",[1333,15345,15346],{},"会真实执行",[1315,15348,15349,15352,15355],{},[1333,15350,15351],{},"行数与成本",[1333,15353,15354],{},"主要是估算值",[1333,15356,15357],{},"同时提供估算与实际数据",[1315,15359,15360,15363,15366],{},[1333,15361,15362],{},"实际耗时",[1333,15364,15365],{},"不提供",[1333,15367,15368],{},"提供各执行节点耗时",[1315,15370,15371,15374,15377],{},[1333,15372,15373],{},"主要用途",[1333,15375,15376],{},"上线前检查计划、低风险分析",[1333,15378,15379],{},"验证估算偏差、定位真实瓶颈",[1315,15381,15382,15385,15388],{},[1333,15383,15384],{},"使用风险",[1333,15386,15387],{},"较低",[1333,15389,15390],{},"慢 SQL 会真实消耗资源",[18,15392,15393,15395],{},[22,15394,11111],{}," 能发现这类问题：",[95,15397,15400],{"className":15398,"code":15399,"language":100,"meta":101},[98],"优化器预计返回 20 行\n实际返回 350000 行\n",[22,15401,15399],{"__ignoreMap":101},[18,15403,15404],{},"这种巨大偏差可能与统计信息、数据倾斜、条件相关性或估算模型有关。",[18,15406,15407],{},"使用时必须注意：",[114,15409,15410,15413,15416,15419],{},[117,15411,15412],{},"它会真实执行查询，慢查询会真实占用 CPU、I\u002FO 和锁资源；",[117,15414,15415],{},"对复杂 SQL 应优先在测试或影子环境执行；",[117,15417,15418],{},"不要在生产高峰期随意分析可能扫描海量数据的语句；",[117,15420,15421],{},"对数据修改语句尤其谨慎，不能把它当成完全无副作用的静态分析工具。",[638,15423,15425,15426,15428],{"id":15424},"_12-不要只根据-type-判断性能","12. 不要只根据 ",[22,15427,11119],{}," 判断性能",[18,15430,15431],{},"下面两个计划：",[95,15433,15436],{"className":15434,"code":15435,"language":100,"meta":101},[98],"计划 A：type=ref，rows=500000\n计划 B：type=range，rows=20\n",[22,15437,15435],{"__ignoreMap":101},[18,15439,15440,15441,15443,15444,15446],{},"虽然官方列表中 ",[22,15442,13624],{}," 排在 ",[22,15445,13627],{}," 前面，但计划 B 很可能扫描更少、执行更快。",[18,15448,15449],{},"同理：",[95,15451,15454],{"className":15452,"code":15453,"language":100,"meta":101},[98],"计划 A：type=ALL，rows=30\n计划 B：type=ref，rows=100000\n",[22,15455,15453],{"__ignoreMap":101},[18,15457,15458],{},"对只有 30 行的小表执行全表扫描，不一定是问题。",[18,15460,15461],{},"因此，合理的判断方式是：",[95,15463,15466],{"className":15464,"code":15465,"language":100,"meta":101},[98],"type\n +\nkey \u002F key_len\n +\nrows \u002F filtered\n +\nExtra\n +\nEXPLAIN ANALYZE 的实际行数与耗时\n",[22,15467,15465],{"__ignoreMap":101},[18,15469,15470,15472],{},[22,15471,11119],{}," 是执行计划的重要入口，但不是最终结论。",[18,15474,15475],{},"几个常见误区：",[114,15477,15478,15483,15488,15493,15499,15504],{},[117,15479,15480,15482],{},[22,15481,11104],{}," 有值，不代表最终使用了索引；",[117,15484,15485,15487],{},[22,15486,11115],{}," 有值，不代表查询一定高效；",[117,15489,15490,15492],{},[22,15491,14785],{}," 通常表示全索引扫描，不等于范围定位；",[117,15494,15495,15498],{},[22,15496,15497],{},"type=ALL"," 是全表扫描，但小表全表扫描可能就是合理计划；",[117,15500,15501,15503],{},[22,15502,14764],{}," 通常表示覆盖索引，不等于“使用索引定位”；",[117,15505,15506],{},"预计扫描行数少，也可能因估算偏差与实际执行差异很大。",[14,15508,1703],{"id":1702},[18,15510,15511],{},"遇到“明明建了索引却很慢”，可以按下面顺序检查：",[2489,15513,15514,15517,15520,15535,15538,15541,15544,15547,15553],{},[117,15515,15516],{},"确认慢 SQL、参数值和数据量，不能只拿脱离现场的 SQL 模板分析。",[117,15518,15519],{},"查看表结构、索引顺序、字段类型、字符集和排序规则。",[117,15521,3901,15522,15524,15525,44,15527,44,15529,44,15531,2818,15533,4878],{},[22,15523,11108],{}," 检查 ",[22,15526,11115],{},[22,15528,11119],{},[22,15530,13639],{},[22,15532,13649],{},[22,15534,13467],{},[117,15536,15537],{},"检查联合索引是否满足最左前缀，范围条件之后是否只剩过滤能力。",[117,15539,15540],{},"检查索引列上是否存在函数、计算或隐式转换。",[117,15542,15543],{},"估算查询命中比例和回表次数，判断优化器放弃索引是否合理。",[117,15545,15546],{},"对比估算行数与实际行数，检查统计信息是否明显失真。",[117,15548,15549,15550,15552],{},"在可控环境中使用 ",[22,15551,11111],{}," 验证真实执行路径。",[117,15554,15555,15556,15558],{},"调整 SQL 或索引后，在可控环境中使用 ",[22,15557,11111],{}," 验证实际执行情况，并结合线上灰度后的查询耗时、扫描行数、回表量及资源指标持续观察，不能只看静态执行计划就宣布优化完成。只有涉及高并发、容量上限或锁竞争的场景，才需要进一步进行专项压测。",[14,15560,15562],{"id":15561},"十四常见错误结论","十四、常见错误结论",[638,15564,15566],{"id":15565},"_1-联合索引中间断了一列整个索引都失效","1. 联合索引中间断了一列，整个索引都失效",[18,15568,15569],{},"不准确。最左侧连续部分仍可能用于定位，后续列也可能通过 ICP 或覆盖索引发挥作用。",[638,15571,15573],{"id":15572},"_2-遇到范围查询后面的索引列完全没用","2. 遇到范围查询，后面的索引列完全没用",[18,15575,15576],{},"不准确。后续列通常不能继续缩小连续范围，但仍可能用于索引层过滤或覆盖查询。",[638,15578,6239,15580,44,15582,44,15584,15586],{"id":15579},"_3-not-inis-null-一定不走索引",[22,15581,4702],{},[22,15583,11088],{},[22,15585,12768],{}," 一定不走索引",[18,15588,15589],{},"不准确。是否选择索引取决于数据分布、命中比例、覆盖情况和优化器成本估算。",[638,15591,14007,15593,15595],{"id":15592},"_4-key-不为-null-就说明索引使用良好",[22,15594,11115],{}," 不为 NULL 就说明索引使用良好",[18,15597,15598],{},"不准确。可能扫描了大部分索引，也可能发生大量回表。",[638,15600,15602],{"id":15601},"_5-全表扫描一定比索引慢","5. 全表扫描一定比索引慢",[18,15604,15605],{},"不准确。小表或需要读取大部分数据时，顺序全表扫描可能是成本更低的方案。",[638,15607,15609,15610,15612],{"id":15608},"_6-使用-force-index-就能解决问题","6. 使用 ",[22,15611,12845],{}," 就能解决问题",[18,15614,15615],{},"不准确。强制索引可能暂时改变执行计划，也可能在数据分布变化后变得更慢。应先找到优化器不选择索引的真实原因。",[14,15617,1867],{"id":1866},[114,15619,15620,15627,15634,15641,15648,15655,15662,15669],{},[117,15621,15622],{},[73,15623,15626],{"href":15624,"rel":15625},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.0\u002Fen\u002Fmysql-indexes.html",[1876],"MySQL 8.0 Reference Manual：How MySQL Uses Indexes",[117,15628,15629],{},[73,15630,15633],{"href":15631,"rel":15632},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.0\u002Fen\u002Foptimization-indexes.html",[1876],"MySQL 8.0 Reference Manual：Optimization and Indexes",[117,15635,15636],{},[73,15637,15640],{"href":15638,"rel":15639},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.0\u002Fen\u002Fexplain.html",[1876],"MySQL 8.0 Reference Manual：EXPLAIN Statement",[117,15642,15643],{},[73,15644,15647],{"href":15645,"rel":15646},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.0\u002Fen\u002Findex-merge-optimization.html",[1876],"MySQL 8.0 Reference Manual：Index Merge Optimization",[117,15649,15650],{},[73,15651,15654],{"href":15652,"rel":15653},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.0\u002Fen\u002Findex-condition-pushdown-optimization.html",[1876],"MySQL 8.0 Reference Manual：Index Condition Pushdown Optimization",[117,15656,15657],{},[73,15658,15661],{"href":15659,"rel":15660},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.0\u002Fen\u002Forder-by-optimization.html",[1876],"MySQL 8.0 Reference Manual：ORDER BY Optimization",[117,15663,15664],{},[73,15665,15668],{"href":15666,"rel":15667},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.0\u002Fen\u002Fcreate-index.html",[1876],"MySQL 8.0 Reference Manual：CREATE INDEX Statement",[117,15670,15671],{},[73,15672,15675],{"href":15673,"rel":15674},"https:\u002F\u002Fdev.mysql.com\u002Fdoc\u002Frefman\u002F8.0\u002Fen\u002Fgenerated-column-index-optimizations.html",[1876],"MySQL 8.0 Reference Manual：Optimizer Use of Generated Column Indexes",[1907,15677,15678],{},"html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}",{"title":101,"searchDepth":165,"depth":165,"links":15680},[15681,15684,15685,15686,15691,15692,15693,15694,15695,15696,15702,15703,15704,15709,15710,15733,15734,15745],{"id":16,"depth":165,"text":16,"children":15682},[15683],{"id":8179,"depth":210,"text":8179},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":11143,"depth":165,"text":11144,"children":15687},[15688,15689,15690],{"id":11150,"depth":210,"text":11151},{"id":11210,"depth":210,"text":11211},{"id":11314,"depth":210,"text":11315},{"id":11333,"depth":165,"text":11334},{"id":11525,"depth":165,"text":11526},{"id":11627,"depth":165,"text":11628},{"id":12019,"depth":165,"text":12020},{"id":12124,"depth":165,"text":12125},{"id":12230,"depth":165,"text":12231,"children":15697},[15698,15699,15701],{"id":12318,"depth":210,"text":12319},{"id":12485,"depth":210,"text":15700},"Using sort_union(...) 是什么意思",{"id":12616,"depth":210,"text":12617},{"id":12689,"depth":165,"text":12690},{"id":12772,"depth":165,"text":12773},{"id":12849,"depth":165,"text":12850,"children":15705},[15706,15707,15708],{"id":12968,"depth":210,"text":12968},{"id":13174,"depth":210,"text":13174},{"id":13310,"depth":210,"text":13310},{"id":13479,"depth":165,"text":13480},{"id":13528,"depth":165,"text":13529,"children":15711},[15712,15714,15716,15718,15720,15722,15724,15725,15727,15729,15730,15731],{"id":13664,"depth":210,"text":15713},"1. type 到底表示什么",{"id":13741,"depth":210,"text":15715},"2. system：表中只有一行",{"id":13772,"depth":210,"text":15717},"3. const：通过主键或唯一键最多定位一行",{"id":14006,"depth":210,"text":15719},"4. eq_ref：JOIN 时每条前表记录最多匹配一行",{"id":14207,"depth":210,"text":15721},"5. ref：通过非唯一索引等值查找一组记录",{"id":14382,"depth":210,"text":15723},"6. range：扫描索引中的一个或多个区间",{"id":14628,"depth":210,"text":14629},{"id":14770,"depth":210,"text":15726},"8. index：把整棵索引扫描一遍",{"id":14909,"depth":210,"text":15728},"9. ALL：扫描整张表",{"id":15025,"depth":210,"text":15026},{"id":15179,"depth":210,"text":15180},{"id":15424,"depth":210,"text":15732},"12. 不要只根据 type 判断性能",{"id":1702,"depth":165,"text":1703},{"id":15561,"depth":165,"text":15562,"children":15735},[15736,15737,15738,15740,15742,15743],{"id":15565,"depth":210,"text":15566},{"id":15572,"depth":210,"text":15573},{"id":15579,"depth":210,"text":15739},"3. !=、NOT IN、IS NULL 一定不走索引",{"id":15592,"depth":210,"text":15741},"4. key 不为 NULL 就说明索引使用良好",{"id":15601,"depth":210,"text":15602},{"id":15608,"depth":210,"text":15744},"6. 使用 FORCE INDEX 就能解决问题",{"id":1866,"depth":165,"text":1867},"wiki:java:mysql-index-failure-scenarios","从联合索引、函数运算、隐式转换、LIKE、OR、选择性和优化器成本等角度，系统解释 MySQL 索引无法使用、部分使用及主动放弃索引的常见场景。",{},77,"\u002Fjava\u002Fmysql-index-failure-scenarios",{"title":11012,"description":15747},"java\u002Fmysql-index-failure-scenarios","Z4hbUCudKpBrIxf2AeaWFne0fjdxJ0cTwR0Q_5IRNh0",{"id":15755,"title":15756,"body":15757,"commentId":16942,"description":16943,"difficulty":4382,"draft":1943,"extension":1944,"meta":16944,"navigation":206,"order":16945,"path":16946,"section":1948,"seo":16947,"stem":16948,"updated":16949,"__hash__":16950},"java\u002Fjava\u002Frocketmq-message-types-and-use-cases.md","RocketMQ 都有哪些消息类型？使用场景是什么？",{"type":7,"value":15758,"toc":16887},[15759,15762,15764,15767,15793,15796,15798,15805,15807,15816,15818,15822,15825,15893,15896,15899,15913,15916,15920,15924,15927,15933,15936,15939,15944,15948,15951,15974,15977,15983,15986,15990,15993,16004,16007,16011,16015,16018,16021,16027,16030,16036,16046,16050,16053,16056,16062,16065,16069,16072,16075,16078,16081,16084,16087,16090,16096,16100,16120,16124,16127,16130,16147,16150,16154,16158,16161,16167,16170,16217,16221,16227,16230,16234,16257,16260,16266,16269,16273,16280,16297,16300,16304,16307,16313,16320,16323,16327,16331,16334,16339,16342,16350,16353,16359,16363,16369,16372,16378,16381,16384,16401,16405,16408,16410,16416,16419,16436,16439,16443,16446,16452,16455,16515,16518,16522,16526,16529,16535,16538,16552,16556,16559,16562,16568,16574,16587,16590,16594,16597,16600,16617,16621,16624,16630,16642,16646,16649,16655,16658,16662,16665,16671,16674,16708,16711,16714,16733,16736,16750,16753,16757,16761,16764,16768,16771,16775,16778,16782,16785,16789,16792,16796,16800,16803,16807,16810,16814,16817,16821,16824,16828,16831,16833,16884],[10,15760,15756],{"id":15761},"rocketmq-都有哪些消息类型使用场景是什么",[14,15763,16],{"id":16},[18,15765,15766],{},"RocketMQ 5.x 按消息的传输语义正式分为四种类型：",[2489,15768,15769,15775,15781,15787],{},[117,15770,15771,15774],{},[64,15772,15773],{},"普通消息 Normal","：没有顺序、定时或事务等特殊语义，发送成功后即可被消费，适合微服务解耦、异步通知、日志和数据集成。",[117,15776,15777,15780],{},[64,15778,15779],{},"顺序消息 FIFO","：同一 Message Group 内的消息按照发送、存储和投递顺序处理，适合同一订单的创建、支付、发货等状态流转，以及 Binlog 增量同步。",[117,15782,15783,15786],{},[64,15784,15785],{},"定时与延时消息 Delay","：消息到指定时间后才对消费者可见，适合订单超时关闭、延迟检查、定时通知和任务调度。",[117,15788,15789,15792],{},[64,15790,15791],{},"事务消息 Transaction","：通过半事务消息、本地事务确认和事务回查，保证本地事务与消息发送的最终一致性，适合下单后发放积分、扣款后发送通知等场景。",[18,15794,15795],{},"RocketMQ 5.x 可以为 Topic 声明消息类型，一个 Topic 只应承载一种消息类型。批量消息属于发送方式，重试消息和死信消息属于消费失败后的系统处理状态，Request-Reply 属于通信模式，它们都不属于上述四种正式 MessageType。",[18,15797,57],{},[59,15799,15800],{},[18,15801,15802],{},[64,15803,15804],{},"无特殊要求用普通消息；同一业务实体需要按序处理用 FIFO；需要未来触发用 Delay；本地事务必须和消息发送保持最终一致用 Transaction。",[14,15806,69],{"id":69},[18,15808,15809],{},[73,15810,15813],{"href":15811,"target":76,"rel":15812},"\u002Fimages\u002Fwiki\u002Fjava\u002Frocketmq-message-types-and-use-cases.svg",[78,79],[81,15814],{"src":15811,"alt":15815},"RocketMQ 四种消息类型、核心语义、典型场景及选择方法",[14,15817,86],{"id":86},[14,15819,15821],{"id":15820},"一先明确-rocketmq-的正式分类","一、先明确 RocketMQ 的正式分类",[18,15823,15824],{},"RocketMQ 5.x 定义了四种 MessageType：",[1309,15826,15827,15839],{},[1312,15828,15829],{},[1315,15830,15831,15834,15837],{},[1318,15832,15833],{},"消息类型",[1318,15835,15836],{},"核心语义",[1318,15838,14174],{},[1328,15840,15841,15854,15867,15880],{},[1315,15842,15843,15848,15851],{},[1333,15844,15845],{},[22,15846,15847],{},"NORMAL",[1333,15849,15850],{},"发送后立即进入可消费状态",[1333,15852,15853],{},"异步解耦、事件通知、日志传输",[1315,15855,15856,15861,15864],{},[1333,15857,15858],{},[22,15859,15860],{},"FIFO",[1333,15862,15863],{},"同一 Message Group 内按顺序处理",[1333,15865,15866],{},"订单状态流转、Binlog 同步",[1315,15868,15869,15874,15877],{},[1333,15870,15871],{},[22,15872,15873],{},"DELAY",[1333,15875,15876],{},"到指定时间后才允许消费",[1333,15878,15879],{},"超时关闭、延迟检查、定时任务",[1315,15881,15882,15887,15890],{},[1333,15883,15884],{},[22,15885,15886],{},"TRANSACTION",[1333,15888,15889],{},"本地事务与消息发送最终一致",[1333,15891,15892],{},"交易完成后驱动下游业务",[18,15894,15895],{},"这四种类型不是按照消息内容划分，而是按照消息需要具备的传输和投递语义划分。",[18,15897,15898],{},"例如，同样是“订单创建”事件：",[114,15900,15901,15904,15907,15910],{},[117,15902,15903],{},"创建后立即异步通知风控，可以使用普通消息；",[117,15905,15906],{},"必须与后续支付、发货事件保持同一订单内的顺序，可以使用顺序消息；",[117,15908,15909],{},"创建三十分钟后检查是否支付，可以使用延时消息；",[117,15911,15912],{},"只有订单数据库事务成功后才能向下游投递，可以使用事务消息。",[18,15914,15915],{},"因此，消息类型的选择取决于业务语义，而不是消息中装了什么数据。",[14,15917,15919],{"id":15918},"二普通消息-normal","二、普通消息 Normal",[638,15921,15923],{"id":15922},"_1-什么是普通消息","1. 什么是普通消息",[18,15925,15926],{},"普通消息没有顺序、定时和事务等特殊语义。Broker 接收并保存消息后，消息进入 Ready 状态，Consumer 可以正常获取并处理。",[95,15928,15931],{"className":15929,"code":15930,"language":100,"meta":101},[98],"Producer\n │ 发送\n ▼\nBroker 持久化\n │ 立即可见\n ▼\nConsumer 消费\n",[22,15932,15930],{"__ignoreMap":101},[18,15934,15935],{},"“普通”不代表不可靠。普通消息同样可以使用发送确认、Broker 持久化、消费重试、死信队列和业务幂等机制。",[18,15937,15938],{},"它只表示：",[59,15940,15941],{},[18,15942,15943],{},"消息之间没有需要 RocketMQ 额外维护的顺序、时间或事务关系。",[638,15945,15947],{"id":15946},"_2-适用场景","2. 适用场景",[18,15949,15950],{},"普通消息适合绝大多数异步业务：",[114,15952,15953,15956,15959,15962,15965,15968,15971],{},[117,15954,15955],{},"微服务之间异步解耦；",[117,15957,15958],{},"用户注册后异步发送欢迎短信；",[117,15960,15961],{},"订单创建后异步更新搜索索引；",[117,15963,15964],{},"操作日志、埋点和审计事件传输；",[117,15966,15967],{},"缓存失效通知；",[117,15969,15970],{},"数据采集和数据集成；",[117,15972,15973],{},"不要求严格顺序的业务事件广播。",[18,15975,15976],{},"例如，订单创建后需要通知多个独立系统：",[95,15978,15981],{"className":15979,"code":15980,"language":100,"meta":101},[98],"订单服务\n │\n └── OrderCreated 普通消息\n ├── 风控服务\n ├── 推荐服务\n └── 数据分析服务\n",[22,15982,15980],{"__ignoreMap":101},[18,15984,15985],{},"这些下游之间不存在必须先后执行的关系，使用普通消息能够获得更好的并发能力。",[638,15987,15989],{"id":15988},"_3-不适合的场景","3. 不适合的场景",[18,15991,15992],{},"以下要求不能只依赖普通消息：",[114,15994,15995,15998,16001],{},[117,15996,15997],{},"同一订单的支付必须在创建之后处理；",[117,15999,16000],{},"消息必须在未来某个时间触发；",[117,16002,16003],{},"本地数据库事务失败时消息绝对不能对下游可见。",[18,16005,16006],{},"这时应分别考虑 FIFO、Delay 或 Transaction。",[14,16008,16010],{"id":16009},"三顺序消息-fifo","三、顺序消息 FIFO",[638,16012,16014],{"id":16013},"_1-顺序消息保证什么","1. 顺序消息保证什么",[18,16016,16017],{},"RocketMQ 5.x 使用 Message Group 标识需要保持顺序的一组消息。同一个 Message Group 中的消息按照先进先出顺序处理。",[18,16019,16020],{},"例如以订单号作为 Message Group：",[95,16022,16025],{"className":16023,"code":16024,"language":100,"meta":101},[98],"Message Group = order-1001\n\n创建订单 → 支付成功 → 仓库出库 → 物流发货\n",[22,16026,16024],{"__ignoreMap":101},[18,16028,16029],{},"另一个订单可以使用不同的 Message Group：",[95,16031,16034],{"className":16032,"code":16033,"language":100,"meta":101},[98],"order-1001：创建 → 支付 → 发货\norder-1002：创建 → 取消\n",[22,16035,16033],{"__ignoreMap":101},[18,16037,16038,16039,16042,16043,4878],{},"两个订单之间不要求顺序，可以并发处理；同一订单内部保持顺序。这通常称为",[64,16040,16041],{},"局部顺序","或",[64,16044,16045],{},"分组顺序",[638,16047,16049],{"id":16048},"_2-为什么不追求整个-topic-的全局顺序","2. 为什么不追求整个 Topic 的全局顺序",[18,16051,16052],{},"如果一个 Topic 的全部消息都要求全局顺序，就只能把所有消息串行发送、存储和消费，并发能力会受到严重限制。",[18,16054,16055],{},"按订单号、用户 ID、账户 ID 等业务键划分 Message Group，可以做到：",[95,16057,16060],{"className":16058,"code":16059,"language":100,"meta":101},[98],"组内有序\n+\n组间并行\n",[22,16061,16059],{"__ignoreMap":101},[18,16063,16064],{},"这更符合大多数业务的真实要求。",[638,16066,16068],{"id":16067},"_3-保证顺序需要满足哪些条件","3. 保证顺序需要满足哪些条件",[18,16070,16071],{},"完整的顺序需要覆盖三个阶段。",[6264,16073,16074],{"id":16074},"发送顺序",[18,16076,16077],{},"同一 Message Group 的消息需要由生产端按业务顺序串行发送。如果多个线程或多个生产者同时发送，即使 Message Group 相同，RocketMQ 也无法推断业务上谁应该在前。",[6264,16079,16080],{"id":16080},"存储顺序",[18,16082,16083],{},"RocketMQ 将同一 Message Group 的消息存入同一个队列，并保持接收顺序。",[6264,16085,16086],{"id":16086},"消费顺序",[18,16088,16089],{},"Consumer 必须遵循“接收、处理、确认”的顺序。不能收到消息后随意提交给异步线程并立即确认，否则业务实际完成顺序仍可能被打乱。",[95,16091,16094],{"className":16092,"code":16093,"language":100,"meta":101},[98],"发送有序\n ↓\n存储有序\n ↓\n投递有序\n ↓\n业务处理有序\n",[22,16095,16093],{"__ignoreMap":101},[638,16097,16099],{"id":16098},"_4-适用场景","4. 适用场景",[114,16101,16102,16105,16108,16111,16114,16117],{},[117,16103,16104],{},"同一订单的创建、支付、取消和发货；",[117,16106,16107],{},"同一账户的充值、扣款和退款；",[117,16109,16110],{},"同一用户的状态变更；",[117,16112,16113],{},"数据库 Binlog 增量同步；",[117,16115,16116],{},"工作流节点推进；",[117,16118,16119],{},"交易撮合等要求按到达顺序处理的场景。",[638,16121,16123],{"id":16122},"_5-使用代价与风险","5. 使用代价与风险",[18,16125,16126],{},"顺序消息会牺牲部分并发能力，并且前面的消息处理失败时，后续消息可能等待。",[18,16128,16129],{},"需要重点关注：",[114,16131,16132,16135,16138,16141,16144],{},[117,16133,16134],{},"Message Group 是否过热；",[117,16136,16137],{},"单条消息是否持续重试并阻塞后续消息；",[117,16139,16140],{},"消费逻辑是否包含慢 SQL、慢 RPC；",[117,16142,16143],{},"是否错误地在消费端进行异步并发处理；",[117,16145,16146],{},"是否真的需要顺序，还是使用状态机和幂等就能解决。",[18,16148,16149],{},"不要把所有消息都设置为同一个 Message Group，否则会把系统退化成串行消费。",[14,16151,16153],{"id":16152},"四定时与延时消息-delay","四、定时与延时消息 Delay",[638,16155,16157],{"id":16156},"_1-定时消息和延时消息有什么区别","1. 定时消息和延时消息有什么区别",[18,16159,16160],{},"业务表达方式不同，但在 RocketMQ 5.x 中本质相同：都是设置一个未来的投递时间戳。",[95,16162,16165],{"className":16163,"code":16164,"language":100,"meta":101},[98],"延时消息：10 分钟后投递\n定时消息：2026-07-26 18:00:00 投递\n",[22,16166,16164],{"__ignoreMap":101},[18,16168,16169],{},"延时消息也需要先计算出最终投递时间：",[95,16171,16173],{"className":135,"code":16172,"language":137,"meta":101,"style":101},"long deliveryTimestamp =\n System.currentTimeMillis() + Duration.ofMinutes(10).toMillis();\n",[22,16174,16175,16186],{"__ignoreMap":101},[141,16176,16177,16180,16183],{"class":143,"line":144},[141,16178,16179],{"class":151},"long",[141,16181,16182],{"class":147}," deliveryTimestamp ",[141,16184,16185],{"class":151},"=\n",[141,16187,16188,16191,16194,16197,16199,16202,16205,16207,16209,16212,16215],{"class":143,"line":165},[141,16189,16190],{"class":147}," System.",[141,16192,16193],{"class":158},"currentTimeMillis",[141,16195,16196],{"class":147},"() ",[141,16198,11754],{"class":151},[141,16200,16201],{"class":147}," Duration.",[141,16203,16204],{"class":158},"ofMinutes",[141,16206,908],{"class":147},[141,16208,2255],{"class":428},[141,16210,16211],{"class":147},").",[141,16213,16214],{"class":158},"toMillis",[141,16216,162],{"class":147},[638,16218,16220],{"id":16219},"_2-消息生命周期","2. 消息生命周期",[95,16222,16225],{"className":16223,"code":16224,"language":100,"meta":101},[98],"Producer 发送\n ↓\nTiming：Broker 按时间暂存\n ↓ 到达投递时间\nReady：转入普通存储并对 Consumer 可见\n ↓\nConsumer 消费并确认\n",[22,16226,16224],{"__ignoreMap":101},[18,16228,16229],{},"消息到达 Broker 并不代表 Consumer 立即可见。只有达到投递时间，消息才进入可以消费的状态。",[638,16231,16233],{"id":16232},"_3-适用场景","3. 适用场景",[114,16235,16236,16239,16242,16245,16248,16251,16254],{},[117,16237,16238],{},"订单创建三十分钟后检查是否支付；",[117,16240,16241],{},"支付处理中，五分钟后查询渠道结果；",[117,16243,16244],{},"优惠券到期提醒；",[117,16246,16247],{},"用户预约通知；",[117,16249,16250],{},"延迟重试；",[117,16252,16253],{},"定时清理任务；",[117,16255,16256],{},"分布式定时调度。",[18,16258,16259],{},"例如订单超时关闭：",[95,16261,16264],{"className":16262,"code":16263,"language":100,"meta":101},[98],"创建订单\n │\n ├── 写入订单数据\n └── 发送 30 分钟后投递的 Delay 消息\n ↓\n Consumer 查询订单状态\n ├── 未支付：关闭订单\n └── 已支付：忽略消息\n",[22,16265,16263],{"__ignoreMap":101},[18,16267,16268],{},"Consumer 收到延时消息后仍然必须重新检查业务状态。消息表达的是“现在应该检查”，不是“订单一定未支付”。",[638,16270,16272],{"id":16271},"_4-延时消息不是精确定时器","4. 延时消息不是精确定时器",[18,16274,16275,16276,16279],{},"设置的时间表示消息",[64,16277,16278],{},"不应早于该时间被消费","，但以下因素可能使实际处理晚于目标时间：",[114,16281,16282,16285,16288,16291,16294],{},[117,16283,16284],{},"Broker 当前负载较高；",[117,16286,16287],{},"大量消息设置了相同投递时间；",[117,16289,16290],{},"消费端发生积压；",[117,16292,16293],{},"Consumer 执行较慢或暂时不可用；",[117,16295,16296],{},"存储系统故障或重启。",[18,16298,16299],{},"因此，对秒级严格准点有强要求的业务不能只依赖消息到达时间，还要监控投递延迟并准备补偿扫描。",[638,16301,16303],{"id":16302},"_5-rocketmq-4x-与-5x-的区别","5. RocketMQ 4.x 与 5.x 的区别",[18,16305,16306],{},"RocketMQ 4.x 常见实现使用固定的延迟级别，例如：",[95,16308,16311],{"className":16309,"code":16310,"language":100,"meta":101},[98],"1 秒、5 秒、10 秒、30 秒、1 分钟……\n",[22,16312,16310],{"__ignoreMap":101},[18,16314,16315,16316,16319],{},"生产者通过 ",[22,16317,16318],{},"delayTimeLevel"," 选择预设级别。",[18,16321,16322],{},"RocketMQ 5.x 的正式 Delay 消息使用毫秒级 Unix 时间戳表示投递时间，不再局限于旧版固定延迟级别。面试时需要先说明讨论的是哪个版本，避免把 4.x 的十八个延迟级别直接当作 5.x 的唯一实现。",[14,16324,16326],{"id":16325},"五事务消息-transaction","五、事务消息 Transaction",[638,16328,16330],{"id":16329},"_1-事务消息解决什么问题","1. 事务消息解决什么问题",[18,16332,16333],{},"事务消息解决的是：",[59,16335,16336],{},[18,16337,16338],{},"本地事务与消息发送之间的最终一致性。",[18,16340,16341],{},"例如订单服务需要同时完成：",[2489,16343,16344,16347],{},[117,16345,16346],{},"在本地数据库创建订单；",[117,16348,16349],{},"向 RocketMQ 发送订单创建消息。",[18,16351,16352],{},"如果先提交数据库再发送消息，数据库成功后消息可能发送失败；如果先发送消息再写数据库，消息可能已被消费，但数据库事务最终失败。",[95,16354,16357],{"className":16355,"code":16356,"language":100,"meta":101},[98],"数据库事务成功，消息失败 → 下游永远不知道订单已创建\n消息发送成功，数据库失败 → 下游处理了一笔不存在的订单\n",[22,16358,16356],{"__ignoreMap":101},[638,16360,16362],{"id":16361},"_2-核心流程","2. 核心流程",[95,16364,16367],{"className":16365,"code":16366,"language":100,"meta":101},[98],"Producer 发送 Half Message\n ↓\nBroker 保存消息，但暂不向 Consumer 投递\n ↓\nProducer 执行本地事务\n ┌───┴────────┐\n │ │\n Commit Rollback\n │ │\n消息可见并投递 消息回滚\n",[22,16368,16366],{"__ignoreMap":101},[18,16370,16371],{},"如果 Broker 长时间没有收到明确结果，会回查 Producer：",[95,16373,16376],{"className":16374,"code":16375,"language":100,"meta":101},[98],"Broker 发起事务回查\n ↓\nProducer 查询本地事务记录\n ┌────┼─────┐\n Commit Unknown Rollback\n",[22,16377,16375],{"__ignoreMap":101},[18,16379,16380],{},"Producer 的事务回查不能只依赖内存变量，需要根据订单表、事务日志或本地 Outbox 等持久化数据判断。",[638,16382,16233],{"id":16383},"_3-适用场景-1",[114,16385,16386,16389,16392,16395,16398],{},[117,16387,16388],{},"订单创建成功后通知库存、积分系统；",[117,16390,16391],{},"扣款成功后发送账务事件；",[117,16393,16394],{},"账户入账成功后通知下游；",[117,16396,16397],{},"数据库状态变化后更新搜索索引；",[117,16399,16400],{},"本地事务成功后驱动跨服务异步流程。",[638,16402,16404],{"id":16403},"_4-事务消息不保证什么","4. 事务消息不保证什么",[18,16406,16407],{},"事务消息保证的是本地事务与消息是否投递之间的最终一致性，不等于整个分布式业务已经成功。",[18,16409,1398],{},[95,16411,16414],{"className":16412,"code":16413,"language":100,"meta":101},[98],"订单本地事务成功\n ↓\n事务消息 Commit\n ↓\n积分服务消费失败\n",[22,16415,16413],{"__ignoreMap":101},[18,16417,16418],{},"RocketMQ 可以重试投递，但积分服务仍需实现：",[114,16420,16421,16424,16427,16430,16433],{},[117,16422,16423],{},"消费幂等；",[117,16425,16426],{},"失败重试；",[117,16428,16429],{},"死信处理；",[117,16431,16432],{},"对账与补偿；",[117,16434,16435],{},"业务状态机。",[18,16437,16438],{},"事务消息也不是跨多个数据库的强一致分布式事务。它更适合能够接受异步执行和最终一致性的业务。",[14,16440,16442],{"id":16441},"六四种消息类型如何选择","六、四种消息类型如何选择",[18,16444,16445],{},"可以按照下面的顺序判断：",[95,16447,16450],{"className":16448,"code":16449,"language":100,"meta":101},[98],"本地事务是否必须与消息发送保持最终一致？\n ├── 是 → Transaction\n └── 否\n ↓\n消息是否需要到未来某个时间才可消费？\n ├── 是 → Delay\n └── 否\n ↓\n同一业务实体的事件是否必须按顺序处理？\n ├── 是 → FIFO\n └── 否 → Normal\n",[22,16451,16449],{"__ignoreMap":101},[18,16453,16454],{},"对应关系：",[1309,16456,16457,16470],{},[1312,16458,16459],{},[1315,16460,16461,16464,16467],{},[1318,16462,16463],{},"业务要求",[1318,16465,16466],{},"推荐类型",[1318,16468,16469],{},"关键设计点",[1328,16471,16472,16483,16493,16504],{},[1315,16473,16474,16477,16480],{},[1333,16475,16476],{},"只需要可靠异步传输",[1333,16478,16479],{},"Normal",[1333,16481,16482],{},"重试、幂等、监控",[1315,16484,16485,16488,16490],{},[1333,16486,16487],{},"同一订单内有先后关系",[1333,16489,15860],{},[1333,16491,16492],{},"Message Group、串行处理",[1315,16494,16495,16498,16501],{},[1333,16496,16497],{},"未来某个时间触发",[1333,16499,16500],{},"Delay",[1333,16502,16503],{},"投递时间、状态复查、延迟监控",[1315,16505,16506,16509,16512],{},[1333,16507,16508],{},"本地事务成功后才能投递",[1333,16510,16511],{},"Transaction",[1333,16513,16514],{},"Half Message、事务回查、持久化事务状态",[18,16516,16517],{},"不要因为高级消息类型“功能更多”就默认使用。每种特殊语义都会增加约束、运维成本或吞吐损耗；没有特殊要求时，普通消息通常是更简单的选择。",[14,16519,16521],{"id":16520},"七这些算不算消息类型","七、这些算不算消息类型",[638,16523,16525],{"id":16524},"_1-批量消息","1. 批量消息",[18,16527,16528],{},"批量消息不是独立 MessageType，而是一种发送或消费方式。",[95,16530,16533],{"className":16531,"code":16532,"language":100,"meta":101},[98],"单条发送：一次请求发送一条消息\n批量发送：一次请求携带多条消息\n",[22,16534,16532],{"__ignoreMap":101},[18,16536,16537],{},"批量能够减少网络往返和请求开销，适合日志采集、数据同步等吞吐优先的场景，但需要注意：",[114,16539,16540,16543,16546,16549],{},[117,16541,16542],{},"控制整个批次的大小；",[117,16544,16545],{},"批次失败后的重试粒度；",[117,16547,16548],{},"顺序消息不应随意并行批处理；",[117,16550,16551],{},"批量消费部分成功时的幂等和重试问题。",[638,16553,16555],{"id":16554},"_2-重试消息","2. 重试消息",[18,16557,16558],{},"重试消息是普通消息、FIFO 消息等消费失败后，RocketMQ 根据消费重试策略重新投递形成的系统处理过程，不是业务创建 Topic 时选择的正式 MessageType。",[18,16560,16561],{},"对于 PushConsumer，一次消费及失败重试可以简化为：",[95,16563,16566],{"className":16564,"code":16565,"language":100,"meta":101},[98],"Ready\n ↓ Consumer 获取消息\nInflight\n ├─ 消费成功并返回结果 → Commit\n └─ 消费失败或等待结果超时 → WaitingRetry\n ├─ 到达重试时间 → Ready\n └─ 超过最大重试次数 → DLQ\n",[22,16567,16565],{"__ignoreMap":101},[18,16569,16570,16573],{},[22,16571,16572],{},"Inflight"," 表示消息已经被 Consumer 获取，Consumer 正在执行业务逻辑，但消费结果还没有返回给 Broker。它可以理解为“正在处理中、等待确认”，不是一种新的消息类型。",[18,16575,16576,16579,16580,16582,16583,16586],{},[22,16577,16578],{},"WaitingRetry"," 是 PushConsumer 重试状态机中的状态。消息消费失败或 Broker 等待消费结果超时后，如果尚未达到最大重试次数，消息会先进入 ",[22,16581,16578],{},"；重试间隔结束后重新回到 ",[22,16584,16585],{},"Ready","，等待下一次投递。",[18,16588,16589],{},"Consumer 必须按消息可能重复投递来设计幂等。",[638,16591,16593],{"id":16592},"_3-死信消息","3. 死信消息",[18,16595,16596],{},"消息超过最大消费重试次数后，可能进入死信队列。死信消息代表消息进入异常隔离状态，也不是四种正式业务 MessageType 之一。",[18,16598,16599],{},"死信队列需要配套：",[114,16601,16602,16605,16608,16611,16614],{},[117,16603,16604],{},"告警；",[117,16606,16607],{},"失败原因记录；",[117,16609,16610],{},"人工检查；",[117,16612,16613],{},"修复后的重投；",[117,16615,16616],{},"对账和业务补偿。",[638,16618,16620],{"id":16619},"_4-request-reply-消息","4. Request-Reply 消息",[18,16622,16623],{},"Request-Reply 是一种通信模式：",[95,16625,16628],{"className":16626,"code":16627,"language":100,"meta":101},[98],"请求方发送消息\n ↓\n处理方消费并返回响应\n ↓\n请求方等待响应\n",[22,16629,16627],{"__ignoreMap":101},[18,16631,16632,16633,44,16635,44,16637,44,16639,16641],{},"它描述生产者和消费者如何交互，不属于 ",[22,16634,15847],{},[22,16636,15860],{},[22,16638,15873],{},[22,16640,15886],{}," 之外的第五种正式 MessageType。",[638,16643,16645],{"id":16644},"_5-同步异步和单向消息","5. 同步、异步和单向消息",[18,16647,16648],{},"同步发送、异步发送和单向发送描述的是 Producer 调用发送接口的方式，也不是消息类型。",[95,16650,16653],{"className":16651,"code":16652,"language":100,"meta":101},[98],"同步发送：等待 Broker 返回结果\n异步发送：通过回调接收结果\n单向发送：发送后不等待结果\n",[22,16654,16652],{"__ignoreMap":101},[18,16656,16657],{},"不要把“发送方式”和“消息传输语义”混为一谈。",[14,16659,16661],{"id":16660},"八rocketmq-5x-为什么要求-topic-类型一致","八、RocketMQ 5.x 为什么要求 Topic 类型一致",[18,16663,16664],{},"RocketMQ 5.x 支持在 Topic 上声明消息类型：",[95,16666,16669],{"className":16667,"code":16668,"language":100,"meta":101},[98],".\u002Fbin\u002Fmqadmin updateTopic \\\n -n 127.0.0.1:9876 \\\n -t order-events \\\n -c DefaultCluster \\\n -a \"+message.type=FIFO\"\n",[22,16670,16668],{"__ignoreMap":101},[18,16672,16673],{},"其中：",[114,16675,16676,16682,16688,16694],{},[117,16677,16678,16681],{},[22,16679,16680],{},"-n"," 指定 NameServer 地址；",[117,16683,16684,16687],{},[22,16685,16686],{},"-t"," 指定 Topic 名称；",[117,16689,16690,16693],{},[22,16691,16692],{},"-c"," 指定目标集群；",[117,16695,16696,16699,16700,44,16702,44,16704,6067,16706,4878],{},[22,16697,16698],{},"message.type"," 可设置为 ",[22,16701,15847],{},[22,16703,15860],{},[22,16705,15873],{},[22,16707,15886],{},[18,16709,16710],{},"上面创建的是 FIFO Topic。创建其他类型时，只需要替换最后一个参数的类型值。",[18,16712,16713],{},"启用类型校验后，一个 Topic 只允许发送与其类型一致的消息。例如：",[114,16715,16716,16724,16730],{},[117,16717,16718,16720,16721,16723],{},[22,16719,15860],{}," 消息不能发送到 ",[22,16722,15847],{}," Topic；",[117,16725,16726,16720,16728,16723],{},[22,16727,15886],{},[22,16729,15873],{},[117,16731,16732],{},"同一个 Topic 不应同时承载普通消息和顺序消息。",[18,16734,16735],{},"这样做的价值是：",[114,16737,16738,16741,16744,16747],{},[117,16739,16740],{},"让 Topic 的行为语义清晰；",[117,16742,16743],{},"避免客户端误用高级消息能力；",[117,16745,16746],{},"便于 Broker 按消息类型管理；",[117,16748,16749],{},"降低运维和故障排查复杂度。",[18,16751,16752],{},"为了兼容旧客户端，5.x 的强制类型校验能力需要结合服务端配置判断。面试中可以说“5.x 支持并推荐一个 Topic 对应一种消息类型”，不要绝对化为所有兼容部署都默认强制拒绝。",[14,16754,16756],{"id":16755},"九常见追问","九、常见追问",[638,16758,16760],{"id":16759},"_1-普通消息一定无序吗","1. 普通消息一定无序吗",[18,16762,16763],{},"普通消息在某个物理队列中自然存在存储先后，但业务没有建立端到端 FIFO 约束。多队列发送、并发消费、失败重试都可能使业务完成顺序变化，因此不能依赖普通消息保证业务顺序。",[638,16765,16767],{"id":16766},"_2-顺序消息能否保证整个-topic-全局有序","2. 顺序消息能否保证整个 Topic 全局有序",[18,16769,16770],{},"实际通常保证同一 Message Group 内有序。理论上把所有消息放入一个组可以接近全局串行，但会形成热点并严重限制吞吐，不建议这样设计。",[638,16772,16774],{"id":16773},"_3-延时消息到点后一定立即执行吗","3. 延时消息到点后一定立即执行吗",[18,16776,16777],{},"不一定。到点表示消息可以进入可消费状态，Broker 调度延迟、消息积压和 Consumer 处理能力都会影响最终业务执行时间。",[638,16779,16781],{"id":16780},"_4-事务消息消费成功是否与本地事务强一致","4. 事务消息消费成功是否与本地事务强一致",[18,16783,16784],{},"不是。事务消息只保证本地事务结果与消息是否投递之间的最终一致性。Consumer 的业务处理仍然是独立的异步过程，需要重试、幂等和补偿。",[638,16786,16788],{"id":16787},"_5-fifo-和-transaction-能否同时使用","5. FIFO 和 Transaction 能否同时使用",[18,16790,16791],{},"从 RocketMQ 5.x 的 Topic 类型模型看，一个 Topic 只对应一种正式消息类型，不能把同一条消息同时声明为 FIFO 和 Transaction。业务同时需要“事务一致性”和“顺序处理”时，需要重新审视领域流程，常见做法是用事务消息可靠发布业务事件，再由下游状态机、版本号、业务序号或独立 FIFO 流程处理顺序要求。",[14,16793,16795],{"id":16794},"十容易答错的地方","十、容易答错的地方",[638,16797,16799],{"id":16798},"错误一rocketmq-有五种消息包含批量消息","错误一：RocketMQ 有五种消息，包含批量消息",[18,16801,16802],{},"批量是发送方式，不是 RocketMQ 5.x 的正式 MessageType。正式类型是 Normal、FIFO、Delay、Transaction。",[638,16804,16806],{"id":16805},"错误二顺序消息保证整个-topic-全局有序","错误二：顺序消息保证整个 Topic 全局有序",[18,16808,16809],{},"通常保证同一 Message Group 内的局部顺序，不同组之间允许并发。",[638,16811,16813],{"id":16812},"错误三延时消息到了时间就保证业务已经执行","错误三：延时消息到了时间就保证业务已经执行",[18,16815,16816],{},"到达投递时间只表示消息对 Consumer 可见，实际业务完成还受积压、消费能力和重试影响。",[638,16818,16820],{"id":16819},"错误四事务消息保证上下游所有业务一起提交","错误四：事务消息保证上下游所有业务一起提交",[18,16822,16823],{},"事务消息保证本地事务与消息投递最终一致，下游消费结果仍然需要独立保障。",[638,16825,16827],{"id":16826},"错误五普通消息可靠性低","错误五：普通消息可靠性低",[18,16829,16830],{},"普通消息只是没有高级传输语义，不代表不持久化、不重试或不可靠。",[14,16832,5605],{"id":5605},[114,16834,16835,16842,16849,16856,16863,16870,16877],{},[117,16836,16837],{},[73,16838,16841],{"href":16839,"rel":16840},"https:\u002F\u002Frocketmq.apache.org\u002Fdocs\u002FdomainModel\u002F02topic\u002F",[1876],"Apache RocketMQ 5.0：Topic 与 MessageType",[117,16843,16844],{},[73,16845,16848],{"href":16846,"rel":16847},"https:\u002F\u002Frocketmq.apache.org\u002Fdocs\u002FfeatureBehavior\u002F01normalmessage\u002F",[1876],"Apache RocketMQ 5.0：普通消息",[117,16850,16851],{},[73,16852,16855],{"href":16853,"rel":16854},"https:\u002F\u002Frocketmq.apache.org\u002Fdocs\u002FfeatureBehavior\u002F03fifomessage\u002F",[1876],"Apache RocketMQ 5.0：顺序消息",[117,16857,16858],{},[73,16859,16862],{"href":16860,"rel":16861},"https:\u002F\u002Frocketmq.apache.org\u002Fdocs\u002FfeatureBehavior\u002F02delaymessage\u002F",[1876],"Apache RocketMQ 5.0：定时与延时消息",[117,16864,16865],{},[73,16866,16869],{"href":16867,"rel":16868},"https:\u002F\u002Frocketmq.apache.org\u002Fdocs\u002FfeatureBehavior\u002F04transactionmessage\u002F",[1876],"Apache RocketMQ 5.0：事务消息",[117,16871,16872],{},[73,16873,16876],{"href":16874,"rel":16875},"https:\u002F\u002Frocketmq.apache.org\u002Fdocs\u002FfeatureBehavior\u002F10consumerretrypolicy\u002F",[1876],"Apache RocketMQ 5.0：消费重试",[117,16878,16879],{},[73,16880,16883],{"href":16881,"rel":16882},"https:\u002F\u002Frocketmq.apache.org\u002Fdocs\u002F4.x\u002Fproducer\u002F04message3\u002F",[1876],"Apache RocketMQ 4.x：延时消息级别",[1907,16885,16886],{},"html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"title":101,"searchDepth":165,"depth":165,"links":16888},[16889,16890,16891,16892,16893,16898,16905,16912,16918,16919,16926,16927,16934,16941],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":15820,"depth":165,"text":15821},{"id":15918,"depth":165,"text":15919,"children":16894},[16895,16896,16897],{"id":15922,"depth":210,"text":15923},{"id":15946,"depth":210,"text":15947},{"id":15988,"depth":210,"text":15989},{"id":16009,"depth":165,"text":16010,"children":16899},[16900,16901,16902,16903,16904],{"id":16013,"depth":210,"text":16014},{"id":16048,"depth":210,"text":16049},{"id":16067,"depth":210,"text":16068},{"id":16098,"depth":210,"text":16099},{"id":16122,"depth":210,"text":16123},{"id":16152,"depth":165,"text":16153,"children":16906},[16907,16908,16909,16910,16911],{"id":16156,"depth":210,"text":16157},{"id":16219,"depth":210,"text":16220},{"id":16232,"depth":210,"text":16233},{"id":16271,"depth":210,"text":16272},{"id":16302,"depth":210,"text":16303},{"id":16325,"depth":165,"text":16326,"children":16913},[16914,16915,16916,16917],{"id":16329,"depth":210,"text":16330},{"id":16361,"depth":210,"text":16362},{"id":16383,"depth":210,"text":16233},{"id":16403,"depth":210,"text":16404},{"id":16441,"depth":165,"text":16442},{"id":16520,"depth":165,"text":16521,"children":16920},[16921,16922,16923,16924,16925],{"id":16524,"depth":210,"text":16525},{"id":16554,"depth":210,"text":16555},{"id":16592,"depth":210,"text":16593},{"id":16619,"depth":210,"text":16620},{"id":16644,"depth":210,"text":16645},{"id":16660,"depth":165,"text":16661},{"id":16755,"depth":165,"text":16756,"children":16928},[16929,16930,16931,16932,16933],{"id":16759,"depth":210,"text":16760},{"id":16766,"depth":210,"text":16767},{"id":16773,"depth":210,"text":16774},{"id":16780,"depth":210,"text":16781},{"id":16787,"depth":210,"text":16788},{"id":16794,"depth":165,"text":16795,"children":16935},[16936,16937,16938,16939,16940],{"id":16798,"depth":210,"text":16799},{"id":16805,"depth":210,"text":16806},{"id":16812,"depth":210,"text":16813},{"id":16819,"depth":210,"text":16820},{"id":16826,"depth":210,"text":16827},{"id":5605,"depth":165,"text":5605},"wiki:java:rocketmq-message-types-and-use-cases","系统介绍 RocketMQ 5.x 的普通消息、顺序消息、定时与延时消息、事务消息，说明各自语义、适用场景、使用限制，并澄清批量消息、重试消息和死信消息是否属于消息类型。",{},78,"\u002Fjava\u002Frocketmq-message-types-and-use-cases",{"title":15756,"description":16943},"java\u002Frocketmq-message-types-and-use-cases","2026-07-26","0Dk0ULElt6DDqSea9SIrQh6YmMktZE9yv-Ac_3lFtCs",{"id":16952,"title":16953,"body":16954,"commentId":18993,"description":18994,"difficulty":4382,"draft":1943,"extension":1944,"meta":18995,"navigation":206,"order":18996,"path":18997,"section":1948,"seo":18998,"stem":18999,"updated":19000,"__hash__":19001},"java\u002Fjava\u002Fjava-thread-pool-core-parameters-and-practice.md","Java 线程池核心参数有哪些？日常应该怎么使用？",{"type":7,"value":16955,"toc":18949},[16956,16959,16961,16994,16997,17000,17002,17009,17011,17020,17022,17026,17029,17043,17046,17052,17056,17059,17127,17131,17136,17139,17154,17157,17175,17180,17184,17189,17192,17198,17203,17207,17213,17221,17234,17237,17240,17248,17252,17259,17276,17279,17283,17289,17292,17365,17368,17385,17388,17392,17397,17411,17414,17420,17423,17427,17430,17433,17505,17508,17512,17515,17530,17535,17541,17544,17547,17551,17554,17560,17563,17569,17575,17584,17588,17592,17595,17598,17604,17607,17611,17614,17620,17623,17629,17632,17649,17652,17656,17659,17673,17676,17682,17685,17689,17692,18358,18361,18385,18388,18392,18398,18402,18411,18417,18421,18427,18433,18444,18447,18453,18459,18470,18476,18480,18482,18494,18507,18510,18536,18566,18578,18582,18585,18587,18593,18596,18613,18616,18620,18623,18728,18731,18751,18754,18758,18767,18773,18776,18782,18785,18795,18803,18809,18814,18820,18824,18828,18831,18835,18838,18842,18847,18851,18854,18858,18869,18873,18876,18880,18921,18923,18946],[10,16957,16953],{"id":16958},"java-线程池核心参数有哪些日常应该怎么使用",[14,16960,16],{"id":16},[18,16962,16963,16966,16967,16970,16971,16974,16975,16978,16979,16982,16983,16986,16987,16990,16991,4878],{},[22,16964,16965],{},"ThreadPoolExecutor"," 有七个核心参数：核心线程数 ",[22,16968,16969],{},"corePoolSize","、最大线程数 ",[22,16972,16973],{},"maximumPoolSize","、非核心线程空闲存活时间 ",[22,16976,16977],{},"keepAliveTime","、时间单位 ",[22,16980,16981],{},"unit","、任务队列 ",[22,16984,16985],{},"workQueue","、线程工厂 ",[22,16988,16989],{},"threadFactory"," 和拒绝策略 ",[22,16992,16993],{},"handler",[18,16995,16996],{},"提交任务后，线程池先判断当前工作线程数是否小于核心线程数，是则创建线程执行；否则尝试将任务放入队列。队列已满时，如果线程数还没有达到最大线程数，就继续创建非核心线程；线程数达到最大值后仍无法接收任务，才执行拒绝策略。因此，最大线程数是否生效与队列是否有界密切相关。",[18,16998,16999],{},"日常使用时，应根据任务是 CPU 密集型还是 I\u002FO 密集型划分独立线程池，明确核心线程数、最大线程数和有界队列，设置有业务含义的线程名，并根据业务选择可观测、可补偿的拒绝策略。同时监控活跃线程数、队列长度、拒绝次数、排队耗时和执行耗时，应用停止时进行优雅关闭。线程数和队列容量不能只靠固定公式决定，还要结合机器 CPU、任务等待与计算比例、下游容量及允许的业务延迟进行压测和调整。",[18,17001,57],{},[59,17003,17004],{},[18,17005,17006],{},[64,17007,17008],{},"线程池用有限的线程和队列承接任务；日常配置的核心不是把参数设大，而是明确资源上限、过载行为和监控补偿机制。",[14,17010,69],{"id":69},[18,17012,17013],{},[73,17014,17017],{"href":17015,"target":76,"rel":17016},"\u002Fimages\u002Fwiki\u002Fjava\u002Fjava-thread-pool-core-parameters-and-practice.svg",[78,79],[81,17018],{"src":17015,"alt":17019},"Java 线程池七个核心参数、任务提交流程和日常使用原则",[14,17021,86],{"id":86},[14,17023,17025],{"id":17024},"一为什么使用线程池","一、为什么使用线程池",[18,17027,17028],{},"如果每个任务都创建一个新线程，会带来以下问题：",[114,17030,17031,17034,17037,17040],{},[117,17032,17033],{},"创建和销毁线程需要消耗时间与内存；",[117,17035,17036],{},"线程数量缺少上限，突发流量可能耗尽系统资源；",[117,17038,17039],{},"大量线程会增加上下文切换和调度开销；",[117,17041,17042],{},"无法统一管理任务排队、拒绝、监控和关闭。",[18,17044,17045],{},"线程池的核心价值不是单纯复用线程，而是对并发资源进行治理：",[95,17047,17050],{"className":17048,"code":17049,"language":100,"meta":101},[98],"控制线程数量\n+ 缓冲暂时处理不了的任务\n+ 定义系统过载时的行为\n+ 统一监控和生命周期管理\n",[22,17051,17049],{"__ignoreMap":101},[14,17053,17055],{"id":17054},"二threadpoolexecutor-的七个核心参数","二、ThreadPoolExecutor 的七个核心参数",[18,17057,17058],{},"常用构造方法如下：",[95,17060,17062],{"className":135,"code":17061,"language":137,"meta":101,"style":101},"public ThreadPoolExecutor(\n int corePoolSize,\n int maximumPoolSize,\n long keepAliveTime,\n TimeUnit unit,\n BlockingQueue\u003CRunnable> workQueue,\n ThreadFactory threadFactory,\n RejectedExecutionHandler handler)\n",[22,17063,17064,17074,17082,17089,17097,17102,17117,17122],{"__ignoreMap":101},[141,17065,17066,17068,17071],{"class":143,"line":144},[141,17067,193],{"class":151},[141,17069,17070],{"class":158}," ThreadPoolExecutor",[141,17072,17073],{"class":147},"(\n",[141,17075,17076,17079],{"class":143,"line":165},[141,17077,17078],{"class":151}," int",[141,17080,17081],{"class":147}," corePoolSize,\n",[141,17083,17084,17086],{"class":143,"line":210},[141,17085,17078],{"class":151},[141,17087,17088],{"class":147}," maximumPoolSize,\n",[141,17090,17091,17094],{"class":143,"line":219},[141,17092,17093],{"class":151}," long",[141,17095,17096],{"class":147}," keepAliveTime,\n",[141,17098,17099],{"class":143,"line":234},[141,17100,17101],{"class":147}," TimeUnit unit,\n",[141,17103,17104,17107,17109,17112,17114],{"class":143,"line":241},[141,17105,17106],{"class":147}," BlockingQueue",[141,17108,3101],{"class":151},[141,17110,17111],{"class":147},"Runnable",[141,17113,9174],{"class":151},[141,17115,17116],{"class":147}," workQueue,\n",[141,17118,17119],{"class":143,"line":247},[141,17120,17121],{"class":147}," ThreadFactory threadFactory,\n",[141,17123,17124],{"class":143,"line":307},[141,17125,17126],{"class":147}," RejectedExecutionHandler handler)\n",[638,17128,17130],{"id":17129},"_1-corepoolsize核心线程数","1. corePoolSize：核心线程数",[18,17132,17133,17135],{},[22,17134,16969],{}," 表示线程池希望长期保留的基本工作线程数量。",[18,17137,17138],{},"默认情况下，核心线程也不是在线程池创建时立即启动，而是在任务到来后按需创建。需要提前完成线程创建时，可以调用：",[95,17140,17142],{"className":135,"code":17141,"language":137,"meta":101,"style":101},"threadPool.prestartAllCoreThreads();\n",[22,17143,17144],{"__ignoreMap":101},[141,17145,17146,17149,17152],{"class":143,"line":144},[141,17147,17148],{"class":147},"threadPool.",[141,17150,17151],{"class":158},"prestartAllCoreThreads",[141,17153,162],{"class":147},[18,17155,17156],{},"核心线程默认不会因为空闲而退出。调用以下方法后，核心线程也可以受空闲超时控制：",[95,17158,17160],{"className":135,"code":17159,"language":137,"meta":101,"style":101},"threadPool.allowCoreThreadTimeOut(true);\n",[22,17161,17162],{"__ignoreMap":101},[141,17163,17164,17166,17169,17171,17173],{"class":143,"line":144},[141,17165,17148],{"class":147},[141,17167,17168],{"class":158},"allowCoreThreadTimeOut",[141,17170,908],{"class":147},[141,17172,4968],{"class":428},[141,17174,915],{"class":147},[18,17176,13461,17177,17179],{},[22,17178,16977],{}," 必须大于零。",[638,17181,17183],{"id":17182},"_2-maximumpoolsize最大线程数","2. maximumPoolSize：最大线程数",[18,17185,17186,17188],{},[22,17187,16973],{}," 是线程池允许存在的最大工作线程数量，必须大于或等于核心线程数。",[18,17190,17191],{},"它并不是任务一多就立即生效。只有满足以下条件时，线程池才会创建超过核心数量的线程：",[95,17193,17196],{"className":17194,"code":17195,"language":100,"meta":101},[98],"核心线程都在工作\n+ workQueue 已满\n+ 当前线程数小于 maximumPoolSize\n",[22,17197,17195],{"__ignoreMap":101},[18,17199,17200,17201,4878],{},"如果使用不会被填满的无界队列，任务会持续进入队列，线程池通常不会扩展到 ",[22,17202,16973],{},[638,17204,17206],{"id":17205},"_3-keepalivetime空闲线程存活时间","3. keepAliveTime：空闲线程存活时间",[18,17208,17209,17210,17212],{},"当工作线程数量超过 ",[22,17211,16969],{}," 时，多出来的线程如果在指定时间内没有获取到任务，就会被回收。",[18,17214,17215,17217,17218,17220],{},[22,17216,16977],{}," 决定空闲等待时长，",[22,17219,16981],{}," 决定它的时间单位：",[95,17222,17224],{"className":135,"code":17223,"language":137,"meta":101,"style":101},"60L, TimeUnit.SECONDS\n",[22,17225,17226],{"__ignoreMap":101},[141,17227,17228,17231],{"class":143,"line":144},[141,17229,17230],{"class":428},"60L",[141,17232,17233],{"class":147},", TimeUnit.SECONDS\n",[18,17235,17236],{},"它们共同表示空闲线程最多等待 60 秒。",[18,17238,17239],{},"该参数是在以下两者之间取舍：",[114,17241,17242,17245],{},[117,17243,17244],{},"设置较短：流量下降后能更快释放线程资源，但下一次突发流量需要重新创建线程；",[117,17246,17247],{},"设置较长：可以减少线程反复创建，但空闲线程会占用更多内存。",[638,17249,17251],{"id":17250},"_4-unit时间单位","4. unit：时间单位",[18,17253,17254,13751,17256,17258],{},[22,17255,16981],{},[22,17257,16977],{}," 的单位，常用值包括：",[114,17260,17261,17266,17271],{},[117,17262,17263],{},[22,17264,17265],{},"TimeUnit.MILLISECONDS",[117,17267,17268],{},[22,17269,17270],{},"TimeUnit.SECONDS",[117,17272,17273],{},[22,17274,17275],{},"TimeUnit.MINUTES",[18,17277,17278],{},"把时间值和单位拆开传入，可以避免代码中出现含义不清的裸数字。",[638,17280,17282],{"id":17281},"_5-workqueue任务队列","5. workQueue：任务队列",[18,17284,17285,17286,17288],{},"当核心线程都在工作时，新任务会先尝试进入 ",[22,17287,16985],{}," 等待，而不是立即创建非核心线程。",[18,17290,17291],{},"常见队列如下：",[1309,17293,17294,17307],{},[1312,17295,17296],{},[1315,17297,17298,17301,17304],{},[1318,17299,17300],{},"队列",[1318,17302,17303],{},"特点",[1318,17305,17306],{},"适用场景与注意事项",[1328,17308,17309,17322,17339,17352],{},[1315,17310,17311,17316,17319],{},[1333,17312,17313],{},[22,17314,17315],{},"ArrayBlockingQueue",[1333,17317,17318],{},"基于数组的有界队列，容量固定",[1333,17320,17321],{},"资源边界明确，适合大多数需要控制积压的服务端任务",[1315,17323,17324,17329,17332],{},[1333,17325,17326],{},[22,17327,17328],{},"LinkedBlockingQueue",[1333,17330,17331],{},"基于链表，可指定容量",[1333,17333,17334,17335,17338],{},"不传容量时上限为 ",[22,17336,17337],{},"Integer.MAX_VALUE","，容易隐藏长期积压",[1315,17340,17341,17346,17349],{},[1333,17342,17343],{},[22,17344,17345],{},"SynchronousQueue",[1333,17347,17348],{},"不保存任务，每次提交都直接移交给工作线程",[1333,17350,17351],{},"适合希望快速扩展线程、任务很短且能够严格控制最大线程数的场景",[1315,17353,17354,17359,17362],{},[1333,17355,17356],{},[22,17357,17358],{},"PriorityBlockingQueue",[1333,17360,17361],{},"按优先级取任务，通常是无界队列",[1333,17363,17364],{},"任务需要可比较；要防止低优先级任务长期得不到执行",[18,17366,17367],{},"队列容量并非越大越好。大队列虽然能暂时降低拒绝次数，却可能带来：",[114,17369,17370,17373,17376,17379,17382],{},[117,17371,17372],{},"任务排队时间不断增长；",[117,17374,17375],{},"内存占用上升；",[117,17377,17378],{},"故障被延迟暴露；",[117,17380,17381],{},"应用关闭时遗留大量未完成任务；",[117,17383,17384],{},"请求已经失去业务时效后仍在执行。",[18,17386,17387],{},"有界队列能够让系统在达到承载上限时尽早进入明确的过载处理流程。",[638,17389,17391],{"id":17390},"_6-threadfactory线程工厂","6. threadFactory：线程工厂",[18,17393,17394,17396],{},[22,17395,16989],{}," 负责创建工作线程，可以统一设置：",[114,17398,17399,17402,17405,17408],{},[117,17400,17401],{},"线程名称；",[117,17403,17404],{},"是否为守护线程；",[117,17406,17407],{},"线程优先级；",[117,17409,17410],{},"未捕获异常处理器。",[18,17412,17413],{},"线程名应体现业务用途，例如：",[95,17415,17418],{"className":17416,"code":17417,"language":100,"meta":101},[98],"order-notify-1\norder-notify-2\n",[22,17419,17417],{"__ignoreMap":101},[18,17421,17422],{},"出现高 CPU、死锁或任务堆积时，有业务含义的线程名能显著降低线程栈排查成本。",[638,17424,17426],{"id":17425},"_7-handler拒绝策略","7. handler：拒绝策略",[18,17428,17429],{},"当线程池没有运行，或者同时满足“线程数达到最大值、任务队列已满”时，新任务会被拒绝。",[18,17431,17432],{},"JDK 提供四种常用策略：",[1309,17434,17435,17448],{},[1312,17436,17437],{},[1315,17438,17439,17442,17445],{},[1318,17440,17441],{},"策略",[1318,17443,17444],{},"行为",[1318,17446,17447],{},"适用提醒",[1328,17449,17450,17466,17479,17492],{},[1315,17451,17452,17457,17463],{},[1333,17453,17454],{},[22,17455,17456],{},"AbortPolicy",[1333,17458,17459,17460],{},"抛出 ",[22,17461,17462],{},"RejectedExecutionException",[1333,17464,17465],{},"默认策略，能够明确暴露过载，调用方需要处理异常",[1315,17467,17468,17473,17476],{},[1333,17469,17470],{},[22,17471,17472],{},"CallerRunsPolicy",[1333,17474,17475],{},"由提交任务的线程直接执行",[1333,17477,17478],{},"可以减慢生产者形成一定反压，但会增加调用线程延迟",[1315,17480,17481,17486,17489],{},[1333,17482,17483],{},[22,17484,17485],{},"DiscardPolicy",[1333,17487,17488],{},"静默丢弃新任务",[1333,17490,17491],{},"只适合明确允许丢弃且有独立监控的低价值任务",[1315,17493,17494,17499,17502],{},[1333,17495,17496],{},[22,17497,17498],{},"DiscardOldestPolicy",[1333,17500,17501],{},"丢弃队列头任务，再尝试提交新任务",[1333,17503,17504],{},"可能丢掉等待最久或优先级最高的任务，使用前必须确认业务语义",[18,17506,17507],{},"拒绝策略没有适用于所有业务的统一答案。核心交易任务通常不能静默丢弃，可以抛出异常后进入降级、补偿或持久化重试；允许采样的日志、指标任务才可能接受丢弃。",[14,17509,17511],{"id":17510},"三任务提交后的完整流程","三、任务提交后的完整流程",[18,17513,17514],{},"调用：",[95,17516,17518],{"className":135,"code":17517,"language":137,"meta":101,"style":101},"threadPool.execute(task);\n",[22,17519,17520],{"__ignoreMap":101},[141,17521,17522,17524,17527],{"class":143,"line":144},[141,17523,17148],{"class":147},[141,17525,17526],{"class":158},"execute",[141,17528,17529],{"class":147},"(task);\n",[18,17531,17532,17534],{},[22,17533,16965],{}," 的处理流程可以概括为：",[95,17536,17539],{"className":17537,"code":17538,"language":100,"meta":101},[98],"1. 当前工作线程数小于 corePoolSize\n → 创建核心工作线程执行任务\n\n2. 当前工作线程数已达到 corePoolSize\n → 尝试将任务加入 workQueue\n\n3. workQueue 已满，且工作线程数小于 maximumPoolSize\n → 创建非核心工作线程执行任务\n\n4. workQueue 已满，且工作线程数已达到 maximumPoolSize\n → 执行拒绝策略\n",[22,17540,17538],{"__ignoreMap":101},[18,17542,17543],{},"任务成功入队后，线程池还会再次检查运行状态。如果线程池在入队期间已经停止，会尝试移除该任务并拒绝；如果池中没有工作线程，则会补充一个工作线程负责消费队列。",[18,17545,17546],{},"这个二次检查避免了任务已经进入队列，却因为线程池状态变化或没有消费者而一直得不到执行。",[14,17548,17550],{"id":17549},"四队列与最大线程数如何相互影响","四、队列与最大线程数如何相互影响",[18,17552,17553],{},"假设配置如下：",[95,17555,17558],{"className":17556,"code":17557,"language":100,"meta":101},[98],"corePoolSize = 8\nmaximumPoolSize = 16\nworkQueue 容量 = 500\n",[22,17559,17557],{"__ignoreMap":101},[18,17561,17562],{},"任务增长过程是：",[95,17564,17567],{"className":17565,"code":17566,"language":100,"meta":101},[98],"前 8 个并发任务\n→ 创建至 8 个核心线程\n\n核心线程忙碌后的新任务\n→ 最多 500 个进入队列\n\n队列满后的新任务\n→ 继续创建线程，最多扩展到 16 个\n\n16 个线程都忙且队列仍满\n→ 触发拒绝策略\n",[22,17568,17566],{"__ignoreMap":101},[18,17570,17571,17572,17574],{},"如果把队列改成默认构造的 ",[22,17573,17328],{},"，它的容量接近无界，任务通常只会继续排队，线程数量很难从 8 扩展到 16。",[18,17576,17577,17578,17580,17581,17583],{},"因此不能孤立地解释 ",[22,17579,16973],{},"，必须和 ",[22,17582,16985],{}," 一起分析。",[14,17585,17587],{"id":17586},"五线程数应该怎么估算","五、线程数应该怎么估算",[638,17589,17591],{"id":17590},"_1-cpu-密集型任务","1. CPU 密集型任务",[18,17593,17594],{},"CPU 密集型任务的大部分时间都在执行计算，例如加密、压缩、图像处理和复杂规则计算。",[18,17596,17597],{},"可以把下面的数值作为初始估算：",[95,17599,17602],{"className":17600,"code":17601,"language":100,"meta":101},[98],"线程数 ≈ CPU 核数 + 1\n",[22,17603,17601],{"__ignoreMap":101},[18,17605,17606],{},"线程数明显超过 CPU 并行能力，通常只会增加上下文切换，并不会线性提升吞吐。",[638,17608,17610],{"id":17609},"_2-io-密集型任务","2. I\u002FO 密集型任务",[18,17612,17613],{},"I\u002FO 密集型任务会花较多时间等待数据库、网络、文件或远程服务，可以用以下公式进行初始估算：",[95,17615,17618],{"className":17616,"code":17617,"language":100,"meta":101},[98],"线程数 ≈ CPU 核数 ×（1 + 平均等待时间 ÷ 平均计算时间）\n",[22,17619,17617],{"__ignoreMap":101},[18,17621,17622],{},"例如任务平均计算 10 毫秒、等待下游 40 毫秒，机器有 8 个 CPU 核：",[95,17624,17627],{"className":17625,"code":17626,"language":100,"meta":101},[98],"8 ×（1 + 40 ÷ 10）= 40\n",[22,17628,17626],{"__ignoreMap":101},[18,17630,17631],{},"40 只能作为起始测试值，不能直接当作生产结论。真实上限还受以下因素约束：",[114,17633,17634,17637,17640,17643,17646],{},[117,17635,17636],{},"数据库连接池只有多少连接；",[117,17638,17639],{},"下游接口允许多少并发；",[117,17641,17642],{},"单任务占用多少内存；",[117,17644,17645],{},"机器 CPU、内存和网络容量；",[117,17647,17648],{},"业务允许的超时和排队时长。",[18,17650,17651],{},"如果数据库连接池只有 20 个可用连接，把线程池配置成 200 个线程，往往只是让更多线程阻塞在等待连接上。",[638,17653,17655],{"id":17654},"_3-队列容量怎么定","3. 队列容量怎么定",[18,17657,17658],{},"队列容量应结合四个维度：",[2489,17660,17661,17664,17667,17670],{},[117,17662,17663],{},"高峰任务到达速率；",[117,17665,17666],{},"线程池稳定处理速率；",[117,17668,17669],{},"业务允许的最大排队时间；",[117,17671,17672],{},"单个排队任务占用的内存。",[18,17674,17675],{},"假设高峰期每秒比稳定处理能力多出 100 个任务，业务最多允许这种峰值持续 3 秒，可以从约 300 个队列容量开始评估：",[95,17677,17680],{"className":17678,"code":17679,"language":100,"meta":101},[98],"暂时积压量\n≈（任务到达速率－稳定处理速率）× 峰值持续时间\n",[22,17681,17679],{"__ignoreMap":101},[18,17683,17684],{},"还必须验证队列排满时的内存占用和最老任务等待时间。容量评估的目标不是永不拒绝，而是在允许的延迟和资源范围内吸收短时突发。",[14,17686,17688],{"id":17687},"六日常推荐写法","六、日常推荐写法",[18,17690,17691],{},"下面是一个边界清晰的业务线程池示例：",[95,17693,17695],{"className":135,"code":17694,"language":137,"meta":101,"style":101},"import java.util.List;\nimport java.util.concurrent.ArrayBlockingQueue;\nimport java.util.concurrent.RejectedExecutionException;\nimport java.util.concurrent.ThreadFactory;\nimport java.util.concurrent.ThreadPoolExecutor;\nimport java.util.concurrent.TimeUnit;\nimport java.util.concurrent.atomic.AtomicInteger;\n\npublic final class OrderAsyncExecutor {\n\n private static final AtomicInteger THREAD_ID = new AtomicInteger();\n\n private static final ThreadFactory THREAD_FACTORY = task -> {\n Thread thread = new Thread(\n task,\n \"order-async-\" + THREAD_ID.incrementAndGet()\n );\n thread.setUncaughtExceptionHandler((currentThread, error) ->\n System.err.println(\n currentThread.getName() + \": \" + error.getMessage()\n )\n );\n return thread;\n };\n\n private static final ThreadPoolExecutor EXECUTOR =\n new ThreadPoolExecutor(\n 8,\n 16,\n 60L,\n TimeUnit.SECONDS,\n new ArrayBlockingQueue\u003C>(500),\n THREAD_FACTORY,\n new ThreadPoolExecutor.AbortPolicy()\n );\n\n private OrderAsyncExecutor() {\n }\n\n public static void execute(Runnable task) {\n try {\n EXECUTOR.execute(task);\n } catch (RejectedExecutionException exception) {\n \u002F\u002F 根据业务接入告警、降级、持久化重试或补偿流程\n throw exception;\n }\n }\n\n public static void shutdown() {\n EXECUTOR.shutdown();\n try {\n if (!EXECUTOR.awaitTermination(30, TimeUnit.SECONDS)) {\n List\u003CRunnable> notStartedTasks = EXECUTOR.shutdownNow();\n if (!notStartedTasks.isEmpty()) {\n System.err.println(\n \"未开始执行的任务数：\" + notStartedTasks.size()\n );\n }\n if (!EXECUTOR.awaitTermination(30, TimeUnit.SECONDS)) {\n System.err.println(\"线程池在中断请求后仍未终止\");\n }\n }\n } catch (InterruptedException exception) {\n EXECUTOR.shutdownNow();\n Thread.currentThread().interrupt();\n }\n }\n}\n",[22,17696,17697,17705,17712,17719,17726,17733,17740,17747,17751,17764,17768,17788,17792,17812,17825,17830,17846,17851,17864,17873,17898,17903,17907,17916,17922,17927,17941,17951,17959,17967,17975,17981,17995,18001,18013,18018,18023,18032,18037,18042,18062,18070,18080,18095,18101,18109,18115,18120,18125,18139,18150,18157,18181,18202,18221,18231,18247,18253,18259,18278,18292,18297,18303,18317,18326,18343,18348,18353],{"__ignoreMap":101},[141,17698,17699,17702],{"class":143,"line":144},[141,17700,17701],{"class":151},"import",[141,17703,17704],{"class":147}," java.util.List;\n",[141,17706,17707,17709],{"class":143,"line":165},[141,17708,17701],{"class":151},[141,17710,17711],{"class":147}," java.util.concurrent.ArrayBlockingQueue;\n",[141,17713,17714,17716],{"class":143,"line":210},[141,17715,17701],{"class":151},[141,17717,17718],{"class":147}," java.util.concurrent.RejectedExecutionException;\n",[141,17720,17721,17723],{"class":143,"line":219},[141,17722,17701],{"class":151},[141,17724,17725],{"class":147}," java.util.concurrent.ThreadFactory;\n",[141,17727,17728,17730],{"class":143,"line":234},[141,17729,17701],{"class":151},[141,17731,17732],{"class":147}," java.util.concurrent.ThreadPoolExecutor;\n",[141,17734,17735,17737],{"class":143,"line":241},[141,17736,17701],{"class":151},[141,17738,17739],{"class":147}," java.util.concurrent.TimeUnit;\n",[141,17741,17742,17744],{"class":143,"line":247},[141,17743,17701],{"class":151},[141,17745,17746],{"class":147}," java.util.concurrent.atomic.AtomicInteger;\n",[141,17748,17749],{"class":143,"line":307},[141,17750,207],{"emptyLinePlaceholder":206},[141,17752,17753,17755,17757,17759,17762],{"class":143,"line":379},[141,17754,193],{"class":151},[141,17756,484],{"class":151},[141,17758,196],{"class":151},[141,17760,17761],{"class":158}," OrderAsyncExecutor",[141,17763,201],{"class":147},[141,17765,17766],{"class":143,"line":391},[141,17767,207],{"emptyLinePlaceholder":206},[141,17769,17770,17772,17774,17776,17779,17781,17783,17786],{"class":143,"line":396},[141,17771,481],{"class":151},[141,17773,728],{"class":151},[141,17775,484],{"class":151},[141,17777,17778],{"class":147}," AtomicInteger THREAD_ID ",[141,17780,152],{"class":151},[141,17782,155],{"class":151},[141,17784,17785],{"class":158}," AtomicInteger",[141,17787,162],{"class":147},[141,17789,17790],{"class":143,"line":401},[141,17791,207],{"emptyLinePlaceholder":206},[141,17793,17794,17796,17798,17800,17803,17805,17808,17810],{"class":143,"line":554},[141,17795,481],{"class":151},[141,17797,728],{"class":151},[141,17799,484],{"class":151},[141,17801,17802],{"class":147}," ThreadFactory THREAD_FACTORY ",[141,17804,152],{"class":151},[141,17806,17807],{"class":147}," task ",[141,17809,4689],{"class":151},[141,17811,201],{"class":147},[141,17813,17814,17817,17819,17821,17823],{"class":143,"line":559},[141,17815,17816],{"class":147}," Thread thread ",[141,17818,152],{"class":151},[141,17820,155],{"class":151},[141,17822,1249],{"class":158},[141,17824,17073],{"class":147},[141,17826,17827],{"class":143,"line":564},[141,17828,17829],{"class":147}," task,\n",[141,17831,17832,17835,17838,17841,17844],{"class":143,"line":571},[141,17833,17834],{"class":911}," \"order-async-\"",[141,17836,17837],{"class":151}," +",[141,17839,17840],{"class":147}," THREAD_ID.",[141,17842,17843],{"class":158},"incrementAndGet",[141,17845,1184],{"class":147},[141,17847,17848],{"class":143,"line":583},[141,17849,17850],{"class":147}," );\n",[141,17852,17853,17856,17859,17862],{"class":143,"line":588},[141,17854,17855],{"class":147}," thread.",[141,17857,17858],{"class":158},"setUncaughtExceptionHandler",[141,17860,17861],{"class":147},"((currentThread, error) ",[141,17863,1255],{"class":151},[141,17865,17866,17869,17871],{"class":143,"line":595},[141,17867,17868],{"class":147}," System.err.",[141,17870,3194],{"class":158},[141,17872,17073],{"class":147},[141,17874,17875,17878,17881,17883,17885,17888,17890,17893,17896],{"class":143,"line":606},[141,17876,17877],{"class":147}," currentThread.",[141,17879,17880],{"class":158},"getName",[141,17882,16196],{"class":147},[141,17884,11754],{"class":151},[141,17886,17887],{"class":911}," \": \"",[141,17889,17837],{"class":151},[141,17891,17892],{"class":147}," error.",[141,17894,17895],{"class":158},"getMessage",[141,17897,1184],{"class":147},[141,17899,17900],{"class":143,"line":611},[141,17901,17902],{"class":147}," )\n",[141,17904,17905],{"class":143,"line":616},[141,17906,17850],{"class":147},[141,17908,17910,17913],{"class":143,"line":17909},23,[141,17911,17912],{"class":151}," return",[141,17914,17915],{"class":147}," thread;\n",[141,17917,17919],{"class":143,"line":17918},24,[141,17920,17921],{"class":147}," };\n",[141,17923,17925],{"class":143,"line":17924},25,[141,17926,207],{"emptyLinePlaceholder":206},[141,17928,17930,17932,17934,17936,17939],{"class":143,"line":17929},26,[141,17931,481],{"class":151},[141,17933,728],{"class":151},[141,17935,484],{"class":151},[141,17937,17938],{"class":147}," ThreadPoolExecutor EXECUTOR ",[141,17940,16185],{"class":151},[141,17942,17944,17947,17949],{"class":143,"line":17943},27,[141,17945,17946],{"class":151}," new",[141,17948,17070],{"class":158},[141,17950,17073],{"class":147},[141,17952,17954,17957],{"class":143,"line":17953},28,[141,17955,17956],{"class":428}," 8",[141,17958,13814],{"class":147},[141,17960,17962,17965],{"class":143,"line":17961},29,[141,17963,17964],{"class":428}," 16",[141,17966,13814],{"class":147},[141,17968,17970,17973],{"class":143,"line":17969},30,[141,17971,17972],{"class":428}," 60L",[141,17974,13814],{"class":147},[141,17976,17978],{"class":143,"line":17977},31,[141,17979,17980],{"class":147}," TimeUnit.SECONDS,\n",[141,17982,17984,17987,17990,17993],{"class":143,"line":17983},32,[141,17985,17986],{"class":151}," new",[141,17988,17989],{"class":147}," ArrayBlockingQueue\u003C>(",[141,17991,17992],{"class":428},"500",[141,17994,12044],{"class":147},[141,17996,17998],{"class":143,"line":17997},33,[141,17999,18000],{"class":147}," THREAD_FACTORY,\n",[141,18002,18004,18006,18009,18011],{"class":143,"line":18003},34,[141,18005,17986],{"class":151},[141,18007,18008],{"class":147}," ThreadPoolExecutor.",[141,18010,17456],{"class":158},[141,18012,1184],{"class":147},[141,18014,18015],{"class":143,"line":3464},[141,18016,18017],{"class":147}," );\n",[141,18019,18021],{"class":143,"line":18020},36,[141,18022,207],{"emptyLinePlaceholder":206},[141,18024,18026,18028,18030],{"class":143,"line":18025},37,[141,18027,481],{"class":151},[141,18029,17761],{"class":158},[141,18031,231],{"class":147},[141,18033,18035],{"class":143,"line":18034},38,[141,18036,244],{"class":147},[141,18038,18040],{"class":143,"line":18039},39,[141,18041,207],{"emptyLinePlaceholder":206},[141,18043,18045,18047,18049,18051,18054,18057,18060],{"class":143,"line":18044},40,[141,18046,222],{"class":151},[141,18048,728],{"class":151},[141,18050,225],{"class":151},[141,18052,18053],{"class":158}," execute",[141,18055,18056],{"class":147},"(Runnable ",[141,18058,18059],{"class":503},"task",[141,18061,507],{"class":147},[141,18063,18065,18068],{"class":143,"line":18064},41,[141,18066,18067],{"class":151}," try",[141,18069,201],{"class":147},[141,18071,18073,18076,18078],{"class":143,"line":18072},42,[141,18074,18075],{"class":147}," EXECUTOR.",[141,18077,17526],{"class":158},[141,18079,17529],{"class":147},[141,18081,18083,18086,18088,18091,18093],{"class":143,"line":18082},43,[141,18084,18085],{"class":147}," } ",[141,18087,1083],{"class":151},[141,18089,18090],{"class":147}," (RejectedExecutionException ",[141,18092,1089],{"class":503},[141,18094,507],{"class":147},[141,18096,18098],{"class":143,"line":18097},44,[141,18099,18100],{"class":237}," \u002F\u002F 根据业务接入告警、降级、持久化重试或补偿流程\n",[141,18102,18104,18107],{"class":143,"line":18103},45,[141,18105,18106],{"class":151}," throw",[141,18108,1156],{"class":147},[141,18110,18112],{"class":143,"line":18111},46,[141,18113,18114],{"class":147}," }\n",[141,18116,18118],{"class":143,"line":18117},47,[141,18119,244],{"class":147},[141,18121,18123],{"class":143,"line":18122},48,[141,18124,207],{"emptyLinePlaceholder":206},[141,18126,18128,18130,18132,18134,18137],{"class":143,"line":18127},49,[141,18129,222],{"class":151},[141,18131,728],{"class":151},[141,18133,225],{"class":151},[141,18135,18136],{"class":158}," shutdown",[141,18138,231],{"class":147},[141,18140,18142,18145,18148],{"class":143,"line":18141},50,[141,18143,18144],{"class":147}," EXECUTOR.",[141,18146,18147],{"class":158},"shutdown",[141,18149,162],{"class":147},[141,18151,18153,18155],{"class":143,"line":18152},51,[141,18154,18067],{"class":151},[141,18156,201],{"class":147},[141,18158,18160,18163,18165,18168,18171,18174,18176,18178],{"class":143,"line":18159},52,[141,18161,18162],{"class":151}," if",[141,18164,4965],{"class":147},[141,18166,18167],{"class":151},"!",[141,18169,18170],{"class":147},"EXECUTOR.",[141,18172,18173],{"class":158},"awaitTermination",[141,18175,908],{"class":147},[141,18177,14515],{"class":428},[141,18179,18180],{"class":147},", TimeUnit.SECONDS)) {\n",[141,18182,18184,18187,18189,18192,18194,18197,18200],{"class":143,"line":18183},53,[141,18185,18186],{"class":147}," List\u003C",[141,18188,17111],{"class":151},[141,18190,18191],{"class":147},"> notStartedTasks ",[141,18193,152],{"class":151},[141,18195,18196],{"class":147}," EXECUTOR.",[141,18198,18199],{"class":158},"shutdownNow",[141,18201,162],{"class":147},[141,18203,18205,18208,18210,18212,18215,18218],{"class":143,"line":18204},54,[141,18206,18207],{"class":151}," if",[141,18209,4965],{"class":147},[141,18211,18167],{"class":151},[141,18213,18214],{"class":147},"notStartedTasks.",[141,18216,18217],{"class":158},"isEmpty",[141,18219,18220],{"class":147},"()) {\n",[141,18222,18224,18227,18229],{"class":143,"line":18223},55,[141,18225,18226],{"class":147}," System.err.",[141,18228,3194],{"class":158},[141,18230,17073],{"class":147},[141,18232,18234,18237,18239,18242,18245],{"class":143,"line":18233},56,[141,18235,18236],{"class":911}," \"未开始执行的任务数：\"",[141,18238,17837],{"class":151},[141,18240,18241],{"class":147}," notStartedTasks.",[141,18243,18244],{"class":158},"size",[141,18246,1184],{"class":147},[141,18248,18250],{"class":143,"line":18249},57,[141,18251,18252],{"class":147}," );\n",[141,18254,18256],{"class":143,"line":18255},58,[141,18257,18258],{"class":147}," }\n",[141,18260,18262,18264,18266,18268,18270,18272,18274,18276],{"class":143,"line":18261},59,[141,18263,18207],{"class":151},[141,18265,4965],{"class":147},[141,18267,18167],{"class":151},[141,18269,18170],{"class":147},[141,18271,18173],{"class":158},[141,18273,908],{"class":147},[141,18275,14515],{"class":428},[141,18277,18180],{"class":147},[141,18279,18281,18283,18285,18287,18290],{"class":143,"line":18280},60,[141,18282,18226],{"class":147},[141,18284,3194],{"class":158},[141,18286,908],{"class":147},[141,18288,18289],{"class":911},"\"线程池在中断请求后仍未终止\"",[141,18291,915],{"class":147},[141,18293,18295],{"class":143,"line":18294},61,[141,18296,18258],{"class":147},[141,18298,18300],{"class":143,"line":18299},62,[141,18301,18302],{"class":147}," }\n",[141,18304,18306,18308,18310,18313,18315],{"class":143,"line":18305},63,[141,18307,18085],{"class":147},[141,18309,1083],{"class":151},[141,18311,18312],{"class":147}," (InterruptedException ",[141,18314,1089],{"class":503},[141,18316,507],{"class":147},[141,18318,18320,18322,18324],{"class":143,"line":18319},64,[141,18321,18075],{"class":147},[141,18323,18199],{"class":158},[141,18325,162],{"class":147},[141,18327,18329,18332,18335,18338,18341],{"class":143,"line":18328},65,[141,18330,18331],{"class":147}," Thread.",[141,18333,18334],{"class":158},"currentThread",[141,18336,18337],{"class":147},"().",[141,18339,18340],{"class":158},"interrupt",[141,18342,162],{"class":147},[141,18344,18346],{"class":143,"line":18345},66,[141,18347,18114],{"class":147},[141,18349,18351],{"class":143,"line":18350},67,[141,18352,244],{"class":147},[141,18354,18356],{"class":143,"line":18355},68,[141,18357,250],{"class":147},[18,18359,18360],{},"这个示例体现了几个基本原则：",[114,18362,18363,18366,18369,18372,18375,18378],{},[117,18364,18365],{},"线程池被复用，而不是每次请求临时创建；",[117,18367,18368],{},"核心线程、最大线程和队列容量都有明确上限；",[117,18370,18371],{},"线程名能够定位到业务；",[117,18373,18374],{},"拒绝不会被静默忽略；",[117,18376,18377],{},"停止应用时先等待已有任务完成，超时后再中断；",[117,18379,18380,18381,18384],{},"捕获 ",[22,18382,18383],{},"InterruptedException"," 后恢复当前线程的中断状态。",[18,18386,18387],{},"实际业务应把告警、指标和补偿接入统一基础设施，而不是只输出错误信息。",[14,18389,18391],{"id":18390},"七为什么不建议盲目使用-executors-工厂方法","七、为什么不建议盲目使用 Executors 工厂方法",[18,18393,18394,18397],{},[22,18395,18396],{},"Executors"," 提供的工厂方法使用方便，但部分方法隐藏了重要的资源边界。",[638,18399,18401],{"id":18400},"_1-newfixedthreadpool-和-newsinglethreadexecutor","1. newFixedThreadPool 和 newSingleThreadExecutor",[18,18403,18404,18405,18407,18408,18410],{},"它们内部使用没有指定容量的 ",[22,18406,17328],{},"。该队列的默认容量是 ",[22,18409,17337],{},"，从业务运行角度看，等同于没有设置可控的任务积压上限：",[95,18412,18415],{"className":18413,"code":18414,"language":100,"meta":101},[98],"生产速度长期大于处理速度\n→ 队列持续增长\n→ 排队延迟和内存占用持续上升\n",[22,18416,18414],{"__ignoreMap":101},[638,18418,18420],{"id":18419},"_2-newcachedthreadpool","2. newCachedThreadPool",[18,18422,18423,18426],{},[22,18424,18425],{},"newCachedThreadPool"," 的主要风险确实来自最大线程数接近无上限。它的关键参数可以简化为：",[95,18428,18431],{"className":18429,"code":18430,"language":100,"meta":101},[98],"corePoolSize = 0\nmaximumPoolSize = Integer.MAX_VALUE\nworkQueue = SynchronousQueue\nkeepAliveTime = 60 秒\n",[22,18432,18430],{"__ignoreMap":101},[18,18434,18435,18437,18438,18440,18441,18443],{},[22,18436,17345],{}," 本身不保存任务。提交任务时，如果没有空闲线程能够接手，线程池就会创建新线程；而 ",[22,18439,16973],{}," 又被设置为 ",[22,18442,17337],{},"，因此任务持续到达或长期阻塞时，线程数量可能快速增长，最终造成大量线程占用内存、频繁上下文切换，甚至耗尽系统资源。",[18,18445,18446],{},"所以它的风险不是任务在队列中无限积压，而是：",[95,18448,18451],{"className":18449,"code":18450,"language":100,"meta":101},[98],"SynchronousQueue 不缓冲任务\n+ maximumPoolSize 接近无上限\n→ 没有空闲线程时持续创建新线程\n",[22,18452,18450],{"__ignoreMap":101},[18,18454,18455,18456,18458],{},"因此在资源敏感的服务端业务中，显式创建 ",[22,18457,16965],{}," 通常更容易表达：",[114,18460,18461,18464,18467],{},[117,18462,18463],{},"最多允许多少并发线程；",[117,18465,18466],{},"最多允许积压多少任务；",[117,18468,18469],{},"超出能力后如何处理。",[18,18471,18472,18473,18475],{},"这并不表示所有 ",[22,18474,18396],{}," 方法都不能使用，而是需要先理解其内部参数和运行边界。",[14,18477,18479],{"id":18478},"八execute-和-submit-有什么区别","八、execute 和 submit 有什么区别",[638,18481,17526],{"id":17526},[95,18483,18484],{"className":135,"code":17517,"language":137,"meta":101,"style":101},[22,18485,18486],{"__ignoreMap":101},[141,18487,18488,18490,18492],{"class":143,"line":144},[141,18489,17148],{"class":147},[141,18491,17526],{"class":158},[141,18493,17529],{"class":147},[114,18495,18496,18501,18504],{},[117,18497,18498,18499,2159],{},"只接收 ",[22,18500,17111],{},[117,18502,18503],{},"没有任务结果；",[117,18505,18506],{},"任务抛出的未捕获异常可以到达线程的未捕获异常处理流程。",[638,18508,18509],{"id":18509},"submit",[95,18511,18513],{"className":135,"code":18512,"language":137,"meta":101,"style":101},"Future\u003CResult> future = threadPool.submit(callable);\n",[22,18514,18515],{"__ignoreMap":101},[141,18516,18517,18520,18523,18526,18528,18531,18533],{"class":143,"line":144},[141,18518,18519],{"class":147},"Future\u003C",[141,18521,18522],{"class":151},"Result",[141,18524,18525],{"class":147},"> future ",[141,18527,152],{"class":151},[141,18529,18530],{"class":147}," threadPool.",[141,18532,18509],{"class":158},[141,18534,18535],{"class":147},"(callable);\n",[114,18537,18538,18546,18552],{},[117,18539,18540,18541,6067,18543,2159],{},"可以接收 ",[22,18542,17111],{},[22,18544,18545],{},"Callable",[117,18547,18548,18549,18551],{},"返回 ",[22,18550,4671],{},"，可以获取结果、等待完成或取消任务；",[117,18553,18554,18555,18557,18558,18561,18562,18565],{},"任务异常会被封装在 ",[22,18556,4671],{}," 中，调用 ",[22,18559,18560],{},"get()"," 时以 ",[22,18563,18564],{},"ExecutionException"," 抛出。",[18,18567,18568,18569,18572,18573,18575,18576,4878],{},"如果调用 ",[22,18570,18571],{},"submit()"," 后既不保存 ",[22,18574,4671],{},"，也不检查任务结果，异常很容易被忽略。此时应在任务内部记录异常，或统一检查 ",[22,18577,4671],{},[14,18579,18581],{"id":18580},"九不同类型的任务为什么要隔离线程池","九、不同类型的任务为什么要隔离线程池",[18,18583,18584],{},"把所有异步任务放进同一个线程池，会产生资源相互影响。",[18,18586,1398],{},[95,18588,18591],{"className":18589,"code":18590,"language":100,"meta":101},[98],"慢第三方接口占满全部线程\n→ 订单本地计算任务无法执行\n→ 两类本来无关的业务一起超时\n",[22,18592,18590],{"__ignoreMap":101},[18,18594,18595],{},"可以按资源特征或故障域拆分：",[114,18597,18598,18601,18604,18607,18610],{},[117,18599,18600],{},"CPU 计算任务使用计算线程池；",[117,18602,18603],{},"数据库写入任务使用受连接池容量约束的线程池；",[117,18605,18606],{},"慢第三方接口使用独立线程池；",[117,18608,18609],{},"核心交易和非核心通知分开；",[117,18611,18612],{},"不同下游服务使用独立的并发上限。",[18,18614,18615],{},"线程池隔离不是越细越好。线程池过多会增加线程总数和管理成本，应围绕“是否共享同一个资源上限、是否应该相互影响”来划分。",[14,18617,18619],{"id":18618},"十需要监控哪些指标","十、需要监控哪些指标",[18,18621,18622],{},"线程池上线后至少应监控：",[1309,18624,18625,18634],{},[1312,18626,18627],{},[1315,18628,18629,18631],{},[1318,18630,6831],{},[1318,18632,18633],{},"说明",[1328,18635,18636,18647,18658,18669,18677,18685,18696,18704,18712,18720],{},[1315,18637,18638,18644],{},[1333,18639,18640,18641],{},"当前线程数 ",[22,18642,18643],{},"poolSize",[1333,18645,18646],{},"线程池当前拥有的工作线程数量",[1315,18648,18649,18655],{},[1333,18650,18651,18652],{},"活跃线程数 ",[22,18653,18654],{},"activeCount",[1333,18656,18657],{},"正在执行任务的线程数量",[1315,18659,18660,18666],{},[1333,18661,18662,18663],{},"历史最大线程数 ",[22,18664,18665],{},"largestPoolSize",[1333,18667,18668],{},"是否曾经逼近最大线程数",[1315,18670,18671,18674],{},[1333,18672,18673],{},"队列长度",[1333,18675,18676],{},"当前排队任务数量",[1315,18678,18679,18682],{},[1333,18680,18681],{},"队列剩余容量",[1333,18683,18684],{},"距离队列满还有多少空间",[1315,18686,18687,18693],{},[1333,18688,18689,18690],{},"已完成任务数 ",[22,18691,18692],{},"completedTaskCount",[1333,18694,18695],{},"任务是否持续推进",[1315,18697,18698,18701],{},[1333,18699,18700],{},"拒绝次数",[1333,18702,18703],{},"线程池是否已经过载",[1315,18705,18706,18709],{},[1333,18707,18708],{},"任务排队耗时",[1333,18710,18711],{},"任务从提交到开始执行等待了多久",[1315,18713,18714,18717],{},[1333,18715,18716],{},"任务执行耗时",[1333,18718,18719],{},"业务逻辑自身耗时",[1315,18721,18722,18725],{},[1333,18723,18724],{},"任务成功率与异常数",[1333,18726,18727],{},"是否存在持续失败或异常被吞掉",[18,18729,18730],{},"常见告警信号包括：",[114,18732,18733,18736,18739,18742,18745,18748],{},[117,18734,18735],{},"活跃线程数长时间接近最大线程数；",[117,18737,18738],{},"队列长度持续上升而不是短时波动；",[117,18740,18741],{},"排队耗时接近业务超时时间；",[117,18743,18744],{},"拒绝次数持续增长；",[117,18746,18747],{},"已完成任务数停止增长；",[117,18749,18750],{},"下游连接池和线程池同时耗尽。",[18,18752,18753],{},"只监控线程数量不够。很多线程池故障的第一表现不是线程数异常，而是队列等待时间持续增加。",[14,18755,18757],{"id":18756},"十一如何优雅关闭线程池","十一、如何优雅关闭线程池",[18,18759,18760,2818,18763,18766],{},[22,18761,18762],{},"shutdown()",[22,18764,18765],{},"shutdownNow()"," 的语义不同：",[95,18768,18771],{"className":18769,"code":18770,"language":100,"meta":101},[98],"shutdown()\n→ 不再接收新任务\n→ 继续执行已提交任务\n\nshutdownNow()\n→ 尝试中断正在执行的任务\n→ 返回队列中尚未开始的任务\n",[22,18772,18770],{"__ignoreMap":101},[18,18774,18775],{},"常见关闭流程是：",[95,18777,18780],{"className":18778,"code":18779,"language":100,"meta":101},[98],"调用 shutdown()\n→ 在限定时间内 awaitTermination()\n→ 超时后调用 shutdownNow()\n→ 记录尚未开始执行的任务\n→ 再次 awaitTermination()，等待已收到中断请求的工作线程退出\n",[22,18781,18779],{"__ignoreMap":101},[18,18783,18784],{},"这里的“再次等待”不是重复做同一件事。",[18,18786,18787,18788,18791,18792,18794],{},"第一次 ",[22,18789,18790],{},"awaitTermination()"," 等待线程池在不接收新任务的前提下，自然执行完已经提交的任务。如果超时，",[22,18793,18765],{}," 会：",[2489,18796,18797,18800],{},[117,18798,18799],{},"尝试中断正在执行的工作线程；",[117,18801,18802],{},"返回队列中尚未开始执行的任务列表。",[18,18804,18805,18806,18808],{},"调用方可以记录或补偿这批尚未开始的任务。随后第二次调用 ",[22,18807,18790],{},"，是给已经收到中断请求的工作线程留出退出时间。如果第二次仍然超时，说明某些任务可能没有正确响应中断，需要记录告警并进一步排查。",[18,18810,13473,18811,18813],{},[22,18812,18765],{}," 只能发出中断请求，不能强制终止线程。如果任务忽略中断，线程池仍可能无法及时结束。",[18,18815,18816,18817,18819],{},"任务代码还必须正确响应中断。阻塞调用收到 ",[22,18818,18383],{}," 后，不应随意吞掉中断状态。",[14,18821,18823],{"id":18822},"十二常见误区","十二、常见误区",[638,18825,18827],{"id":18826},"_1-最大线程数越大处理能力越强","1. 最大线程数越大，处理能力越强",[18,18829,18830],{},"线程数量超过 CPU、数据库连接池或下游承载能力后，只会增加竞争、等待和上下文切换。",[638,18832,18834],{"id":18833},"_2-队列越大越不容易出问题","2. 队列越大，越不容易出问题",[18,18836,18837],{},"大队列可能只是把拒绝转化为更长的延迟和更高的内存风险。",[638,18839,18841],{"id":18840},"_3-使用-callerrunspolicy-就解决了限流","3. 使用 CallerRunsPolicy 就解决了限流",[18,18843,18844,18846],{},[22,18845,17472],{}," 会让提交线程执行任务，从而减慢生产者，但它不是严格的 QPS 限流器。调用线程可能是 Web 请求线程、消息消费线程或定时调度线程，执行任务会影响这些上游组件的延迟和可用性。",[638,18848,18850],{"id":18849},"_4-threadpoolexecutor-线程安全任务就一定线程安全","4. ThreadPoolExecutor 线程安全，任务就一定线程安全",[18,18852,18853],{},"线程池只负责安全调度任务，不会自动保护任务访问的共享对象。任务内部仍要正确使用锁、原子类、并发容器或不可变对象。",[638,18855,18857],{"id":18856},"_5-submit-后没有异常日志就表示任务成功","5. submit 后没有异常日志，就表示任务成功",[18,18859,18860,18862,18863,18865,18866,18868],{},[22,18861,18571],{}," 会把异常保存到 ",[22,18864,4671],{},"。如果从未调用 ",[22,18867,18560],{}," 或没有统一异常处理，失败可能没有明显日志。",[638,18870,18872],{"id":18871},"_6-线程池能够无限吸收突发流量","6. 线程池能够无限吸收突发流量",[18,18874,18875],{},"线程池只能在有限线程和有限队列范围内吸收波动。持续过载必须通过限流、降级、削峰、扩容或优化下游能力解决。",[14,18877,18879],{"id":18878},"十三日常使用检查清单","十三、日常使用检查清单",[114,18881,18882,18885,18888,18891,18894,18897,18900,18903,18911,18918],{},[117,18883,18884],{},"是否按照任务类型和下游资源进行合理隔离；",[117,18886,18887],{},"是否明确设置线程数和有界队列；",[117,18889,18890],{},"线程数量是否与 CPU、连接池和下游容量匹配；",[117,18892,18893],{},"是否设置可识别的线程名称；",[117,18895,18896],{},"拒绝策略是否符合业务语义；",[117,18898,18899],{},"被拒绝任务是否有告警、降级或补偿；",[117,18901,18902],{},"是否记录排队耗时、执行耗时和拒绝次数；",[117,18904,18905,18907,18908,18910],{},[22,18906,18571],{}," 返回的 ",[22,18909,4671],{}," 是否被正确处理；",[117,18912,18913,18914,18917],{},"任务是否支持中断，是否会泄漏 ",[22,18915,18916],{},"ThreadLocal"," 上下文；",[117,18919,18920],{},"应用关闭时是否执行线程池优雅停止。",[14,18922,5605],{"id":5605},[114,18924,18925,18932,18939],{},[117,18926,18927],{},[73,18928,18931],{"href":18929,"rel":18930},"https:\u002F\u002Fdocs.oracle.com\u002Fjavase\u002F8\u002Fdocs\u002Fapi\u002Fjava\u002Futil\u002Fconcurrent\u002FThreadPoolExecutor.html",[1876],"ThreadPoolExecutor Java 8 API",[117,18933,18934],{},[73,18935,18938],{"href":18936,"rel":18937},"https:\u002F\u002Fdocs.oracle.com\u002Fjavase\u002F8\u002Fdocs\u002Fapi\u002Fjava\u002Futil\u002Fconcurrent\u002FExecutors.html",[1876],"Executors Java 8 API",[117,18940,18941],{},[73,18942,18945],{"href":18943,"rel":18944},"https:\u002F\u002Fdocs.oracle.com\u002Fjavase\u002F8\u002Fdocs\u002Fapi\u002Fjava\u002Futil\u002Fconcurrent\u002FRejectedExecutionHandler.html",[1876],"RejectedExecutionHandler Java 8 API",[1907,18947,18948],{},"html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}html pre.shiki code .s4XuR, html code.shiki .s4XuR{--shiki-default:#E36209;--shiki-dark:#FFAB70}html pre.shiki code .sJ8bj, html code.shiki .sJ8bj{--shiki-default:#6A737D;--shiki-dark:#6A737D}",{"title":101,"searchDepth":165,"depth":165,"links":18950},[18951,18952,18953,18954,18955,18964,18965,18966,18971,18972,18976,18980,18981,18982,18983,18991,18992],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":17024,"depth":165,"text":17025},{"id":17054,"depth":165,"text":17055,"children":18956},[18957,18958,18959,18960,18961,18962,18963],{"id":17129,"depth":210,"text":17130},{"id":17182,"depth":210,"text":17183},{"id":17205,"depth":210,"text":17206},{"id":17250,"depth":210,"text":17251},{"id":17281,"depth":210,"text":17282},{"id":17390,"depth":210,"text":17391},{"id":17425,"depth":210,"text":17426},{"id":17510,"depth":165,"text":17511},{"id":17549,"depth":165,"text":17550},{"id":17586,"depth":165,"text":17587,"children":18967},[18968,18969,18970],{"id":17590,"depth":210,"text":17591},{"id":17609,"depth":210,"text":17610},{"id":17654,"depth":210,"text":17655},{"id":17687,"depth":165,"text":17688},{"id":18390,"depth":165,"text":18391,"children":18973},[18974,18975],{"id":18400,"depth":210,"text":18401},{"id":18419,"depth":210,"text":18420},{"id":18478,"depth":165,"text":18479,"children":18977},[18978,18979],{"id":17526,"depth":210,"text":17526},{"id":18509,"depth":210,"text":18509},{"id":18580,"depth":165,"text":18581},{"id":18618,"depth":165,"text":18619},{"id":18756,"depth":165,"text":18757},{"id":18822,"depth":165,"text":18823,"children":18984},[18985,18986,18987,18988,18989,18990],{"id":18826,"depth":210,"text":18827},{"id":18833,"depth":210,"text":18834},{"id":18840,"depth":210,"text":18841},{"id":18849,"depth":210,"text":18850},{"id":18856,"depth":210,"text":18857},{"id":18871,"depth":210,"text":18872},{"id":18878,"depth":165,"text":18879},{"id":5605,"depth":165,"text":5605},"wiki:java:java-thread-pool-core-parameters-and-practice","系统讲解 ThreadPoolExecutor 七个核心参数、任务提交流程、阻塞队列与拒绝策略选择，并给出线程池配置、监控、关闭和容量评估的日常实践。",{},79,"\u002Fjava\u002Fjava-thread-pool-core-parameters-and-practice",{"title":16953,"description":18994},"java\u002Fjava-thread-pool-core-parameters-and-practice","2026-07-27","di9Q_z1vSXT1dkyqU0bFHy7k2NFzb6V7vRHzB-lGKx4",{"id":19003,"title":19004,"body":19005,"commentId":21688,"description":21689,"difficulty":3462,"draft":1943,"extension":1944,"meta":21690,"navigation":206,"order":21691,"path":21692,"section":1948,"seo":21693,"stem":21694,"updated":19000,"__hash__":21695},"java\u002Fjava\u002Fspring-bean-lifecycle-and-extension-points.md","Spring Bean 生命周期有哪些阶段？都有哪些扩展点？",{"type":7,"value":19006,"toc":21627},[19007,19010,19012,19018,19036,19060,19074,19105,19107,19114,19116,19125,19127,19131,19134,19138,19141,19147,19151,19154,19160,19168,19172,19177,19200,19203,19229,19232,19236,19242,19244,19255,19261,19265,19273,19275,19286,19290,19299,19352,19358,19372,19389,19393,19396,19401,19443,19446,19449,19466,19473,19486,19489,19499,19503,19509,19512,19613,19616,19651,19654,19657,19663,19673,19677,19684,19688,19693,19696,19702,19705,19709,19718,19771,19774,19780,19783,19789,19796,20008,20020,20026,20096,20102,20106,20109,20171,20177,20181,20184,20205,20211,20215,20218,20222,20225,20231,20234,20245,20256,20260,20263,20269,20272,20278,20280,20294,20298,20305,20316,20322,20326,20332,20338,20342,20348,20351,20370,20373,20377,20380,20383,20467,20477,20480,20484,20487,20501,20503,20517,20521,20529,20532,20538,20542,20545,20563,20565,20673,20676,20736,20742,20745,20756,20759,20763,20766,20779,20782,20796,20802,20805,20811,20820,20824,20827,20831,20834,20867,20869,20884,20887,20891,20896,20899,20934,20937,20940,20944,20949,21012,21015,21032,21038,21042,21045,21048,21072,21080,21083,21100,21104,21111,21114,21120,21124,21262,21266,21273,21366,21372,21378,21385,21389,21392,21418,21428,21431,21448,21452,21456,21459,21463,21468,21472,21475,21479,21485,21489,21492,21496,21507,21511,21514,21520,21523,21529,21533,21585,21587,21624],[10,19008,19004],{"id":19009},"spring-bean-生命周期有哪些阶段都有哪些扩展点",[14,19011,16],{"id":16},[18,19013,19014,19015,4878],{},"Spring Bean 的完整生命周期可以分为：",[64,19016,19017],{},"Bean 定义注册与修改、实例化、属性填充、Aware 回调、初始化前处理、初始化、初始化后处理、Bean 就绪，以及容器关闭时的销毁",[18,19019,19020,19021,4878,19024,19027,19028,19031,19032,19035],{},"容器启动后，首先读取配置并注册 ",[22,19022,19023],{},"BeanDefinition",[22,19025,19026],{},"BeanDefinitionRegistryPostProcessor"," 可以继续注册或删除定义，",[22,19029,19030],{},"BeanFactoryPostProcessor"," 可以在 Bean 创建前修改定义。随后 Spring 注册所有 ",[22,19033,19034],{},"BeanPostProcessor","，再创建非懒加载单例。",[18,19037,19038,19039,19042,19043,44,19046,44,19048,19051,19052,19055,19056,19059],{},"创建单个 Bean 时，Spring先选择构造方法并实例化对象，再进行依赖注入；随后执行 ",[22,19040,19041],{},"Aware"," 回调、",[22,19044,19045],{},"BeanPostProcessor#postProcessBeforeInitialization()",[22,19047,39],{},[22,19049,19050],{},"InitializingBean#afterPropertiesSet()"," 和自定义 ",[22,19053,19054],{},"init-method","，最后执行 ",[22,19057,19058],{},"postProcessAfterInitialization()","。Spring AOP 通常在初始化后处理阶段返回代理对象。",[18,19061,19062,19063,19066,19067,19070,19071,19073],{},"这条主线还有一个特殊分支：目标对象实例化之前，",[22,19064,19065],{},"InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()"," 可以返回替代对象。返回 ",[22,19068,19069],{},"null"," 才会继续正常创建；返回非 ",[22,19072,19069],{}," 时会跳过原 Bean 的实例化、属性填充和初始化，并对替代对象执行初始化后处理。",[18,19075,19076,19077,19080,19081,19084,19085,19088,19089,19092,19093,19096,19097,19100,19101,19104],{},"所有普通非懒加载单例创建完成后，可以使用 ",[22,19078,19079],{},"SmartInitializingSingleton"," 或监听 ",[22,19082,19083],{},"ContextRefreshedEvent"," 执行全局初始化；需要管理组件启动和停止顺序时，可以使用 ",[22,19086,19087],{},"SmartLifecycle","。容器关闭时，先由 ",[22,19090,19091],{},"DestructionAwareBeanPostProcessor"," 执行销毁前处理，其中 ",[22,19094,19095],{},"CommonAnnotationBeanPostProcessor"," 会调用 ",[22,19098,19099],{},"@PreDestroy","；之后再执行 ",[22,19102,19103],{},"DisposableBean#destroy()"," 和自定义销毁方法。",[18,19106,57],{},[59,19108,19109],{},[18,19110,19111],{},[64,19112,19113],{},"Spring 先处理 BeanDefinition，再通过 BeanPostProcessor 贯穿 Bean 的创建过程；Bean 初始化完成不等于容器全部就绪，批量就绪、运行启停和销毁分别有对应扩展点。",[14,19115,69],{"id":69},[18,19117,19118],{},[73,19119,19122],{"href":19120,"target":76,"rel":19121},"\u002Fimages\u002Fwiki\u002Fjava\u002Fspring-bean-lifecycle-and-extension-points.svg",[78,79],[81,19123],{"src":19120,"alt":19124},"Spring 容器启动、Bean 创建、就绪运行和销毁阶段及主要扩展点",[14,19126,86],{"id":86},[14,19128,19130],{"id":19129},"一先区分两个生命周期","一、先区分两个生命周期",[18,19132,19133],{},"讨论“Spring 生命周期”时，容易把两个概念混在一起：",[638,19135,19137],{"id":19136},"_1-applicationcontext-容器生命周期","1. ApplicationContext 容器生命周期",[18,19139,19140],{},"容器负责：",[95,19142,19145],{"className":19143,"code":19144,"language":100,"meta":101},[98],"加载配置\n→ 注册和修改 BeanDefinition\n→ 注册容器级后处理器\n→ 创建非懒加载单例\n→ 发布刷新完成事件\n→ 启动 Lifecycle 组件\n→ 关闭并销毁单例\n",[22,19146,19144],{"__ignoreMap":101},[638,19148,19150],{"id":19149},"_2-单个-bean-的生命周期","2. 单个 Bean 的生命周期",[18,19152,19153],{},"单个 Bean 经历：",[95,19155,19158],{"className":19156,"code":19157,"language":100,"meta":101},[98],"实例化\n→ 属性填充\n→ Aware 回调\n→ 初始化前处理\n→ 初始化回调\n→ 初始化后处理\n→ 对外提供\n→ 销毁\n",[22,19159,19157],{"__ignoreMap":101},[18,19161,19162,19164,19165,19167],{},[22,19163,19030],{}," 作用于整个容器中的 Bean 定义；",[22,19166,19034],{}," 作用于容器创建的 Bean 实例。两者所处层次不同。",[14,19169,19171],{"id":19170},"二阶段一加载并注册-beandefinition","二、阶段一：加载并注册 BeanDefinition",[18,19173,19174,19176],{},[22,19175,19023],{}," 是 Spring 创建 Bean 的配置模型，记录了：",[114,19178,19179,19182,19185,19188,19191,19194,19197],{},[117,19180,19181],{},"Bean 类型；",[117,19183,19184],{},"作用域；",[117,19186,19187],{},"是否懒加载；",[117,19189,19190],{},"构造参数和属性值；",[117,19192,19193],{},"初始化方法和销毁方法；",[117,19195,19196],{},"依赖关系；",[117,19198,19199],{},"是否允许作为自动注入候选项。",[18,19201,19202],{},"Bean 定义可能来自：",[114,19204,19205,19211,19217,19220,19223],{},[117,19206,19207,19210],{},[22,19208,19209],{},"@Component"," 组件扫描；",[117,19212,19213,19216],{},[22,19214,19215],{},"@Bean"," 方法；",[117,19218,19219],{},"XML；",[117,19221,19222],{},"程序化注册；",[117,19224,19225,19228],{},[22,19226,19227],{},"@Import"," 导入。",[18,19230,19231],{},"这一阶段还没有创建普通业务 Bean，处理的是“如何创建 Bean”的元数据。",[638,19233,19235],{"id":19234},"_1-importselector","1. ImportSelector",[18,19237,19238,19241],{},[22,19239,19240],{},"ImportSelector"," 根据导入类的元数据，返回需要注册的配置类名称。",[18,19243,4130],{},[114,19245,19246,19249,19252],{},[117,19247,19248],{},"按条件组合一组配置；",[117,19250,19251],{},"模块化装配；",[117,19253,19254],{},"框架自动配置入口。",[18,19256,19257,19260],{},[22,19258,19259],{},"DeferredImportSelector"," 会在普通配置类处理之后再决定导入内容，Spring Boot 自动配置大量使用了这类机制。",[638,19262,19264],{"id":19263},"_2-importbeandefinitionregistrar","2. ImportBeanDefinitionRegistrar",[18,19266,19267,19270,19271,4878],{},[22,19268,19269],{},"ImportBeanDefinitionRegistrar"," 可以直接向注册表写入 ",[22,19272,19023],{},[18,19274,4130],{},[114,19276,19277,19280,19283],{},[117,19278,19279],{},"根据注解属性动态注册 Bean；",[117,19281,19282],{},"为接口生成代理 BeanDefinition；",[117,19284,19285],{},"注册数量或名称在编译期不固定的组件。",[638,19287,19289],{"id":19288},"_3-beandefinitionregistrypostprocessor","3. BeanDefinitionRegistryPostProcessor",[18,19291,19292,19293,19295,19296,4039],{},"它是 ",[22,19294,19030],{}," 的子接口，核心能力是操作 ",[22,19297,19298],{},"BeanDefinitionRegistry",[95,19300,19302],{"className":135,"code":19301,"language":137,"meta":101,"style":101},"public interface BeanDefinitionRegistryPostProcessor\n extends BeanFactoryPostProcessor {\n\n void postProcessBeanDefinitionRegistry(\n BeanDefinitionRegistry registry);\n}\n",[22,19303,19304,19314,19324,19328,19338,19348],{"__ignoreMap":101},[141,19305,19306,19308,19311],{"class":143,"line":144},[141,19307,193],{"class":151},[141,19309,19310],{"class":151}," interface",[141,19312,19313],{"class":158}," BeanDefinitionRegistryPostProcessor\n",[141,19315,19316,19319,19322],{"class":143,"line":165},[141,19317,19318],{"class":151}," extends",[141,19320,19321],{"class":158}," BeanFactoryPostProcessor",[141,19323,201],{"class":147},[141,19325,19326],{"class":143,"line":210},[141,19327,207],{"emptyLinePlaceholder":206},[141,19329,19330,19333,19336],{"class":143,"line":219},[141,19331,19332],{"class":151}," void",[141,19334,19335],{"class":158}," postProcessBeanDefinitionRegistry",[141,19337,17073],{"class":147},[141,19339,19340,19343,19346],{"class":143,"line":234},[141,19341,19342],{"class":147}," BeanDefinitionRegistry ",[141,19344,19345],{"class":503},"registry",[141,19347,915],{"class":147},[141,19349,19350],{"class":143,"line":241},[141,19351,250],{"class":147},[18,19353,19354,19355,19357],{},"它可以在普通 ",[22,19356,19030],{}," 执行前：",[114,19359,19360,19363,19366,19369],{},[117,19361,19362],{},"注册新的 BeanDefinition；",[117,19364,19365],{},"删除或替换已有 BeanDefinition；",[117,19367,19368],{},"扫描额外的组件；",[117,19370,19371],{},"根据外部配置动态扩展容器。",[18,19373,19374,19377,19378,44,19381,44,19384,2818,19386,19388],{},[22,19375,19376],{},"ConfigurationClassPostProcessor"," 就是重要实现，它负责解析 ",[22,19379,19380],{},"@Configuration",[22,19382,19383],{},"@ComponentScan",[22,19385,19227],{},[22,19387,19215],{}," 等配置。",[14,19390,19392],{"id":19391},"三阶段二修改-beandefinition","三、阶段二：修改 BeanDefinition",[638,19394,19030],{"id":19395},"beanfactorypostprocessor",[18,19397,19398,19399,4039],{},"所有 BeanDefinition 基本注册完成后，Spring 调用 ",[22,19400,19030],{},[95,19402,19404],{"className":135,"code":19403,"language":137,"meta":101,"style":101},"public interface BeanFactoryPostProcessor {\n\n void postProcessBeanFactory(\n ConfigurableListableBeanFactory beanFactory);\n}\n",[22,19405,19406,19416,19420,19429,19439],{"__ignoreMap":101},[141,19407,19408,19410,19412,19414],{"class":143,"line":144},[141,19409,193],{"class":151},[141,19411,19310],{"class":151},[141,19413,19321],{"class":158},[141,19415,201],{"class":147},[141,19417,19418],{"class":143,"line":165},[141,19419,207],{"emptyLinePlaceholder":206},[141,19421,19422,19424,19427],{"class":143,"line":210},[141,19423,19332],{"class":151},[141,19425,19426],{"class":158}," postProcessBeanFactory",[141,19428,17073],{"class":147},[141,19430,19431,19434,19437],{"class":143,"line":219},[141,19432,19433],{"class":147}," ConfigurableListableBeanFactory ",[141,19435,19436],{"class":503},"beanFactory",[141,19438,915],{"class":147},[141,19440,19441],{"class":143,"line":234},[141,19442,250],{"class":147},[18,19444,19445],{},"它处理的是 BeanDefinition，而不是已经创建好的业务对象。",[18,19447,19448],{},"典型能力包括：",[114,19450,19451,19454,19457,19460,19463],{},[117,19452,19453],{},"修改属性值；",[117,19455,19456],{},"修改作用域和懒加载配置；",[117,19458,19459],{},"调整自动注入候选状态；",[117,19461,19462],{},"解析配置占位符；",[117,19464,19465],{},"注册容器级基础设施。",[18,19467,19468,19469,19472],{},"例如 ",[22,19470,19471],{},"PropertySourcesPlaceholderConfigurer"," 会把：",[95,19474,19476],{"className":4553,"code":19475,"language":4555,"meta":101,"style":101},"order.timeout=${ORDER_TIMEOUT}\n",[22,19477,19478],{"__ignoreMap":101},[141,19479,19480,19483],{"class":143,"line":144},[141,19481,19482],{"class":151},"order.timeout",[141,19484,19485],{"class":147},"=${ORDER_TIMEOUT}\n",[18,19487,19488],{},"中的占位符替换为环境中的实际值。",[18,19490,19491,19492,19495,19496,19498],{},"不要在这个阶段随意调用 ",[22,19493,19494],{},"getBean()","。这会导致普通 Bean 提前创建，使它可能绕过尚未注册完成的 ",[22,19497,19034],{},"，进而错过依赖注入、AOP 等处理。",[14,19500,19502],{"id":19501},"四阶段三注册-beanpostprocessor","四、阶段三：注册 BeanPostProcessor",[18,19504,19505,19506,19508],{},"Spring 会提前创建并注册所有 ",[22,19507,19034],{},"，使它们能够处理后续创建的 Bean。",[18,19510,19511],{},"基础接口如下：",[95,19513,19515],{"className":135,"code":19514,"language":137,"meta":101,"style":101},"public interface BeanPostProcessor {\n\n default Object postProcessBeforeInitialization(\n Object bean, String beanName) {\n return bean;\n }\n\n default Object postProcessAfterInitialization(\n Object bean, String beanName) {\n return bean;\n }\n}\n",[22,19516,19517,19528,19532,19545,19561,19568,19572,19576,19587,19599,19605,19609],{"__ignoreMap":101},[141,19518,19519,19521,19523,19526],{"class":143,"line":144},[141,19520,193],{"class":151},[141,19522,19310],{"class":151},[141,19524,19525],{"class":158}," BeanPostProcessor",[141,19527,201],{"class":147},[141,19529,19530],{"class":143,"line":165},[141,19531,207],{"emptyLinePlaceholder":206},[141,19533,19534,19537,19540,19543],{"class":143,"line":210},[141,19535,19536],{"class":151}," default",[141,19538,19539],{"class":147}," Object ",[141,19541,19542],{"class":158},"postProcessBeforeInitialization",[141,19544,17073],{"class":147},[141,19546,19547,19550,19553,19556,19559],{"class":143,"line":219},[141,19548,19549],{"class":147}," Object ",[141,19551,19552],{"class":503},"bean",[141,19554,19555],{"class":147},", String ",[141,19557,19558],{"class":503},"beanName",[141,19560,507],{"class":147},[141,19562,19563,19565],{"class":143,"line":234},[141,19564,17912],{"class":151},[141,19566,19567],{"class":147}," bean;\n",[141,19569,19570],{"class":143,"line":241},[141,19571,244],{"class":147},[141,19573,19574],{"class":143,"line":247},[141,19575,207],{"emptyLinePlaceholder":206},[141,19577,19578,19580,19582,19585],{"class":143,"line":307},[141,19579,19536],{"class":151},[141,19581,19539],{"class":147},[141,19583,19584],{"class":158},"postProcessAfterInitialization",[141,19586,17073],{"class":147},[141,19588,19589,19591,19593,19595,19597],{"class":143,"line":379},[141,19590,19549],{"class":147},[141,19592,19552],{"class":503},[141,19594,19555],{"class":147},[141,19596,19558],{"class":503},[141,19598,507],{"class":147},[141,19600,19601,19603],{"class":143,"line":391},[141,19602,17912],{"class":151},[141,19604,19567],{"class":147},[141,19606,19607],{"class":143,"line":396},[141,19608,244],{"class":147},[141,19610,19611],{"class":143,"line":401},[141,19612,250],{"class":147},[18,19614,19615],{},"常见功能很多都建立在 BeanPostProcessor 体系上：",[114,19617,19618,19627,19633,19636,19640,19645,19648],{},[117,19619,19620,44,19623,19626],{},[22,19621,19622],{},"@Autowired",[22,19624,19625],{},"@Value"," 注入；",[117,19628,19629,44,19631,2159],{},[22,19630,39],{},[22,19632,19099],{},[117,19634,19635],{},"AOP 自动代理；",[117,19637,19638,2159],{},[22,19639,1287],{},[117,19641,19642,2159],{},[22,19643,19644],{},"@Scheduled",[117,19646,19647],{},"事务代理；",[117,19649,19650],{},"异常转换。",[638,19652,19653],{"id":19653},"执行顺序",[18,19655,19656],{},"多个后处理器通常按照以下优先级排序：",[95,19658,19661],{"className":19659,"code":19660,"language":100,"meta":101},[98],"PriorityOrdered\n→ Ordered\n→ 未实现排序接口\n",[22,19662,19660],{"__ignoreMap":101},[18,19664,19665,19666,19669,19670,4878],{},"程序化调用 ",[22,19667,19668],{},"addBeanPostProcessor()"," 注册时，主要按照实际注册顺序执行，不应只依赖 ",[22,19671,19672],{},"Ordered",[14,19674,19676],{"id":19675},"五阶段四实例化-bean","五、阶段四：实例化 Bean",[18,19678,19679,19680,19683],{},"Spring 在 ",[22,19681,19682],{},"AbstractAutowireCapableBeanFactory#createBean()"," 中进入单个 Bean 的创建流程。",[638,19685,19687],{"id":19686},"_1-实例化前扩展","1. 实例化前扩展",[18,19689,19690,19692],{},[22,19691,19065],{}," 在目标对象真正实例化前执行。",[18,19694,19695],{},"它可以直接返回一个对象，例如代理：",[95,19697,19700],{"className":19698,"code":19699,"language":100,"meta":101},[98],"返回 null\n→ 继续正常实例化流程\n\n返回非 null\n→ 跳过普通实例化、属性填充和初始化流程\n→ 对返回对象执行初始化后处理\n",[22,19701,19699],{"__ignoreMap":101},[18,19703,19704],{},"这属于特殊扩展点，主要用于框架基础设施，不适合承载普通业务初始化。",[638,19706,19708],{"id":19707},"_2-为什么同时存在两个-before-回调","2. 为什么同时存在两个 Before 回调",[18,19710,19711,2818,19714,19717],{},[22,19712,19713],{},"postProcessBeforeInstantiation()",[22,19715,19716],{},"postProcessBeforeInitialization()"," 名称相似，但位置、作用和接收到的参数完全不同：",[1309,19719,19720,19736],{},[1312,19721,19722],{},[1315,19723,19724,19727,19730,19733],{},[1318,19725,19726],{},"回调",[1318,19728,19729],{},"所属接口",[1318,19731,19732],{},"执行位置",[1318,19734,19735],{},"此时原 Bean 是否存在",[1328,19737,19738,19755],{},[1315,19739,19740,19744,19749,19752],{},[1333,19741,19742],{},[22,19743,19713],{},[1333,19745,19746],{},[22,19747,19748],{},"InstantiationAwareBeanPostProcessor",[1333,19750,19751],{},"构造方法或工厂方法执行前",[1333,19753,19754],{},"不存在",[1315,19756,19757,19761,19765,19768],{},[1333,19758,19759],{},[22,19760,19716],{},[1333,19762,19763],{},[22,19764,19034],{},[1333,19766,19767],{},"实例化、属性填充和 Aware 回调之后，初始化方法之前",[1333,19769,19770],{},"已经存在",[18,19772,19773],{},"正常创建路径如下：",[95,19775,19778],{"className":19776,"code":19777,"language":100,"meta":101},[98],"postProcessBeforeInstantiation 返回 null\n→ 选择构造方法并实例化\n→ postProcessAfterInstantiation\n→ postProcessProperties\n→ 属性填充\n→ Aware 回调\n→ postProcessBeforeInitialization\n → @PostConstruct\n→ afterPropertiesSet\n→ 自定义 init-method\n→ postProcessAfterInitialization\n",[22,19779,19777],{"__ignoreMap":101},[18,19781,19782],{},"短路路径则是：",[95,19784,19787],{"className":19785,"code":19786,"language":100,"meta":101},[98],"postProcessBeforeInstantiation 返回非 null 对象\n→ 跳过原 Bean 的实例化、属性填充和初始化\n→ 对返回对象执行 postProcessAfterInitialization\n→ 返回对象成为最终 Bean\n",[22,19788,19786],{"__ignoreMap":101},[18,19790,19791,19792,19795],{},"下面的处理器会在 ",[22,19793,19794],{},"GreetingServiceImpl"," 实例化之前直接返回一个 JDK 动态代理：",[95,19797,19799],{"className":135,"code":19798,"language":137,"meta":101,"style":101},"@Component\npublic class GreetingInstantiationPostProcessor\n implements InstantiationAwareBeanPostProcessor {\n\n @Override\n public Object postProcessBeforeInstantiation(\n Class\u003C?> beanClass,\n String beanName) {\n\n if (beanClass != GreetingServiceImpl.class) {\n return null;\n }\n\n return Proxy.newProxyInstance(\n beanClass.getClassLoader(),\n beanClass.getInterfaces(),\n (proxy, method, args) -> {\n if (\"hello\".equals(method.getName())) {\n return \"hello from proxy\";\n }\n return null;\n });\n }\n}\n",[22,19800,19801,19808,19817,19827,19831,19837,19848,19864,19873,19877,19890,19899,19903,19907,19919,19930,19939,19948,19971,19981,19986,19995,20000,20004],{"__ignoreMap":101},[141,19802,19803,19805],{"class":143,"line":144},[141,19804,263],{"class":147},[141,19806,19807],{"class":151},"Component\n",[141,19809,19810,19812,19814],{"class":143,"line":165},[141,19811,193],{"class":151},[141,19813,196],{"class":151},[141,19815,19816],{"class":158}," GreetingInstantiationPostProcessor\n",[141,19818,19819,19822,19825],{"class":143,"line":210},[141,19820,19821],{"class":151}," implements",[141,19823,19824],{"class":158}," InstantiationAwareBeanPostProcessor",[141,19826,201],{"class":147},[141,19828,19829],{"class":143,"line":219},[141,19830,207],{"emptyLinePlaceholder":206},[141,19832,19833,19835],{"class":143,"line":234},[141,19834,213],{"class":147},[141,19836,1668],{"class":151},[141,19838,19839,19841,19843,19846],{"class":143,"line":241},[141,19840,222],{"class":151},[141,19842,19539],{"class":147},[141,19844,19845],{"class":158},"postProcessBeforeInstantiation",[141,19847,17073],{"class":147},[141,19849,19850,19853,19856,19859,19862],{"class":143,"line":247},[141,19851,19852],{"class":147}," Class\u003C",[141,19854,19855],{"class":151},"?",[141,19857,19858],{"class":147},"> ",[141,19860,19861],{"class":503},"beanClass",[141,19863,13814],{"class":147},[141,19865,19866,19869,19871],{"class":143,"line":307},[141,19867,19868],{"class":147}," String ",[141,19870,19558],{"class":503},[141,19872,507],{"class":147},[141,19874,19875],{"class":143,"line":379},[141,19876,207],{"emptyLinePlaceholder":206},[141,19878,19879,19882,19885,19887],{"class":143,"line":391},[141,19880,19881],{"class":151}," if",[141,19883,19884],{"class":147}," (beanClass ",[141,19886,4702],{"class":151},[141,19888,19889],{"class":147}," GreetingServiceImpl.class) {\n",[141,19891,19892,19895,19897],{"class":143,"line":396},[141,19893,19894],{"class":151}," return",[141,19896,4705],{"class":428},[141,19898,8560],{"class":147},[141,19900,19901],{"class":143,"line":401},[141,19902,18114],{"class":147},[141,19904,19905],{"class":143,"line":554},[141,19906,207],{"emptyLinePlaceholder":206},[141,19908,19909,19911,19914,19917],{"class":143,"line":559},[141,19910,17912],{"class":151},[141,19912,19913],{"class":147}," Proxy.",[141,19915,19916],{"class":158},"newProxyInstance",[141,19918,17073],{"class":147},[141,19920,19921,19924,19927],{"class":143,"line":564},[141,19922,19923],{"class":147}," beanClass.",[141,19925,19926],{"class":158},"getClassLoader",[141,19928,19929],{"class":147},"(),\n",[141,19931,19932,19934,19937],{"class":143,"line":571},[141,19933,19923],{"class":147},[141,19935,19936],{"class":158},"getInterfaces",[141,19938,19929],{"class":147},[141,19940,19941,19944,19946],{"class":143,"line":583},[141,19942,19943],{"class":147}," (proxy, method, args) ",[141,19945,4689],{"class":151},[141,19947,201],{"class":147},[141,19949,19950,19953,19955,19958,19960,19963,19966,19968],{"class":143,"line":588},[141,19951,19952],{"class":151}," if",[141,19954,4965],{"class":147},[141,19956,19957],{"class":911},"\"hello\"",[141,19959,431],{"class":147},[141,19961,19962],{"class":158},"equals",[141,19964,19965],{"class":147},"(method.",[141,19967,17880],{"class":158},[141,19969,19970],{"class":147},"())) {\n",[141,19972,19973,19976,19979],{"class":143,"line":595},[141,19974,19975],{"class":151}," return",[141,19977,19978],{"class":911}," \"hello from proxy\"",[141,19980,8560],{"class":147},[141,19982,19983],{"class":143,"line":606},[141,19984,19985],{"class":147}," }\n",[141,19987,19988,19991,19993],{"class":143,"line":611},[141,19989,19990],{"class":151}," return",[141,19992,4705],{"class":428},[141,19994,8560],{"class":147},[141,19996,19997],{"class":143,"line":616},[141,19998,19999],{"class":147}," });\n",[141,20001,20002],{"class":143,"line":17909},[141,20003,244],{"class":147},[141,20005,20006],{"class":143,"line":17918},[141,20007,250],{"class":147},[18,20009,8834,20010,20012,20013,20016,20017,20019],{},[22,20011,19794],{}," 实现了 ",[22,20014,20015],{},"GreetingService"," 接口，那么容器最终保存的是代理对象，原类的构造方法和 ",[22,20018,39],{}," 都不会执行。使用 JDK 动态代理时应通过接口类型获取或注入该 Bean，不能把最终对象强制转换为实现类。",[18,20021,20022,20023,20025],{},"如果这个方法返回 ",[22,20024,19069],{},"，Spring才会继续创建原对象：",[95,20027,20029],{"className":135,"code":20028,"language":137,"meta":101,"style":101},"@Override\npublic Object postProcessBeforeInstantiation(\n Class\u003C?> beanClass,\n String beanName) {\n\n System.out.println(\"实例化前：\" + beanName);\n return null;\n}\n",[22,20030,20031,20037,20047,20058,20063,20067,20083,20092],{"__ignoreMap":101},[141,20032,20033,20035],{"class":143,"line":144},[141,20034,263],{"class":147},[141,20036,1668],{"class":151},[141,20038,20039,20041,20043,20045],{"class":143,"line":165},[141,20040,193],{"class":151},[141,20042,19539],{"class":147},[141,20044,19845],{"class":158},[141,20046,17073],{"class":147},[141,20048,20049,20052,20055],{"class":143,"line":210},[141,20050,20051],{"class":147}," Class",[141,20053,20054],{"class":151},"\u003C?>",[141,20056,20057],{"class":147}," beanClass,\n",[141,20059,20060],{"class":143,"line":219},[141,20061,20062],{"class":147}," String beanName) {\n",[141,20064,20065],{"class":143,"line":234},[141,20066,207],{"emptyLinePlaceholder":206},[141,20068,20069,20071,20073,20075,20078,20080],{"class":143,"line":241},[141,20070,3225],{"class":147},[141,20072,3194],{"class":158},[141,20074,908],{"class":147},[141,20076,20077],{"class":911},"\"实例化前：\"",[141,20079,17837],{"class":151},[141,20081,20082],{"class":147}," beanName);\n",[141,20084,20085,20088,20090],{"class":143,"line":247},[141,20086,20087],{"class":151}," return",[141,20089,4705],{"class":428},[141,20091,8560],{"class":147},[141,20093,20094],{"class":143,"line":307},[141,20095,250],{"class":147},[18,20097,20098,20099,20101],{},"还要注意，普通 Spring AOP 通常在 ",[22,20100,19058],{}," 中创建代理。实例化前直接返回代理属于特殊的短路能力，不能把它理解为所有 AOP 代理的常规创建位置。",[638,20103,20105],{"id":20104},"_3-instantiationawarebeanpostprocessor-不只在实例化前工作","3. InstantiationAwareBeanPostProcessor 不只在实例化前工作",[18,20107,20108],{},"这个接口名称表示它能够感知 Bean 的实例化过程，但它的回调分布在多个阶段：",[1309,20110,20111,20121],{},[1312,20112,20113],{},[1315,20114,20115,20118],{},[1318,20116,20117],{},"方法",[1318,20119,20120],{},"执行阶段",[1328,20122,20123,20132,20142,20152,20162],{},[1315,20124,20125,20129],{},[1333,20126,20127],{},[22,20128,19713],{},[1333,20130,20131],{},"目标对象实例化前",[1315,20133,20134,20139],{},[1333,20135,20136],{},[22,20137,20138],{},"postProcessAfterInstantiation()",[1333,20140,20141],{},"目标对象实例化后、属性填充前",[1315,20143,20144,20149],{},[1333,20145,20146],{},[22,20147,20148],{},"postProcessProperties()",[1333,20150,20151],{},"属性填充阶段",[1315,20153,20154,20159],{},[1333,20155,20156,20157],{},"继承的 ",[22,20158,19716],{},[1333,20160,20161],{},"初始化方法前",[1315,20163,20164,20168],{},[1333,20165,20156,20166],{},[22,20167,19058],{},[1333,20169,20170],{},"初始化方法后",[18,20172,20173,20174,20176],{},"因此，准确的说法不是“",[22,20175,19748],{}," 只在实例化前执行”，而是“它提供了实例化前、实例化后和属性填充阶段的扩展能力，同时继承了 BeanPostProcessor 的初始化前后回调”。",[638,20178,20180],{"id":20179},"_4-选择构造方法","4. 选择构造方法",[18,20182,20183],{},"Spring需要决定使用：",[114,20185,20186,20189,20192,20197,20200],{},[117,20187,20188],{},"默认构造方法；",[117,20190,20191],{},"显式指定的构造方法；",[117,20193,20194,20196],{},[22,20195,19622],{}," 构造方法；",[117,20198,20199],{},"工厂方法；",[117,20201,20202,4878],{},[22,20203,20204],{},"Supplier",[18,20206,20207,20210],{},[22,20208,20209],{},"SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors()"," 可以参与候选构造方法选择。",[638,20212,20214],{"id":20213},"_5-创建原始对象","5. 创建原始对象",[18,20216,20217],{},"构造方法或工厂方法执行完成后，得到的是原始 Bean 实例。此时依赖属性通常还没有填充，初始化回调也没有执行。",[14,20219,20221],{"id":20220},"六阶段五处理合并后的-beandefinition","六、阶段五：处理合并后的 BeanDefinition",[18,20223,20224],{},"父子 BeanDefinition、配置覆盖和类型解析完成后，Spring 得到合并后的 BeanDefinition。",[18,20226,20227,20230],{},[22,20228,20229],{},"MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition()"," 可以缓存与具体 Bean 类型有关的元数据。",[18,20232,20233],{},"常见用途包括：",[114,20235,20236,20239,20242],{},[117,20237,20238],{},"扫描注入点；",[117,20240,20241],{},"缓存注解元数据；",[117,20243,20244],{},"为后续属性注入和销毁处理做准备。",[18,20246,20247,20250,20251,44,20253,20255],{},[22,20248,20249],{},"AutowiredAnnotationBeanPostProcessor"," 会在这里分析 ",[22,20252,19622],{},[22,20254,19625],{}," 等注入信息，避免每次都重新反射扫描。",[14,20257,20259],{"id":20258},"七阶段六提前暴露引用","七、阶段六：提前暴露引用",[18,20261,20262],{},"对于允许循环依赖处理的单例，Spring可能在属性填充前暴露一个对象工厂：",[95,20264,20267],{"className":20265,"code":20266,"language":100,"meta":101},[98],"singletonFactories\n→ earlySingletonObjects\n→ singletonObjects\n",[22,20268,20266],{"__ignoreMap":101},[18,20270,20271],{},"这里暴露的不是“已经完成初始化的 Bean”，而是用于打破依赖环的早期引用。",[18,20273,20274,20277],{},[22,20275,20276],{},"SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference()"," 可以决定早期暴露什么对象。AOP 自动代理创建器会利用这个扩展点，尽量让循环依赖中的其他 Bean 获得代理引用，而不是直接获得原始对象。",[18,20279,4629],{},[114,20281,20282,20285,20288,20291],{},[117,20283,20284],{},"这主要处理单例的属性或 Setter 注入循环依赖；",[117,20286,20287],{},"构造器循环依赖无法靠提前暴露一个尚未构造完成的对象解决；",[117,20289,20290],{},"原型 Bean 的循环依赖也不能通过三级缓存解决；",[117,20292,20293],{},"不应把三级缓存当成设计循环依赖的理由。",[14,20295,20297],{"id":20296},"八阶段七属性填充与依赖注入","八、阶段七：属性填充与依赖注入",[18,20299,20300,20301,20304],{},"实例创建后，Spring进入 ",[22,20302,20303],{},"populateBean()","，为对象填充依赖。",[18,20306,20307,20309,20310,20312,20313,20315],{},[22,20308,20303],{}," 是这一阶段的主流程入口，不要把它与 ",[22,20311,20148],{}," 混为一谈。前者负责组织整个属性填充阶段，后者只是 ",[22,20314,19748],{}," 在该阶段提供的扩展回调。其主要调用关系可以简化为：",[95,20317,20320],{"className":20318,"code":20319,"language":100,"meta":101},[98],"populateBean\n├── postProcessAfterInstantiation\n├── postProcessProperties\n└── 应用 BeanDefinition 中配置的属性值\n",[22,20321,20319],{"__ignoreMap":101},[638,20323,20325],{"id":20324},"_1-postprocessafterinstantiation","1. postProcessAfterInstantiation",[18,20327,20328,20331],{},[22,20329,20330],{},"InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation()"," 在对象已经实例化、属性填充尚未开始时执行。",[18,20333,18548,20334,20337],{},[22,20335,20336],{},"false"," 可以阻止 Spring继续执行常规属性填充，因此属于影响较大的底层扩展点。",[638,20339,20341],{"id":20340},"_2-postprocessproperties","2. postProcessProperties",[18,20343,20344,20347],{},[22,20345,20346],{},"InstantiationAwareBeanPostProcessor#postProcessProperties()"," 可以处理属性注入。",[18,20349,20350],{},"典型实现：",[114,20352,20353,20362],{},[117,20354,20355,20357,20358,2818,20360,2159],{},[22,20356,20249],{},"：处理 ",[22,20359,19622],{},[22,20361,19625],{},[117,20363,20364,20357,20366,20369],{},[22,20365,19095],{},[22,20367,20368],{},"@Resource"," 等 Jakarta 注解。",[18,20371,20372],{},"随后 Spring还会应用 BeanDefinition 中显式配置的属性值。",[14,20374,20376],{"id":20375},"九阶段八aware-回调","九、阶段八：Aware 回调",[18,20378,20379],{},"依赖注入完成后，Spring让 Bean 感知容器提供的基础设施。",[18,20381,20382],{},"常见接口包括：",[1309,20384,20385,20395],{},[1312,20386,20387],{},[1315,20388,20389,20392],{},[1318,20390,20391],{},"Aware 接口",[1318,20393,20394],{},"能够获得的对象",[1328,20396,20397,20407,20417,20427,20437,20447,20457],{},[1315,20398,20399,20404],{},[1333,20400,20401],{},[22,20402,20403],{},"BeanNameAware",[1333,20405,20406],{},"当前 Bean 名称",[1315,20408,20409,20414],{},[1333,20410,20411],{},[22,20412,20413],{},"BeanClassLoaderAware",[1333,20415,20416],{},"Bean 类加载器",[1315,20418,20419,20424],{},[1333,20420,20421],{},[22,20422,20423],{},"BeanFactoryAware",[1333,20425,20426],{},"当前 BeanFactory",[1315,20428,20429,20434],{},[1333,20430,20431],{},[22,20432,20433],{},"EnvironmentAware",[1333,20435,20436],{},"Environment",[1315,20438,20439,20444],{},[1333,20440,20441],{},[22,20442,20443],{},"ApplicationEventPublisherAware",[1333,20445,20446],{},"事件发布器",[1315,20448,20449,20454],{},[1333,20450,20451],{},[22,20452,20453],{},"ResourceLoaderAware",[1333,20455,20456],{},"资源加载器",[1315,20458,20459,20464],{},[1333,20460,20461],{},[22,20462,20463],{},"ApplicationContextAware",[1333,20465,20466],{},"ApplicationContext",[18,20468,20469,20470,20472,20473,20476],{},"前三个由 BeanFactory 初始化流程直接调用；",[22,20471,20463],{}," 等接口通常由 ",[22,20474,20475],{},"ApplicationContextAwareProcessor"," 这个 BeanPostProcessor 处理。",[18,20478,20479],{},"Aware 适合获取容器基础设施，但会让业务类与 Spring 接口耦合。普通业务依赖仍应优先采用构造器注入。",[14,20481,20483],{"id":20482},"十阶段九初始化前处理","十、阶段九：初始化前处理",[18,20485,20486],{},"Spring依次调用所有：",[95,20488,20490],{"className":135,"code":20489,"language":137,"meta":101,"style":101},"BeanPostProcessor#postProcessBeforeInitialization()\n",[22,20491,20492],{"__ignoreMap":101},[141,20493,20494,20497,20499],{"class":143,"line":144},[141,20495,20496],{"class":147},"BeanPostProcessor#",[141,20498,19542],{"class":158},[141,20500,1184],{"class":147},[18,20502,20233],{},[114,20504,20505,20508,20511,20514],{},[117,20506,20507],{},"识别并执行生命周期注解；",[117,20509,20510],{},"对 Bean 做初始化前检查；",[117,20512,20513],{},"注入容器上下文相关能力；",[117,20515,20516],{},"包装或替换 Bean。",[638,20518,20520],{"id":20519},"postconstruct-在哪里执行","@PostConstruct 在哪里执行",[18,20522,20523,20525,20526,20528],{},[22,20524,39],{}," 不是 Spring硬编码在初始化流程中的独立步骤，而是由 ",[22,20527,19095],{}," 在初始化前处理阶段识别并调用。",[18,20530,20531],{},"因此从宏观顺序看：",[95,20533,20536],{"className":20534,"code":20535,"language":100,"meta":101},[98],"Aware 回调\n→ postProcessBeforeInitialization\n → @PostConstruct\n→ InitializingBean\n→ 自定义 init-method\n",[22,20537,20535],{"__ignoreMap":101},[14,20539,20541],{"id":20540},"十一阶段十执行初始化回调","十一、阶段十：执行初始化回调",[18,20543,20544],{},"同一个 Bean 同时使用多种初始化机制且方法名不同时，调用顺序是：",[2489,20546,20547,20551,20555],{},[117,20548,20549,2159],{},[22,20550,39],{},[117,20552,20553,2159],{},[22,20554,19050],{},[117,20556,20557,20560,20561,4878],{},[22,20558,20559],{},"@Bean(initMethod = \"...\")"," 或 XML ",[22,20562,19054],{},[18,20564,3163],{},[95,20566,20568],{"className":135,"code":20567,"language":137,"meta":101,"style":101},"public class PaymentClient implements InitializingBean {\n\n @PostConstruct\n public void validateConfiguration() {\n \u002F\u002F 校验配置\n }\n\n @Override\n public void afterPropertiesSet() {\n \u002F\u002F Spring 接口回调\n }\n\n public void init() {\n \u002F\u002F 自定义初始化方法\n }\n}\n",[22,20569,20570,20586,20590,20596,20607,20612,20616,20620,20626,20637,20642,20646,20650,20660,20665,20669],{"__ignoreMap":101},[141,20571,20572,20574,20576,20579,20581,20584],{"class":143,"line":144},[141,20573,193],{"class":151},[141,20575,196],{"class":151},[141,20577,20578],{"class":158}," PaymentClient",[141,20580,1653],{"class":151},[141,20582,20583],{"class":158}," InitializingBean",[141,20585,201],{"class":147},[141,20587,20588],{"class":143,"line":165},[141,20589,207],{"emptyLinePlaceholder":206},[141,20591,20592,20594],{"class":143,"line":210},[141,20593,213],{"class":147},[141,20595,782],{"class":151},[141,20597,20598,20600,20602,20605],{"class":143,"line":219},[141,20599,222],{"class":151},[141,20601,225],{"class":151},[141,20603,20604],{"class":158}," validateConfiguration",[141,20606,231],{"class":147},[141,20608,20609],{"class":143,"line":234},[141,20610,20611],{"class":237}," \u002F\u002F 校验配置\n",[141,20613,20614],{"class":143,"line":241},[141,20615,244],{"class":147},[141,20617,20618],{"class":143,"line":247},[141,20619,207],{"emptyLinePlaceholder":206},[141,20621,20622,20624],{"class":143,"line":307},[141,20623,213],{"class":147},[141,20625,1668],{"class":151},[141,20627,20628,20630,20632,20635],{"class":143,"line":379},[141,20629,222],{"class":151},[141,20631,225],{"class":151},[141,20633,20634],{"class":158}," afterPropertiesSet",[141,20636,231],{"class":147},[141,20638,20639],{"class":143,"line":391},[141,20640,20641],{"class":237}," \u002F\u002F Spring 接口回调\n",[141,20643,20644],{"class":143,"line":396},[141,20645,244],{"class":147},[141,20647,20648],{"class":143,"line":401},[141,20649,207],{"emptyLinePlaceholder":206},[141,20651,20652,20654,20656,20658],{"class":143,"line":554},[141,20653,222],{"class":151},[141,20655,225],{"class":151},[141,20657,791],{"class":158},[141,20659,231],{"class":147},[141,20661,20662],{"class":143,"line":559},[141,20663,20664],{"class":237}," \u002F\u002F 自定义初始化方法\n",[141,20666,20667],{"class":143,"line":564},[141,20668,244],{"class":147},[141,20670,20671],{"class":143,"line":571},[141,20672,250],{"class":147},[18,20674,20675],{},"配置：",[95,20677,20679],{"className":135,"code":20678,"language":137,"meta":101,"style":101},"@Bean(initMethod = \"init\", destroyMethod = \"close\")\npublic PaymentClient paymentClient() {\n return new PaymentClient();\n}\n",[22,20680,20681,20710,20722,20732],{"__ignoreMap":101},[141,20682,20683,20685,20688,20690,20693,20695,20698,20700,20703,20705,20708],{"class":143,"line":144},[141,20684,263],{"class":147},[141,20686,20687],{"class":151},"Bean",[141,20689,908],{"class":147},[141,20691,20692],{"class":428},"initMethod",[141,20694,946],{"class":151},[141,20696,20697],{"class":911}," \"init\"",[141,20699,4981],{"class":147},[141,20701,20702],{"class":428},"destroyMethod",[141,20704,946],{"class":151},[141,20706,20707],{"class":911}," \"close\"",[141,20709,1481],{"class":147},[141,20711,20712,20714,20717,20720],{"class":143,"line":165},[141,20713,193],{"class":151},[141,20715,20716],{"class":147}," PaymentClient ",[141,20718,20719],{"class":158},"paymentClient",[141,20721,231],{"class":147},[141,20723,20724,20726,20728,20730],{"class":143,"line":210},[141,20725,20087],{"class":151},[141,20727,155],{"class":151},[141,20729,20578],{"class":158},[141,20731,162],{"class":147},[141,20733,20734],{"class":143,"line":219},[141,20735,250],{"class":147},[18,20737,20738,20739,20741],{},"业务代码通常优先选择 ",[22,20740,39],{}," 或自定义初始化方法，避免为了生命周期回调而强耦合 Spring 接口。",[18,20743,20744],{},"初始化方法适合：",[114,20746,20747,20750,20753],{},[117,20748,20749],{},"校验必要配置；",[117,20751,20752],{},"构造只依赖当前 Bean 状态的内存结构；",[117,20754,20755],{},"完成本地资源准备。",[18,20757,20758],{},"不适合在初始化方法中启动复杂异步任务，或者访问大量其他 Bean。初始化发生在单例创建过程中，过重或存在交叉访问的逻辑可能延长启动时间，甚至引发初始化死锁。",[14,20760,20762],{"id":20761},"十二阶段十一初始化后处理与-aop-代理","十二、阶段十一：初始化后处理与 AOP 代理",[18,20764,20765],{},"初始化回调完成后，Spring调用：",[95,20767,20769],{"className":135,"code":20768,"language":137,"meta":101,"style":101},"BeanPostProcessor#postProcessAfterInitialization()\n",[22,20770,20771],{"__ignoreMap":101},[141,20772,20773,20775,20777],{"class":143,"line":144},[141,20774,20496],{"class":147},[141,20776,19584],{"class":158},[141,20778,1184],{"class":147},[18,20780,20781],{},"后处理器可以返回：",[114,20783,20784,20787,20790,20793],{},[117,20785,20786],{},"原对象；",[117,20788,20789],{},"包装对象；",[117,20791,20792],{},"代理对象；",[117,20794,20795],{},"其他兼容对象。",[18,20797,20798,20799,20801],{},"Spring AOP 的自动代理创建器属于 ",[22,20800,19034],{},"。它会判断当前 Bean 是否匹配 Advisor；如果匹配，就创建 JDK 动态代理或 CGLIB 代理。",[18,20803,20804],{},"因此容器最终对外暴露的对象可能不是原始对象：",[95,20806,20809],{"className":20807,"code":20808,"language":100,"meta":101},[98],"原始 Bean\n→ 初始化回调\n→ AOP 后处理器\n→ 代理 Bean\n→ singletonObjects\n",[22,20810,20808],{"__ignoreMap":101},[18,20812,20813,20814,20816,20817,20819],{},"这也解释了为什么在 ",[22,20815,39],{}," 中调用自身的事务方法，通常不会经过当前 Bean 的事务代理：初始化回调执行时，完整代理尚未作为最终 Bean 对外提供，而且调用方式仍然是对象内部的 ",[22,20818,35],{}," 调用。",[14,20821,20823],{"id":20822},"十三bean-初始化完成后容器何时才算就绪","十三、Bean 初始化完成后，容器何时才算就绪",[18,20825,20826],{},"单个 Bean 完成初始化，并不代表所有单例都已经创建完成。",[638,20828,20830],{"id":20829},"_1-smartinitializingsingleton","1. SmartInitializingSingleton",[18,20832,20833],{},"所有常规非懒加载单例完成实例化后，Spring调用：",[95,20835,20837],{"className":135,"code":20836,"language":137,"meta":101,"style":101},"public interface SmartInitializingSingleton {\n\n void afterSingletonsInstantiated();\n}\n",[22,20838,20839,20850,20854,20863],{"__ignoreMap":101},[141,20840,20841,20843,20845,20848],{"class":143,"line":144},[141,20842,193],{"class":151},[141,20844,19310],{"class":151},[141,20846,20847],{"class":158}," SmartInitializingSingleton",[141,20849,201],{"class":147},[141,20851,20852],{"class":143,"line":165},[141,20853,207],{"emptyLinePlaceholder":206},[141,20855,20856,20858,20861],{"class":143,"line":210},[141,20857,19332],{"class":151},[141,20859,20860],{"class":158}," afterSingletonsInstantiated",[141,20862,162],{"class":147},[141,20864,20865],{"class":143,"line":219},[141,20866,250],{"class":147},[18,20868,4130],{},[114,20870,20871,20874,20877],{},[117,20872,20873],{},"需要确认其他单例已经准备完成的检查；",[117,20875,20876],{},"汇总多个 Bean 建立注册表；",[117,20878,20879,20880,20883],{},"避免因为主动 ",[22,20881,20882],{},"getBeansOfType()"," 导致意外提前初始化。",[18,20885,20886],{},"它只对单例 Bean 有意义。",[638,20888,20890],{"id":20889},"_2-contextrefreshedevent","2. ContextRefreshedEvent",[18,20892,20893,20894,4878],{},"容器刷新完成后会发布 ",[22,20895,19083],{},[18,20897,20898],{},"可以使用：",[95,20900,20902],{"className":135,"code":20901,"language":137,"meta":101,"style":101},"@EventListener(ContextRefreshedEvent.class)\npublic void onContextReady() {\n \u002F\u002F 容器刷新完成后的逻辑\n}\n",[22,20903,20904,20914,20925,20930],{"__ignoreMap":101},[141,20905,20906,20908,20911],{"class":143,"line":144},[141,20907,263],{"class":147},[141,20909,20910],{"class":151},"EventListener",[141,20912,20913],{"class":147},"(ContextRefreshedEvent.class)\n",[141,20915,20916,20918,20920,20923],{"class":143,"line":165},[141,20917,193],{"class":151},[141,20919,225],{"class":151},[141,20921,20922],{"class":158}," onContextReady",[141,20924,231],{"class":147},[141,20926,20927],{"class":143,"line":210},[141,20928,20929],{"class":237}," \u002F\u002F 容器刷新完成后的逻辑\n",[141,20931,20932],{"class":143,"line":219},[141,20933,250],{"class":147},[18,20935,20936],{},"适合需要基于 ApplicationContext 刷新完成事件触发的逻辑。",[18,20938,20939],{},"需要注意，ApplicationContext 可以被刷新多次时，监听逻辑也可能执行多次，业务代码应考虑幂等。",[638,20941,20943],{"id":20942},"_3-smartlifecycle","3. SmartLifecycle",[18,20945,20946,20947,4039],{},"需要启动和停止后台消费者、调度器、长连接等有运行状态的组件时，优先考虑 ",[22,20948,19087],{},[95,20950,20952],{"className":135,"code":20951,"language":137,"meta":101,"style":101},"public interface SmartLifecycle extends Lifecycle, Phased {\n\n boolean isAutoStartup();\n\n void stop(Runnable callback);\n}\n",[22,20953,20954,20976,20980,20990,20994,21008],{"__ignoreMap":101},[141,20955,20956,20958,20960,20963,20966,20969,20971,20974],{"class":143,"line":144},[141,20957,193],{"class":151},[141,20959,19310],{"class":151},[141,20961,20962],{"class":158}," SmartLifecycle",[141,20964,20965],{"class":151}," extends",[141,20967,20968],{"class":158}," Lifecycle",[141,20970,4981],{"class":147},[141,20972,20973],{"class":158},"Phased",[141,20975,201],{"class":147},[141,20977,20978],{"class":143,"line":165},[141,20979,207],{"emptyLinePlaceholder":206},[141,20981,20982,20985,20988],{"class":143,"line":210},[141,20983,20984],{"class":151}," boolean",[141,20986,20987],{"class":158}," isAutoStartup",[141,20989,162],{"class":147},[141,20991,20992],{"class":143,"line":219},[141,20993,207],{"emptyLinePlaceholder":206},[141,20995,20996,20998,21001,21003,21006],{"class":143,"line":234},[141,20997,19332],{"class":151},[141,20999,21000],{"class":158}," stop",[141,21002,18056],{"class":147},[141,21004,21005],{"class":503},"callback",[141,21007,915],{"class":147},[141,21009,21010],{"class":143,"line":241},[141,21011,250],{"class":147},[18,21013,21014],{},"它支持：",[114,21016,21017,21020,21026,21029],{},[117,21018,21019],{},"容器刷新后自动启动；",[117,21021,21022,21025],{},[22,21023,21024],{},"phase"," 控制启动和停止顺序；",[117,21027,21028],{},"异步停止完成回调；",[117,21030,21031],{},"运行状态检查。",[18,21033,21034,21035,21037],{},"启动时通常先启动较小的 ",[22,21036,21024],{},"，关闭时反向停止。依赖其他组件的服务应根据依赖关系设计 phase，而不是随意填写。",[14,21039,21041],{"id":21040},"十四阶段十二容器关闭与-bean-销毁","十四、阶段十二：容器关闭与 Bean 销毁",[18,21043,21044],{},"容器正常关闭时，Spring先停止需要运行期管理的 Lifecycle 组件，再销毁受管理的单例 Bean。",[18,21046,21047],{},"同一个 Bean 配置多种销毁机制且方法名不同时，可以按下面的层次理解：",[2489,21049,21050,21060,21064],{},[117,21051,21052,19092,21055,21057,21058,2159],{},[22,21053,21054],{},"DestructionAwareBeanPostProcessor#postProcessBeforeDestruction()",[22,21056,19095],{}," 调用 ",[22,21059,19099],{},[117,21061,21062,2159],{},[22,21063,19103],{},[117,21065,21066,20560,21069,4878],{},[22,21067,21068],{},"@Bean(destroyMethod = \"...\")",[22,21070,21071],{},"destroy-method",[18,21073,14275,21074,21076,21077,21079],{},[22,21075,19099],{}," 不是脱离后处理器单独运行的一轮流程，而是 ",[22,21078,19091],{}," 体系提供的具体生命周期回调。",[18,21081,21082],{},"销毁阶段适合：",[114,21084,21085,21088,21091,21094,21097],{},[117,21086,21087],{},"停止后台任务；",[117,21089,21090],{},"关闭线程池；",[117,21092,21093],{},"关闭网络连接；",[117,21095,21096],{},"刷新缓冲数据；",[117,21098,21099],{},"注销服务或监听器。",[638,21101,21103],{"id":21102},"原型-bean-的特殊点","原型 Bean 的特殊点",[18,21105,21106,21107,21110],{},"对于 ",[22,21108,21109],{},"prototype"," Bean，Spring负责创建和注入，但把实例交给调用方后通常不再跟踪其完整生命周期，因此不会自动调用普通销毁回调。",[18,21112,21113],{},"如果原型 Bean 持有必须释放的资源，应由使用方显式关闭，或者改用更合适的作用域和资源管理方式。",[18,21115,21116,21117,21119],{},"应用被强制终止时，销毁回调也不保证一定执行。重要数据不能只依赖 ",[22,21118,19099],{}," 才落盘。",[14,21121,21123],{"id":21122},"十五常见扩展点应该怎么选择","十五、常见扩展点应该怎么选择",[1309,21125,21126,21135],{},[1312,21127,21128],{},[1315,21129,21130,21132],{},[1318,21131,6425],{},[1318,21133,21134],{},"优先考虑的扩展点",[1328,21136,21137,21148,21159,21168,21178,21189,21201,21210,21220,21229,21240,21250],{},[1315,21138,21139,21142],{},[1333,21140,21141],{},"导入一组配置类",[1333,21143,21144,44,21146],{},[22,21145,19240],{},[22,21147,19259],{},[1315,21149,21150,21153],{},[1333,21151,21152],{},"动态注册 BeanDefinition",[1333,21154,21155,44,21157],{},[22,21156,19269],{},[22,21158,19026],{},[1315,21160,21161,21164],{},[1333,21162,21163],{},"在创建 Bean 前修改配置元数据",[1333,21165,21166],{},[22,21167,19030],{},[1315,21169,21170,21173],{},[1333,21171,21172],{},"自定义注入、实例化或代理",[1333,21174,21175,21177],{},[22,21176,19034],{}," 及其子接口",[1315,21179,21180,21183],{},[1333,21181,21182],{},"获得 Bean 名称或容器对象",[1333,21184,21185,21186,21188],{},"对应的 ",[22,21187,19041],{}," 接口",[1315,21190,21191,21194],{},[1333,21192,21193],{},"依赖注入完成后校验当前 Bean",[1333,21195,21196,21198,21199],{},[22,21197,39],{}," 或自定义 ",[22,21200,20692],{},[1315,21202,21203,21206],{},[1333,21204,21205],{},"所有普通单例创建完成后执行",[1333,21207,21208],{},[22,21209,19079],{},[1315,21211,21212,21215],{},[1333,21213,21214],{},"容器刷新完成后执行",[1333,21216,21217,21218],{},"监听 ",[22,21219,19083],{},[1315,21221,21222,21225],{},[1333,21223,21224],{},"管理后台组件的启动和停止",[1333,21226,21227],{},[22,21228,19087],{},[1315,21230,21231,21234],{},[1333,21232,21233],{},"释放 Bean 自身资源",[1333,21235,21236,21198,21238],{},[22,21237,19099],{},[22,21239,20702],{},[1315,21241,21242,21245],{},[1333,21243,21244],{},"创建复杂对象并把产物交给容器",[1333,21246,21247],{},[22,21248,21249],{},"FactoryBean",[1315,21251,21252,21255],{},[1333,21253,21254],{},"定义新的 Bean 作用域",[1333,21256,21257,21258,21261],{},"实现 ",[22,21259,21260],{},"Scope"," 并注册",[14,21263,21265],{"id":21264},"十六factorybean-是什么扩展点","十六、FactoryBean 是什么扩展点",[18,21267,21268,21269,21272],{},"普通 BeanDefinition 描述“这个类本身如何被创建”；",[22,21270,21271],{},"FactoryBean\u003CT>"," 描述“通过这个工厂生产什么对象”。",[95,21274,21276],{"className":135,"code":21275,"language":137,"meta":101,"style":101},"public interface FactoryBean\u003CT> {\n\n T getObject() throws Exception;\n\n Class\u003C?> getObjectType();\n\n default boolean isSingleton() {\n return true;\n }\n}\n",[22,21277,21278,21295,21299,21315,21319,21333,21337,21349,21358,21362],{"__ignoreMap":101},[141,21279,21280,21282,21284,21287,21289,21292],{"class":143,"line":144},[141,21281,193],{"class":151},[141,21283,19310],{"class":151},[141,21285,21286],{"class":158}," FactoryBean",[141,21288,3101],{"class":147},[141,21290,21291],{"class":151},"T",[141,21293,21294],{"class":147},"> {\n",[141,21296,21297],{"class":143,"line":165},[141,21298,207],{"emptyLinePlaceholder":206},[141,21300,21301,21304,21307,21309,21312],{"class":143,"line":210},[141,21302,21303],{"class":147}," T ",[141,21305,21306],{"class":158},"getObject",[141,21308,16196],{"class":147},[141,21310,21311],{"class":151},"throws",[141,21313,21314],{"class":147}," Exception;\n",[141,21316,21317],{"class":143,"line":219},[141,21318,207],{"emptyLinePlaceholder":206},[141,21320,21321,21324,21326,21328,21331],{"class":143,"line":234},[141,21322,21323],{"class":147}," Class\u003C",[141,21325,19855],{"class":151},[141,21327,19858],{"class":147},[141,21329,21330],{"class":158},"getObjectType",[141,21332,162],{"class":147},[141,21334,21335],{"class":143,"line":241},[141,21336,207],{"emptyLinePlaceholder":206},[141,21338,21339,21341,21344,21347],{"class":143,"line":247},[141,21340,19536],{"class":151},[141,21342,21343],{"class":151}," boolean",[141,21345,21346],{"class":158}," isSingleton",[141,21348,231],{"class":147},[141,21350,21351,21353,21356],{"class":143,"line":307},[141,21352,17912],{"class":151},[141,21354,21355],{"class":428}," true",[141,21357,8560],{"class":147},[141,21359,21360],{"class":143,"line":379},[141,21361,244],{"class":147},[141,21363,21364],{"class":143,"line":391},[141,21365,250],{"class":147},[18,21367,21368,21369,4039],{},"假设 Bean 名称为 ",[22,21370,21371],{},"clientFactory",[95,21373,21376],{"className":21374,"code":21375,"language":100,"meta":101},[98],"getBean(\"clientFactory\")\n→ 获得 FactoryBean 生产的对象\n\ngetBean(\"&clientFactory\")\n→ 获得 FactoryBean 本身\n",[22,21377,21375],{"__ignoreMap":101},[18,21379,21380,21381,21384],{},"它适合创建代理、客户端、会话工厂等构造过程复杂的对象。MyBatis 与 Spring 集成中的 ",[22,21382,21383],{},"SqlSessionFactoryBean"," 就使用了这一机制。",[14,21386,21388],{"id":21387},"十七自定义-scope","十七、自定义 Scope",[18,21390,21391],{},"默认常见作用域包括：",[114,21393,21394,21399,21403],{},[117,21395,21396,2159],{},[22,21397,21398],{},"singleton",[117,21400,21401,2159],{},[22,21402,21109],{},[117,21404,21405,21406,44,21409,44,21412,44,21415,4878],{},"Web 环境中的 ",[22,21407,21408],{},"request",[22,21410,21411],{},"session",[22,21413,21414],{},"application",[22,21416,21417],{},"websocket",[18,21419,21257,21420,21423,21424,21427],{},[22,21421,21422],{},"org.springframework.beans.factory.config.Scope"," 并通过 ",[22,21425,21426],{},"ConfigurableBeanFactory#registerScope()"," 注册，可以定义租户、任务、线程上下文等自定义作用域。",[18,21429,21430],{},"自定义 Scope 必须明确：",[114,21432,21433,21436,21439,21442,21445],{},[117,21434,21435],{},"实例保存在哪里；",[117,21437,21438],{},"何时创建和复用；",[117,21440,21441],{},"上下文结束时如何执行销毁回调；",[117,21443,21444],{},"上下文如何跨线程传播；",[117,21446,21447],{},"作用域 Bean 被单例依赖时是否需要代理。",[14,21449,21451],{"id":21450},"十八常见误区","十八、常见误区",[638,21453,21455],{"id":21454},"_1-bean-构造完成就可以使用","1. Bean 构造完成就可以使用",[18,21457,21458],{},"构造完成后还没有完成属性注入、Aware、初始化回调和后处理，不能把构造完成等同于 Bean 就绪。",[638,21460,21462],{"id":21461},"_2-postconstruct-发生在-aop-代理之后","2. @PostConstruct 发生在 AOP 代理之后",[18,21464,21465,21467],{},[22,21466,39],{}," 属于初始化前处理阶段；AOP 代理通常在初始化后处理中形成并作为最终对象暴露。",[638,21469,21471],{"id":21470},"_3-beanpostprocessor-只在初始化前后各做一次简单回调","3. BeanPostProcessor 只在初始化前后各做一次简单回调",[18,21473,21474],{},"基础接口只有两个方法，但其子接口参与实例化前、构造器选择、属性填充、早期代理、合并定义和销毁等多个阶段。",[638,21476,21478],{"id":21477},"_4-beanfactorypostprocessor-可以直接修改业务-bean","4. BeanFactoryPostProcessor 可以直接修改业务 Bean",[18,21480,21481,21482,21484],{},"它应该修改 BeanDefinition。调用 ",[22,21483,19494],{}," 可能造成提前实例化并绕过其他基础设施。",[638,21486,21488],{"id":21487},"_5-bean-生命周期结束一定会执行销毁方法","5. Bean 生命周期结束一定会执行销毁方法",[18,21490,21491],{},"原型 Bean、进程强杀、机器掉电等场景都可能无法执行正常销毁回调。",[638,21493,21495],{"id":21494},"_6-所有初始化逻辑都放进-postconstruct","6. 所有初始化逻辑都放进 @PostConstruct",[18,21497,21498,21499,21501,21502,21504,21505,4878],{},"Bean 自身的轻量校验可以放在 ",[22,21500,39],{},"；依赖所有单例完成、容器刷新完成或需要启停管理的任务，应分别选择 ",[22,21503,19079],{},"、容器事件或 ",[22,21506,19087],{},[14,21508,21510],{"id":21509},"十九源码主线","十九、源码主线",[18,21512,21513],{},"阅读 Spring Bean 生命周期源码时，可以沿着以下调用链：",[95,21515,21518],{"className":21516,"code":21517,"language":100,"meta":101},[98],"AbstractApplicationContext#refresh\n├── invokeBeanFactoryPostProcessors\n├── registerBeanPostProcessors\n├── finishBeanFactoryInitialization\n│ └── preInstantiateSingletons\n│ └── getBean\n│ └── AbstractAutowireCapableBeanFactory#createBean\n│ ├── resolveBeforeInstantiation\n│ │ ├── applyBeanPostProcessorsBeforeInstantiation\n│ │ └── applyBeanPostProcessorsAfterInitialization\n│ │ （仅在实例化前返回非 null 对象时）\n│ └── doCreateBean\n│ ├── createBeanInstance\n│ ├── applyMergedBeanDefinitionPostProcessors\n│ ├── addSingletonFactory\n│ ├── populateBean\n│ └── initializeBean\n│ ├── invokeAwareMethods\n│ ├── applyBeanPostProcessorsBeforeInitialization\n│ ├── invokeInitMethods\n│ └── applyBeanPostProcessorsAfterInitialization\n└── finishRefresh\n",[22,21519,21517],{"__ignoreMap":101},[18,21521,21522],{},"销毁主线可以关注：",[95,21524,21527],{"className":21525,"code":21526,"language":100,"meta":101},[98],"AbstractApplicationContext#close\n→ doClose\n→ LifecycleProcessor#onClose\n→ destroyBeans\n→ DisposableBeanAdapter#destroy\n",[22,21528,21526],{"__ignoreMap":101},[14,21530,21532],{"id":21531},"二十复习检查清单","二十、复习检查清单",[114,21534,21535,21538,21546,21549,21558,21561,21568,21571,21579,21582],{},[117,21536,21537],{},"能否区分容器生命周期和单个 Bean 生命周期；",[117,21539,21540,21541,6242,21543,21545],{},"能否说明 ",[22,21542,19030],{},[22,21544,19034],{}," 的区别；",[117,21547,21548],{},"是否知道依赖注入发生在实例化之后、初始化之前；",[117,21550,21551,21552,44,21554,21557],{},"能否说清 ",[22,21553,39],{},[22,21555,21556],{},"InitializingBean","、自定义 init 方法的顺序；",[117,21559,21560],{},"是否知道 AOP 代理通常在哪个阶段创建；",[117,21562,21563,21564,21567],{},"能否解释三级缓存和 ",[22,21565,21566],{},"getEarlyBeanReference()"," 的作用；",[117,21569,21570],{},"是否知道单个 Bean 初始化完成后还有哪些容器级扩展点；",[117,21572,21540,21573,21575,21576,21578],{},[22,21574,19079],{},"、容器事件和 ",[22,21577,19087],{}," 的使用边界；",[117,21580,21581],{},"是否知道销毁回调的顺序以及原型 Bean 的限制；",[117,21583,21584],{},"能否按目标选择定义级、实例级、运行级和销毁级扩展点。",[14,21586,5605],{"id":5605},[114,21588,21589,21596,21603,21610,21617],{},[117,21590,21591],{},[73,21592,21595],{"href":21593,"rel":21594},"https:\u002F\u002Fdocs.spring.io\u002Fspring-framework\u002Freference\u002Fcore\u002Fbeans\u002Ffactory-extension.html",[1876],"Spring Framework：Container Extension Points",[117,21597,21598],{},[73,21599,21602],{"href":21600,"rel":21601},"https:\u002F\u002Fdocs.spring.io\u002Fspring-framework\u002Freference\u002Fcore\u002Fbeans\u002Ffactory-nature.html",[1876],"Spring Framework：Customizing the Nature of a Bean",[117,21604,21605],{},[73,21606,21609],{"href":21607,"rel":21608},"https:\u002F\u002Fdocs.spring.io\u002Fspring-framework\u002Freference\u002Fcore\u002Fbeans\u002Fbeanfactory.html",[1876],"Spring Framework：The BeanFactory API",[117,21611,21612],{},[73,21613,21616],{"href":21614,"rel":21615},"https:\u002F\u002Fdocs.spring.io\u002Fspring-framework\u002Fdocs\u002Fcurrent\u002Fjavadoc-api\u002Forg\u002Fspringframework\u002Fbeans\u002Ffactory\u002Fconfig\u002FInstantiationAwareBeanPostProcessor.html",[1876],"InstantiationAwareBeanPostProcessor API",[117,21618,21619],{},[73,21620,21623],{"href":21621,"rel":21622},"https:\u002F\u002Fdocs.spring.io\u002Fspring-framework\u002Fdocs\u002Fcurrent\u002Fjavadoc-api\u002Forg\u002Fspringframework\u002Fbeans\u002Ffactory\u002FSmartInitializingSingleton.html",[1876],"SmartInitializingSingleton API",[1907,21625,21626],{},"html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html pre.shiki code .s4XuR, html code.shiki .s4XuR{--shiki-default:#E36209;--shiki-dark:#FFAB70}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}html pre.shiki code .sJ8bj, html code.shiki .sJ8bj{--shiki-default:#6A737D;--shiki-dark:#6A737D}",{"title":101,"searchDepth":165,"depth":165,"links":21628},[21629,21630,21631,21632,21636,21641,21644,21647,21654,21655,21656,21660,21661,21664,21665,21666,21671,21674,21675,21676,21677,21685,21686,21687],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":19129,"depth":165,"text":19130,"children":21633},[21634,21635],{"id":19136,"depth":210,"text":19137},{"id":19149,"depth":210,"text":19150},{"id":19170,"depth":165,"text":19171,"children":21637},[21638,21639,21640],{"id":19234,"depth":210,"text":19235},{"id":19263,"depth":210,"text":19264},{"id":19288,"depth":210,"text":19289},{"id":19391,"depth":165,"text":19392,"children":21642},[21643],{"id":19395,"depth":210,"text":19030},{"id":19501,"depth":165,"text":19502,"children":21645},[21646],{"id":19653,"depth":210,"text":19653},{"id":19675,"depth":165,"text":19676,"children":21648},[21649,21650,21651,21652,21653],{"id":19686,"depth":210,"text":19687},{"id":19707,"depth":210,"text":19708},{"id":20104,"depth":210,"text":20105},{"id":20179,"depth":210,"text":20180},{"id":20213,"depth":210,"text":20214},{"id":20220,"depth":165,"text":20221},{"id":20258,"depth":165,"text":20259},{"id":20296,"depth":165,"text":20297,"children":21657},[21658,21659],{"id":20324,"depth":210,"text":20325},{"id":20340,"depth":210,"text":20341},{"id":20375,"depth":165,"text":20376},{"id":20482,"depth":165,"text":20483,"children":21662},[21663],{"id":20519,"depth":210,"text":20520},{"id":20540,"depth":165,"text":20541},{"id":20761,"depth":165,"text":20762},{"id":20822,"depth":165,"text":20823,"children":21667},[21668,21669,21670],{"id":20829,"depth":210,"text":20830},{"id":20889,"depth":210,"text":20890},{"id":20942,"depth":210,"text":20943},{"id":21040,"depth":165,"text":21041,"children":21672},[21673],{"id":21102,"depth":210,"text":21103},{"id":21122,"depth":165,"text":21123},{"id":21264,"depth":165,"text":21265},{"id":21387,"depth":165,"text":21388},{"id":21450,"depth":165,"text":21451,"children":21678},[21679,21680,21681,21682,21683,21684],{"id":21454,"depth":210,"text":21455},{"id":21461,"depth":210,"text":21462},{"id":21470,"depth":210,"text":21471},{"id":21477,"depth":210,"text":21478},{"id":21487,"depth":210,"text":21488},{"id":21494,"depth":210,"text":21495},{"id":21509,"depth":165,"text":21510},{"id":21531,"depth":165,"text":21532},{"id":5605,"depth":165,"text":5605},"wiki:java:spring-bean-lifecycle-and-extension-points","系统讲解 Spring 容器启动、Bean 定义处理、实例化、属性注入、初始化、AOP 代理、就绪与销毁的完整生命周期，并梳理 BeanFactoryPostProcessor、BeanPostProcessor、Aware、初始化回调、SmartInitializingSingleton、事件和 SmartLifecycle 等扩展点。",{},80,"\u002Fjava\u002Fspring-bean-lifecycle-and-extension-points",{"title":19004,"description":21689},"java\u002Fspring-bean-lifecycle-and-extension-points","ZtXQ8TCnwPnWeee0oKnQyksLUPgWGyb866r_87O5X4Q",{"id":21697,"title":21698,"body":21699,"commentId":23098,"description":23099,"difficulty":3462,"draft":1943,"extension":1944,"meta":23100,"navigation":206,"order":23101,"path":23102,"section":1948,"seo":23103,"stem":23104,"updated":23105,"__hash__":23106},"java\u002Fjava\u002Fjava-oom-troubleshooting.md","如果系统出现 OOM，应该如何处理？",{"type":7,"value":21700,"toc":23050},[21701,21704,21706,21709,21735,21738,21740,21747,21749,21758,21760,21764,21770,21773,21863,21870,21874,21877,21894,21897,21900,21904,21908,21911,21937,21941,21944,21950,21953,21956,21962,21965,21969,21972,21975,21981,21984,21990,21993,21997,22084,22087,22093,22096,22119,22127,22130,22134,22137,22141,22151,22155,22158,22164,22167,22173,22178,22182,22185,22191,22195,22199,22202,22228,22231,22234,22236,22259,22265,22279,22285,22288,22292,22295,22319,22322,22325,22328,22348,22351,22357,22361,22364,22367,22384,22394,22401,22405,22431,22435,22438,22441,22455,22458,22462,22465,22485,22487,22521,22524,22530,22533,22537,22540,22542,22564,22567,22587,22590,22594,22597,22630,22633,22660,22663,22667,22670,22687,22690,22694,22755,22758,22762,22765,22782,22785,22802,22805,22822,22825,22829,22832,22855,22858,22862,22866,22880,22883,22906,22914,22917,22934,22938,22942,22945,22949,22952,22956,22959,22963,22966,22970,22973,22977,23015,23017,23047],[10,21702,21698],{"id":21703},"如果系统出现-oom应该如何处理",[14,21705,16],{"id":16},[18,21707,21708],{},"系统发生 OOM 后，我会先止损并保留现场，而不是立即反复重启。首先确认影响范围，通过摘除故障实例、切换流量、限流或关闭非核心功能保护系统；同时保存 OOM 错误、应用日志、GC 日志、Heap Dump、容器事件和监控数据。证据保存完成后，再由进程托管系统重启或扩容恢复服务。",[18,21710,21711,21712,2818,21715,21718,21719,21722,21723,21726,21727,21730,21731,21734],{},"然后根据错误类型确定排查方向。",[22,21713,21714],{},"Java heap space",[22,21716,21717],{},"GC overhead limit exceeded"," 重点分析堆；",[22,21720,21721],{},"Metaspace"," 重点检查类数量和 ClassLoader；",[22,21724,21725],{},"Direct buffer memory"," 重点检查直接内存和 Netty\u002FNIO Buffer；",[22,21728,21729],{},"unable to create native thread"," 重点检查线程数量、线程栈、系统限制和进程原生内存；容器出现 ",[22,21732,21733],{},"OOMKilled"," 时，还要检查进程 RSS、容器内存限制以及堆外内存，因为它不一定会留下 Java OOM。",[18,21736,21737],{},"堆内存问题通常使用 Heap Dump、对象直方图和 GC 日志分析。重点查看占用最大的对象、Retained Size、Dominator Tree 和到 GC Roots 的引用链，并结合关键 GC 周期后老年代基线是否持续增长，区分内存泄漏、正常容量不足和单次超大对象分配。使用 G1 时，应重点观察并发标记及随后一系列 Mixed GC 完成后的老年代占用。修复后需要用相同流量模型验证内存能否回落、GC 是否恢复正常，同时补齐自动 Dump、GC 日志、内存分区监控和容量告警。",[18,21739,57],{},[59,21741,21742],{},[18,21743,21744],{},[64,21745,21746],{},"OOM 处理的主线是先止损、再留证、按内存区域分类定位，最后区分泄漏、容量不足和异常大对象，并通过同等流量验证修复。",[14,21748,69],{"id":69},[18,21750,21751],{},[73,21752,21755],{"href":21753,"target":76,"rel":21754},"\u002Fimages\u002Fwiki\u002Fjava\u002Fjava-oom-troubleshooting.svg",[78,79],[81,21756],{"src":21753,"alt":21757},"Java OOM 止损、留证、分类定位、修复验证与预防流程",[14,21759,86],{"id":86},[14,21761,21763],{"id":21762},"一oom-不等于-java-堆内存泄漏","一、OOM 不等于 Java 堆内存泄漏",[18,21765,21766,21769],{},[22,21767,21768],{},"OutOfMemoryError"," 表示 JVM 无法满足某次资源申请，但发生问题的资源不一定是 Java 堆，也不一定存在泄漏。",[18,21771,21772],{},"常见类型如下：",[1309,21774,21775,21785],{},[1312,21776,21777],{},[1315,21778,21779,21782],{},[1318,21780,21781],{},"错误信息",[1318,21783,21784],{},"主要排查方向",[1328,21786,21787,21796,21805,21814,21824,21833,21842,21852],{},[1315,21788,21789,21793],{},[1333,21790,21791],{},[22,21792,21714],{},[1333,21794,21795],{},"堆容量不足、对象泄漏、瞬时大对象",[1315,21797,21798,21802],{},[1333,21799,21800],{},[22,21801,21717],{},[1333,21803,21804],{},"堆长期接近耗尽，GC 频繁但回收效果很差",[1315,21806,21807,21811],{},[1333,21808,21809],{},[22,21810,21721],{},[1333,21812,21813],{},"类元数据过多、ClassLoader 泄漏、动态生成类失控",[1315,21815,21816,21821],{},[1333,21817,21818],{},[22,21819,21820],{},"Compressed class space",[1333,21822,21823],{},"压缩类指针空间不足",[1315,21825,21826,21830],{},[1333,21827,21828],{},[22,21829,21725],{},[1333,21831,21832],{},"NIO、Netty 等直接内存申请过多或释放不及时",[1315,21834,21835,21839],{},[1333,21836,21837],{},[22,21838,21729],{},[1333,21840,21841],{},"线程过多、线程栈占用过大、系统线程限制或原生内存不足",[1315,21843,21844,21849],{},[1333,21845,21846],{},[22,21847,21848],{},"Requested array size exceeds VM limit",[1333,21850,21851],{},"代码尝试创建超过 JVM 限制的超大数组",[1315,21853,21854,21860],{},[1333,21855,21856,21857,21859],{},"容器 ",[22,21858,21733],{},"、退出码 137",[1333,21861,21862],{},"进程总内存超过容器限制，不一定出现 Java OOM",[18,21864,21865,21866,21869],{},"因此，第一步不是直接调大 ",[22,21867,21868],{},"-Xmx","，而是先确认错误类型和耗尽的内存区域。",[14,21871,21873],{"id":21872},"二第一阶段先止损","二、第一阶段：先止损",[18,21875,21876],{},"线上故障首先要控制影响范围：",[2489,21878,21879,21882,21885,21888,21891],{},[117,21880,21881],{},"从负载均衡中摘除异常实例，避免继续接收新流量；",[117,21883,21884],{},"有健康副本时切换流量或临时扩容；",[117,21886,21887],{},"对非核心接口限流、熔断或降级；",[117,21889,21890],{},"暂停可能持续放大内存的批处理、消费任务或大查询；",[117,21892,21893],{},"确认现场信息已经保存后，再重启异常实例。",[18,21895,21896],{},"是否立即重启取决于可用性和取证条件。如果服务已经不可用，并且有自动生成的 Heap Dump、GC 日志和监控数据，可以尽快重启恢复；如果没有任何证据且仍能安全操作，应先保留必要现场。",[18,21898,21899],{},"不要让已经发生严重 OOM 的进程长期勉强提供服务。此时进程可能持续 Full GC、请求超时，甚至无法创建用于自救的新线程。",[14,21901,21903],{"id":21902},"三第二阶段保留现场","三、第二阶段：保留现场",[638,21905,21907],{"id":21906},"_1-记录基本信息","1. 记录基本信息",[18,21909,21910],{},"至少保存：",[114,21912,21913,21916,21919,21922,21925,21928,21931,21934],{},[117,21914,21915],{},"完整 OOM 错误和调用栈；",[117,21917,21918],{},"故障时间、实例、版本和流量变化；",[117,21920,21921],{},"JVM 启动参数；",[117,21923,21924],{},"GC 日志；",[117,21926,21927],{},"Heap Dump；",[117,21929,21930],{},"堆、元空间、直接内存、线程数和进程 RSS 监控；",[117,21932,21933],{},"容器事件、退出原因和内存限制；",[117,21935,21936],{},"故障前后的发布、配置和任务变更。",[638,21938,21940],{"id":21939},"_2-提前配置自动-heap-dump","2. 提前配置自动 Heap Dump",[18,21942,21943],{},"生产环境应在启动时配置：",[95,21945,21948],{"className":21946,"code":21947,"language":100,"meta":101},[98],"-XX:+HeapDumpOnOutOfMemoryError\n-XX:HeapDumpPath=\u002Fdata\u002Fdumps\n",[22,21949,21947],{"__ignoreMap":101},[18,21951,21952],{},"Dump 目录必须有足够空间和写权限，并有清理策略。Heap Dump 可能包含用户数据、令牌或业务字段，下载和保存时要遵守数据安全要求。",[18,21954,21955],{},"对于由进程托管系统负责自动拉起的无状态服务，可以评估：",[95,21957,21960],{"className":21958,"code":21959,"language":100,"meta":101},[98],"-XX:+ExitOnOutOfMemoryError\n",[22,21961,21959],{"__ignoreMap":101},[18,21963,21964],{},"它让 JVM 在 OOM 后退出，由 Kubernetes、systemd 等外部系统重启。是否使用取决于服务容灾能力，不能替代现场保留和根因修复。",[638,21966,21968],{"id":21967},"_3-gc-日志由谁生成","3. GC 日志由谁生成",[18,21970,21971],{},"GC 日志由 JVM 生成，不需要在业务代码中手动打印，但必须通过 JVM 启动参数提前开启。应用使用的 Logback、Log4j 等日志框架不会自动记录完整 GC 日志。",[18,21973,21974],{},"JDK 9 及以上可以使用统一日志参数：",[95,21976,21979],{"className":21977,"code":21978,"language":100,"meta":101},[98],"-Xlog:gc*:file=\u002Fdata\u002Flogs\u002Fgc.log:time,uptime,level,tags:filecount=10,filesize=100M\n",[22,21980,21978],{"__ignoreMap":101},[18,21982,21983],{},"JDK 8 常见配置为：",[95,21985,21988],{"className":21986,"code":21987,"language":100,"meta":101},[98],"-XX:+PrintGCDetails\n-XX:+PrintGCDateStamps\n-Xloggc:\u002Fdata\u002Flogs\u002Fgc.log\n",[22,21989,21987],{"__ignoreMap":101},[18,21991,21992],{},"如果故障发生前没有开启，就无法在事后补回完整的历史 GC 日志，只能结合监控、Heap Dump、JFR 或其他现场信息分析。",[638,21994,21996],{"id":21995},"_4-常用诊断命令","4. 常用诊断命令",[95,21998,22000],{"className":7782,"code":21999,"language":7784,"meta":101,"style":101},"jcmd \u003Cpid> VM.flags\njcmd \u003Cpid> GC.heap_info\njcmd \u003Cpid> GC.class_histogram\njcmd \u003Cpid> Thread.print\njcmd \u003Cpid> GC.heap_dump \u002Fdata\u002Fdumps\u002Fapp.hprof\n",[22,22001,22002,22021,22036,22051,22066],{"__ignoreMap":101},[141,22003,22004,22007,22010,22013,22016,22018],{"class":143,"line":144},[141,22005,22006],{"class":158},"jcmd",[141,22008,22009],{"class":151}," \u003C",[141,22011,22012],{"class":911},"pi",[141,22014,22015],{"class":147},"d",[141,22017,9174],{"class":151},[141,22019,22020],{"class":911}," VM.flags\n",[141,22022,22023,22025,22027,22029,22031,22033],{"class":143,"line":165},[141,22024,22006],{"class":158},[141,22026,22009],{"class":151},[141,22028,22012],{"class":911},[141,22030,22015],{"class":147},[141,22032,9174],{"class":151},[141,22034,22035],{"class":911}," GC.heap_info\n",[141,22037,22038,22040,22042,22044,22046,22048],{"class":143,"line":210},[141,22039,22006],{"class":158},[141,22041,22009],{"class":151},[141,22043,22012],{"class":911},[141,22045,22015],{"class":147},[141,22047,9174],{"class":151},[141,22049,22050],{"class":911}," GC.class_histogram\n",[141,22052,22053,22055,22057,22059,22061,22063],{"class":143,"line":219},[141,22054,22006],{"class":158},[141,22056,22009],{"class":151},[141,22058,22012],{"class":911},[141,22060,22015],{"class":147},[141,22062,9174],{"class":151},[141,22064,22065],{"class":911}," Thread.print\n",[141,22067,22068,22070,22072,22074,22076,22078,22081],{"class":143,"line":234},[141,22069,22006],{"class":158},[141,22071,22009],{"class":151},[141,22073,22012],{"class":911},[141,22075,22015],{"class":147},[141,22077,9174],{"class":151},[141,22079,22080],{"class":911}," GC.heap_dump",[141,22082,22083],{"class":911}," \u002Fdata\u002Fdumps\u002Fapp.hprof\n",[18,22085,22086],{},"原生内存跟踪需要在 JVM 启动时开启：",[95,22088,22091],{"className":22089,"code":22090,"language":100,"meta":101},[98],"-XX:NativeMemoryTracking=summary\n",[22,22092,22090],{"__ignoreMap":101},[18,22094,22095],{},"开启后可以查看：",[95,22097,22099],{"className":7782,"code":22098,"language":7784,"meta":101,"style":101},"jcmd \u003Cpid> VM.native_memory summary\n",[22,22100,22101],{"__ignoreMap":101},[141,22102,22103,22105,22107,22109,22111,22113,22116],{"class":143,"line":144},[141,22104,22006],{"class":158},[141,22106,22009],{"class":151},[141,22108,22012],{"class":911},[141,22110,22015],{"class":147},[141,22112,9174],{"class":151},[141,22114,22115],{"class":911}," VM.native_memory",[141,22117,22118],{"class":911}," summary\n",[59,22120,22121],{},[18,22122,22123,22126],{},[64,22124,22125],{},"NMT（Native Memory Tracking）"," 是 HotSpot 提供的原生内存跟踪能力，用于统计 JVM 在堆外为类元数据、线程、代码缓存、GC 等模块申请的原生内存。它需要在启动时开启，且不能覆盖所有第三方原生库的内存分配。",[18,22128,22129],{},"在线执行对象直方图或 Heap Dump 可能引起停顿和大量磁盘 I\u002FO。操作前要确认磁盘空间、实例影响和可用副本，优先使用 OOM 时自动生成的 Dump。",[14,22131,22133],{"id":22132},"四先判断是-jvm-oom还是容器-oomkilled","四、先判断是 JVM OOM，还是容器 OOMKilled",[18,22135,22136],{},"这两类问题经常被混淆。",[638,22138,22140],{"id":22139},"jvm-oom","JVM OOM",[18,22142,22143,22144,22146,22147,22150],{},"JVM 自己发现某个资源无法继续分配，通常会在日志中出现具体的 ",[22,22145,21768],{},"。如果配置了自动 Dump，可能生成 ",[22,22148,22149],{},".hprof"," 文件。",[638,22152,22154],{"id":22153},"容器-oomkilled","容器 OOMKilled",[18,22156,22157],{},"当进程总内存超过容器的 cgroup 限制时，操作系统可能直接杀掉进程。Kubernetes 中常见现象是：",[95,22159,22162],{"className":22160,"code":22161,"language":100,"meta":101},[98],"Reason: OOMKilled\nExit Code: 137\n",[22,22163,22161],{"__ignoreMap":101},[18,22165,22166],{},"这时进程可能来不及抛出 Java OOM，也可能没有 Heap Dump。容器计算的是进程总内存，不只是 Java 堆：",[95,22168,22171],{"className":22169,"code":22170,"language":100,"meta":101},[98],"进程总内存\n≈ Java Heap\n+ Metaspace\n+ Direct Memory\n+ 线程栈\n+ Code Cache\n+ JVM 原生结构\n+ 共享库和其他映射\n",[22,22172,22170],{"__ignoreMap":101},[18,22174,4060,22175,22177],{},[22,22176,21868],{}," 几乎等于容器内存上限，即使堆没有耗尽，也可能因为堆外空间、线程栈或 JVM 自身开销触发 OOMKilled。",[14,22179,22181],{"id":22180},"五java-heap-space-如何分析","五、Java Heap Space 如何分析",[18,22183,22184],{},"堆 OOM 通常要回答三个问题：",[95,22186,22189],{"className":22187,"code":22188,"language":100,"meta":101},[98],"谁占用了内存？\n为什么没有被回收？\n占用是持续增长，还是一次性突增？\n",[22,22190,22188],{"__ignoreMap":101},[638,22192,22194],{"id":22193},"_1-按垃圾收集器分析-gc-趋势","1. 按垃圾收集器分析 GC 趋势",[6264,22196,22198],{"id":22197},"g1重点观察并发标记和-mixed-gc","G1：重点观察并发标记和 Mixed GC",[18,22200,22201],{},"G1 的正常回收链路不是简单地等待一次 Full GC，而是在年轻代回收之外，周期性地完成老年代存活分析和增量空间回收：",[2489,22203,22204,22210,22216,22222],{},[117,22205,22206,22209],{},[64,22207,22208],{},"并发标记","：统计对象的存活情况，为判断哪些老年代 Region 具有回收价值提供依据；",[117,22211,22212,22215],{},[64,22213,22214],{},"Remark","：在 Stop-The-World 停顿中完成标记，处理引用和类卸载等工作，并根据存活数据确定老年代候选 Region；",[117,22217,22218,22221],{},[64,22219,22220],{},"Cleanup","：完成候选 Region 的整理和排序，并决定是否进入空间回收阶段；",[117,22223,22224,22227],{},[64,22225,22226],{},"Mixed GC","：每次都回收本次年轻代 Region，同时从候选集合中选择部分老年代 Region 一起回收。",[18,22229,22230],{},"因此，Mixed GC 的 Collection Set 同时包含年轻代 Region 和部分老年代候选 Region。“老年代候选 Region”是并发标记、Remark 和 Cleanup 这条链路产生的；普通年轻代 Region 不需要由 Remark 从中筛选，而是在每次 Young GC 或 Mixed GC 构建 Collection Set 时按年轻代回收规则加入。",[18,22232,22233],{},"分析 G1 时，应观察一轮完整的并发标记及后续一系列 Mixed GC，而不是只看某一次 Young GC。",[18,22235,13569],{},[114,22237,22238,22241,22244,22247,22250,22253,22256],{},[117,22239,22240],{},"Young GC 是否越来越频繁、停顿时间是否持续增长；",[117,22242,22243],{},"并发标记周期是否能够及时启动并正常完成；",[117,22245,22246],{},"一系列 Mixed GC 完成后，老年代 Region 占用能否明显回落；",[117,22248,22249],{},"老年代回收后的内存基线是否持续上升；",[117,22251,22252],{},"Humongous Region 是否持续增加；",[117,22254,22255],{},"GC 日志中是否出现 Evacuation Failure 或 To-space exhausted；",[117,22257,22258],{},"空间持续不足后是否触发 Full GC。",[18,22260,22261,22264],{},[22,22262,22263],{},"Evacuation Failure"," 表示 G1 在回收期间未能把部分存活对象迁移到目标 Region。常见原因包括：",[114,22266,22267,22273],{},[117,22268,22269,22272],{},[22,22270,22271],{},"Allocation","：找不到足够的目标空间容纳待迁移对象；",[117,22274,22275,22278],{},[22,22276,22277],{},"Pinned","：对象因 JNI 等原因被固定，暂时不能移动。",[18,22280,22281,22284],{},[22,22282,22283],{},"To-space exhausted"," 是较早版本 GC 日志中的常见描述，表示用于接收存活对象的空闲 Region 不足，可以理解为 Evacuation Failure 的一种空间不足表现。",[18,22286,22287],{},"出现一次 Evacuation Failure 并不代表 G1 会立即执行 Full GC。G1 可以保留未完成迁移的 Region，并在后续 GC 中继续处理；如果堆空间持续紧张，GC 最终仍无法释放足够空间，G1 才会调度一次 Stop-The-World 的 Full GC，对整个堆进行压缩。因此更准确的说法是“空间持续不足后触发 Full GC”，而不是“G1 退化为 Full GC”。",[6264,22289,22291],{"id":22290},"cms重点观察并发周期和老年代回收结果","CMS：重点观察并发周期和老年代回收结果",[18,22293,22294],{},"CMS 主要通过并发标记和并发清除回收老年代，排查时重点观察：",[114,22296,22297,22300,22303,22310,22316],{},[117,22298,22299],{},"CMS 周期是否越来越频繁；",[117,22301,22302],{},"一轮 CMS 周期完成后，老年代占用能否明显下降；",[117,22304,22305,22306,22309],{},"是否出现 ",[22,22307,22308],{},"concurrent mode failure","，即 CMS 尚未完成，老年代已经没有足够空间；",[117,22311,22305,22312,22315],{},[22,22313,22314],{},"promotion failed","，即新生代对象晋升时老年代无法提供足够空间；",[117,22317,22318],{},"老年代碎片是否持续增加，并最终触发代价较高的 Full GC。",[18,22320,22321],{},"CMS 不在正常并发回收过程中整理存活对象，因此即使老年代总剩余空间看起来尚可，也可能因缺少足够大的连续空间而发生晋升失败或 Full GC。",[6264,22323,22324],{"id":22324},"通用判断方法",[18,22326,22327],{},"无论使用哪种收集器，都需要结合以下趋势判断：",[114,22329,22330,22333,22336,22339,22342,22345],{},[117,22331,22332],{},"老年代使用量是否持续增长；",[117,22334,22335],{},"关键 GC 周期是否越来越频繁；",[117,22337,22338],{},"关键 GC 周期后内存能否明显下降；",[117,22340,22341],{},"对象分配速率是否突然升高；",[117,22343,22344],{},"晋升速率和大对象分配是否异常；",[117,22346,22347],{},"GC 停顿是否已经影响业务。",[18,22349,22350],{},"其中，“关键回收周期”在 G1 下主要指一轮并发标记及后续一系列 Mixed GC，在 CMS 下主要指一轮完整的 CMS 周期：",[95,22352,22355],{"className":22353,"code":22354,"language":100,"meta":101},[98],"关键回收周期后老年代基线持续上升\n→ 更像对象泄漏或无上限缓存\n\n回收后能够下降，但高峰期仍然耗尽\n→ 更像容量不足或瞬时流量过大\n\n内存突然被单次请求快速打满\n→ 检查超大数组、文件、结果集或批次\n",[22,22356,22354],{"__ignoreMap":101},[638,22358,22360],{"id":22359},"_2-分析-heap-dump","2. 分析 Heap Dump",[18,22362,22363],{},"常用工具包括 Eclipse MAT、JDK Mission Control 和 VisualVM。",[18,22365,22366],{},"重点关注：",[114,22368,22369,22372,22375,22378,22381],{},[117,22370,22371],{},"Histogram：各类对象的实例数和浅堆大小；",[117,22373,22374],{},"Dominator Tree：哪些对象支配了大量内存；",[117,22376,22377],{},"Retained Size：删除某对象后理论上能够释放多少内存；",[117,22379,22380],{},"Path to GC Roots：对象为什么仍然可达；",[117,22382,22383],{},"Leak Suspects：工具给出的泄漏候选，需要结合业务验证。",[18,22385,22386,22389,22390,22393],{},[22,22387,22388],{},"Shallow Size"," 只表示对象自身大小；",[22,22391,22392],{},"Retained Size"," 还包括只能通过该对象访问的其他对象。排查泄漏时，Retained Size 通常更有价值。",[59,22395,22396],{},[18,22397,22398,22400],{},[64,22399,22392],{}," 表示：如果某个对象被回收，并且没有其他引用路径继续持有其支配的对象，理论上能够一并释放的堆内存总量。它用于衡量对象实际“留住”了多少内存，不等于对象自身大小，也不代表这些内存会立刻返还给操作系统。",[638,22402,22404],{"id":22403},"_3-常见堆泄漏来源","3. 常见堆泄漏来源",[114,22406,22407,22410,22413,22416,22419,22422,22425,22428],{},[117,22408,22409],{},"没有容量上限或过期机制的本地缓存；",[117,22411,22412],{},"静态集合持续保存业务对象；",[117,22414,22415],{},"ThreadLocal 使用后没有清理；",[117,22417,22418],{},"监听器、回调或订阅关系只注册不注销；",[117,22420,22421],{},"队列无界，生产速度长期高于消费速度；",[117,22423,22424],{},"一次性加载超大文件、结果集或消息批次；",[117,22426,22427],{},"ORM 上下文、会话对象长期持有实体；",[117,22429,22430],{},"重试任务、Future 或上下文对象长期积压。",[14,22432,22434],{"id":22433},"六gc-overhead-limit-exceeded-是什么","六、GC Overhead Limit Exceeded 是什么",[18,22436,22437],{},"这个错误表示 JVM 长时间忙于执行 GC，但每次只能回收很少的堆空间。它描述的是“GC 开销极高、回收收益极低”的状态，通常说明 Java 堆压力已经非常严重，而不是指某个新的内存区域发生了 OOM。",[18,22439,22440],{},"排查方法与堆 OOM 基本一致：",[2489,22442,22443,22446,22449,22452],{},[117,22444,22445],{},"查看 GC 频率以及关键回收周期前后的堆占用；",[117,22447,22448],{},"分析 Heap Dump 中的主要存活对象；",[117,22450,22451],{},"检查是否存在内存泄漏或缓存、队列无上限；",[117,22453,22454],{},"检查堆容量是否与真实负载匹配。",[18,22456,22457],{},"只关闭 GC overhead 检查通常没有解决根因，只会让进程以另一种方式继续恶化。",[14,22459,22461],{"id":22460},"七metaspace-oom-如何分析","七、Metaspace OOM 如何分析",[18,22463,22464],{},"Metaspace 保存类元数据。发生 OOM 时重点检查：",[114,22466,22467,22470,22473,22476,22479],{},[117,22468,22469],{},"已加载类数量是否持续增长；",[117,22471,22472],{},"是否频繁动态生成代理类、脚本类或字节码增强类；",[117,22474,22475],{},"是否存在大量无法卸载的 ClassLoader；",[117,22477,22478],{},"热部署、插件化或脚本引擎是否反复创建类加载器；",[117,22480,22481,22484],{},[22,22482,22483],{},"-XX:MaxMetaspaceSize"," 是否设置得过小。",[18,22486,20898],{},[95,22488,22490],{"className":7782,"code":22489,"language":7784,"meta":101,"style":101},"jcmd \u003Cpid> VM.classloader_stats\njcmd \u003Cpid> GC.class_histogram\n",[22,22491,22492,22507],{"__ignoreMap":101},[141,22493,22494,22496,22498,22500,22502,22504],{"class":143,"line":144},[141,22495,22006],{"class":158},[141,22497,22009],{"class":151},[141,22499,22012],{"class":911},[141,22501,22015],{"class":147},[141,22503,9174],{"class":151},[141,22505,22506],{"class":911}," VM.classloader_stats\n",[141,22508,22509,22511,22513,22515,22517,22519],{"class":143,"line":165},[141,22510,22006],{"class":158},[141,22512,22009],{"class":151},[141,22514,22012],{"class":911},[141,22516,22015],{"class":147},[141,22518,9174],{"class":151},[141,22520,22050],{"class":911},[18,22522,22523],{},"典型泄漏链路是：",[95,22525,22528],{"className":22526,"code":22527,"language":100,"meta":101},[98],"业务线程、ThreadLocal、静态对象或第三方库\n→ 持有自定义 ClassLoader\n→ ClassLoader 持有其加载的全部 Class\n→ 类元数据无法卸载\n",[22,22529,22527],{"__ignoreMap":101},[18,22531,22532],{},"简单调大 Metaspace 只能延迟故障。类数量持续增长时，应定位是哪个 ClassLoader 和动态类生成逻辑没有释放。",[14,22534,22536],{"id":22535},"八direct-buffer-memory-如何分析","八、Direct Buffer Memory 如何分析",[18,22538,22539],{},"直接内存位于 Java 堆之外，常见使用者包括 NIO、Netty、压缩库和网络框架。",[18,22541,1747],{},[114,22543,22544,22547,22552,22555,22558,22561],{},[117,22545,22546],{},"DirectByteBuffer 数量和容量；",[117,22548,22549,2159],{},[22,22550,22551],{},"-XX:MaxDirectMemorySize",[117,22553,22554],{},"Netty 池化内存和引用计数是否正确释放；",[117,22556,22557],{},"是否缓存了大量直接缓冲区；",[117,22559,22560],{},"是否存在大文件或网络数据的堆外缓冲；",[117,22562,22563],{},"进程 RSS 是否增长，但 Java 堆保持稳定。",[18,22565,22566],{},"如果启用了 NMT，可以通过：",[95,22568,22569],{"className":7782,"code":22098,"language":7784,"meta":101,"style":101},[22,22570,22571],{"__ignoreMap":101},[141,22572,22573,22575,22577,22579,22581,22583,22585],{"class":143,"line":144},[141,22574,22006],{"class":158},[141,22576,22009],{"class":151},[141,22578,22012],{"class":911},[141,22580,22015],{"class":147},[141,22582,9174],{"class":151},[141,22584,22115],{"class":911},[141,22586,22118],{"class":911},[18,22588,22589],{},"查看 JVM 能追踪到的原生内存分类。需要注意，NMT 不能解释所有第三方原生库分配，仍要结合框架指标、进程 RSS 和操作系统工具分析。",[14,22591,22593],{"id":22592},"九unable-to-create-native-thread-如何分析","九、Unable to Create Native Thread 如何分析",[18,22595,22596],{},"创建线程不仅需要 Java 对象，还需要原生线程和线程栈。常见原因包括：",[114,22598,22599,22602,22608,22615,22618,22624,22627],{},[117,22600,22601],{},"线程池配置失控或不断创建新线程；",[117,22603,3901,22604,22607],{},[22,22605,22606],{},"newCachedThreadPool()"," 等高上限线程池承接阻塞任务；",[117,22609,22610,22611,22614],{},"每次处理请求或任务时都重新执行 ",[22,22612,22613],{},"new Thread()","，没有复用受控线程池；",[117,22616,22617],{},"线程阻塞、死锁或下游超时，旧线程迟迟不能释放；",[117,22619,22620,22623],{},[22,22621,22622],{},"-Xss"," 设置过大；",[117,22625,22626],{},"容器原生内存不足；",[117,22628,22629],{},"操作系统或容器的 PID、用户线程数限制。",[18,22631,22632],{},"排查时可以结合：",[95,22634,22636],{"className":7782,"code":22635,"language":7784,"meta":101,"style":101},"jcmd \u003Cpid> Thread.print\nps -eLf\n",[22,22637,22638,22652],{"__ignoreMap":101},[141,22639,22640,22642,22644,22646,22648,22650],{"class":143,"line":144},[141,22641,22006],{"class":158},[141,22643,22009],{"class":151},[141,22645,22012],{"class":911},[141,22647,22015],{"class":147},[141,22649,9174],{"class":151},[141,22651,22065],{"class":911},[141,22653,22654,22657],{"class":143,"line":165},[141,22655,22656],{"class":158},"ps",[141,22658,22659],{"class":428}," -eLf\n",[18,22661,22662],{},"重点统计线程总数、线程名称分布和线程状态，确认是哪一个线程池或业务模块持续增长。解决方向通常是限制线程数量、使用有界队列、修复阻塞和超时、释放线程资源，而不是只调整系统线程上限。",[14,22664,22666],{"id":22665},"十requested-array-size-exceeds-vm-limit","十、Requested Array Size Exceeds VM Limit",[18,22668,22669],{},"该错误通常说明代码尝试创建一个超过 JVM 可表示或可管理范围的数组，例如：",[114,22671,22672,22675,22678,22681,22684],{},[117,22673,22674],{},"根据错误长度计算数组容量；",[117,22676,22677],{},"整数溢出后得到异常容量；",[117,22679,22680],{},"一次性把超大文件读入 byte 数组；",[117,22682,22683],{},"一次性拼接超大字符串；",[117,22685,22686],{},"查询结果或批处理缺少分页。",[18,22688,22689],{},"这类问题的重点是定位申请数组的调用栈并修改数据处理方式，例如分页、流式读取、分块处理或限制单次请求大小。单纯增加堆通常无效。",[14,22691,22693],{"id":22692},"十一如何区分泄漏容量不足和异常大对象","十一、如何区分泄漏、容量不足和异常大对象",[1309,22695,22696,22705],{},[1312,22697,22698],{},[1315,22699,22700,22702],{},[1318,22701,1795],{},[1318,22703,22704],{},"更可能的原因",[1328,22706,22707,22715,22723,22731,22739,22747],{},[1315,22708,22709,22712],{},[1333,22710,22711],{},"关键 GC 周期后老年代基线仍持续上升",[1333,22713,22714],{},"对象泄漏、无上限缓存或队列",[1315,22716,22717,22720],{},[1333,22718,22719],{},"内存随流量上升，流量下降后能够回落",[1333,22721,22722],{},"正常业务占用或容量不足",[1315,22724,22725,22728],{},[1333,22726,22727],{},"某次请求后内存瞬间大幅增长",[1333,22729,22730],{},"超大对象、文件、结果集或批次",[1315,22732,22733,22736],{},[1333,22734,22735],{},"Java 堆稳定，但进程 RSS 持续增长",[1333,22737,22738],{},"直接内存、线程栈或原生库",[1315,22740,22741,22744],{},[1333,22742,22743],{},"类数量和 Metaspace 持续增长",[1333,22745,22746],{},"ClassLoader 或动态类泄漏",[1315,22748,22749,22752],{},[1333,22750,22751],{},"线程数持续增长并最终创建失败",[1333,22753,22754],{},"线程泄漏、阻塞或线程池失控",[18,22756,22757],{},"判断不能只靠故障时的一张截图。应把 Heap Dump、GC 日志、时间序列监控、流量和发布记录结合起来。",[14,22759,22761],{"id":22760},"十二修复时应该做什么","十二、修复时应该做什么",[638,22763,22764],{"id":22764},"内存泄漏",[114,22766,22767,22770,22773,22776,22779],{},[117,22768,22769],{},"删除无效引用；",[117,22771,22772],{},"给缓存和集合增加容量、过期和清理策略；",[117,22774,22775],{},"正确清理 ThreadLocal、监听器和回调；",[117,22777,22778],{},"修复 ClassLoader、Buffer 或原生资源释放；",[117,22780,22781],{},"为队列和重试任务设置上限。",[638,22783,22784],{"id":22784},"容量不足",[114,22786,22787,22790,22793,22796,22799],{},[117,22788,22789],{},"根据峰值存活对象和分配速率重新评估堆容量；",[117,22791,22792],{},"优化对象生命周期和数据结构；",[117,22794,22795],{},"降低单次批量大小；",[117,22797,22798],{},"扩容实例并重新分配流量；",[117,22800,22801],{},"调整容器上限时为堆外内存保留空间。",[638,22803,22804],{"id":22804},"异常大对象或突发流量",[114,22806,22807,22810,22813,22816,22819],{},[117,22808,22809],{},"限制请求体、文件、分页和批次大小；",[117,22811,22812],{},"使用流式处理代替一次性加载；",[117,22814,22815],{},"对大查询增加保护；",[117,22817,22818],{},"在入口处限流和拒绝异常请求；",[117,22820,22821],{},"避免把外部积压无限转移到 JVM 内存。",[18,22823,22824],{},"调大内存可以作为临时止损手段，但必须建立在容量评估之上。存在泄漏时，内存越大通常只是让故障更晚发生。",[14,22826,22828],{"id":22827},"十三如何验证修复有效","十三、如何验证修复有效",[18,22830,22831],{},"修复后不能只确认“暂时没有再 OOM”，还要在接近真实的流量模型下验证：",[114,22833,22834,22837,22840,22843,22846,22849,22852],{},[117,22835,22836],{},"老年代在 GC 后能够回落并保持稳定；",[117,22838,22839],{},"对象数量不再无界增长；",[117,22841,22842],{},"Metaspace、直接内存和线程数保持在合理范围；",[117,22844,22845],{},"GC 频率、停顿和吞吐符合目标；",[117,22847,22848],{},"进程 RSS 与容器限制之间有足够余量；",[117,22850,22851],{},"高峰、降峰和长时间运行都没有持续爬升；",[117,22853,22854],{},"限流、降级和自动重启策略能够正确触发。",[18,22856,22857],{},"内存泄漏往往需要时间积累，短时间功能测试不能代替持续稳定性验证。",[14,22859,22861],{"id":22860},"十四上线前应该建立哪些预防能力","十四、上线前应该建立哪些预防能力",[638,22863,22865],{"id":22864},"jvm-证据","JVM 证据",[114,22867,22868,22871,22874,22877],{},[117,22869,22870],{},"开启 OOM 自动 Heap Dump；",[117,22872,22873],{},"保存并轮转 GC 日志；",[117,22875,22876],{},"记录 JVM 参数和应用版本；",[117,22878,22879],{},"在需要分析原生内存的服务上评估开启 NMT。",[638,22881,22882],{"id":22882},"监控告警",[114,22884,22885,22888,22891,22894,22897,22900,22903],{},[117,22886,22887],{},"Heap 各代使用量及 GC 后基线；",[117,22889,22890],{},"GC 次数、停顿和回收量；",[117,22892,22893],{},"Metaspace 和已加载类数量；",[117,22895,22896],{},"Direct Buffer 使用量；",[117,22898,22899],{},"线程总数和各线程池状态；",[117,22901,22902],{},"进程 RSS、容器 Working Set 和 OOMKilled；",[117,22904,22905],{},"队列长度、缓存数量、请求体和批次大小。",[59,22907,22908],{},[18,22909,22910,22913],{},[64,22911,22912],{},"容器 Working Set"," 通常近似表示 cgroup 内存使用量扣除不活跃文件缓存后的部分，用于衡量当前不容易被操作系统立即回收的内存。它不是 Java Heap，也不完全等同于单个 Java 进程的 RSS，排查时需要结合两者一起看。",[638,22915,22916],{"id":22916},"容量与保护",[114,22918,22919,22922,22925,22928,22931],{},[117,22920,22921],{},"为容器总内存预留堆外空间；",[117,22923,22924],{},"缓存、队列、线程池和批次必须有明确上限；",[117,22926,22927],{},"大请求、大文件和大查询需要入口保护；",[117,22929,22930],{},"关键服务具备摘流、限流、降级和快速重启能力；",[117,22932,22933],{},"定期进行内存压测和故障演练。",[14,22935,22937],{"id":22936},"十五常见错误做法","十五、常见错误做法",[638,22939,22941],{"id":22940},"_1-一出现-oom-就把-xmx-调大","1. 一出现 OOM 就把 Xmx 调大",[18,22943,22944],{},"这可能暂时缓解容量不足，但无法修复泄漏、线程失控、直接内存或 ClassLoader 问题。",[638,22946,22948],{"id":22947},"_2-重启后不保留任何证据","2. 重启后不保留任何证据",[18,22950,22951],{},"重启会清空最重要的现场。至少应提前配置自动 Dump、GC 日志和监控。",[638,22953,22955],{"id":22954},"_3-只看-heap-dump不看时间趋势","3. 只看 Heap Dump，不看时间趋势",[18,22957,22958],{},"单份 Dump 能说明“当时谁占内存”，但不一定能证明谁在持续增长。需要结合多个时间点、GC 后基线和业务流量。",[638,22960,22962],{"id":22961},"_4-把容器内存全部分给-xmx","4. 把容器内存全部分给 Xmx",[18,22964,22965],{},"JVM 还需要 Metaspace、直接内存、线程栈和原生结构，容器必须保留余量。",[638,22967,22969],{"id":22968},"_5-在线高峰期随意执行重型诊断","5. 在线高峰期随意执行重型诊断",[18,22971,22972],{},"Heap Dump、对象直方图等操作可能产生停顿和磁盘压力，应评估实例状态、可用副本和磁盘空间。",[14,22974,22976],{"id":22975},"十六排查检查清单","十六、排查检查清单",[114,22978,22979,22982,22985,22988,22991,22994,22997,23000,23003,23006,23009,23012],{},[117,22980,22981],{},"OOM 的完整错误信息是什么；",[117,22983,22984],{},"是 JVM 抛出的 OOM，还是容器 OOMKilled；",[117,22986,22987],{},"故障发生在哪个内存区域；",[117,22989,22990],{},"是否保存了 Heap Dump、GC 日志和监控；",[117,22992,22993],{},"关键 GC 周期后老年代能否回落；G1 下重点观察并发标记及后续一系列 Mixed GC；",[117,22995,22996],{},"最大对象及其 Retained Size 是多少；",[117,22998,22999],{},"对象通过什么引用链连接到 GC Roots；",[117,23001,23002],{},"类数量、ClassLoader、直接内存或线程数是否持续增长；",[117,23004,23005],{},"最近是否有发布、配置、流量或批量任务变化；",[117,23007,23008],{},"问题属于泄漏、容量不足还是异常大对象；",[117,23010,23011],{},"修复后是否在真实负载和长时间运行下验证；",[117,23013,23014],{},"是否补齐自动留证、监控告警和容量保护。",[14,23016,5605],{"id":5605},[114,23018,23019,23026,23033,23040],{},[117,23020,23021],{},[73,23022,23025],{"href":23023,"rel":23024},"https:\u002F\u002Fdocs.oracle.com\u002Fen\u002Fjava\u002Fjavase\u002F21\u002Ftroubleshoot\u002Ftroubleshooting-memory-leaks.html",[1876],"Oracle Java Troubleshooting Guide：Troubleshoot Memory Leaks",[117,23027,23028],{},[73,23029,23032],{"href":23030,"rel":23031},"https:\u002F\u002Fdocs.oracle.com\u002Fen\u002Fjava\u002Fjavase\u002F21\u002Fdocs\u002Fspecs\u002Fman\u002Fjcmd.html",[1876],"Oracle Java Tools Reference：jcmd",[117,23034,23035],{},[73,23036,23039],{"href":23037,"rel":23038},"https:\u002F\u002Fdocs.oracle.com\u002Fen\u002Fjava\u002Fjavase\u002F21\u002Fvm\u002Fnative-memory-tracking.html",[1876],"Oracle Java Troubleshooting Guide：Native Memory Tracking",[117,23041,23042],{},[73,23043,23046],{"href":23044,"rel":23045},"https:\u002F\u002Feclipse.dev\u002Fmat\u002F",[1876],"Eclipse Memory Analyzer",[1907,23048,23049],{},"html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}",{"title":101,"searchDepth":165,"depth":165,"links":23051},[23052,23053,23054,23055,23056,23057,23063,23067,23072,23073,23074,23075,23076,23077,23078,23083,23084,23089,23096,23097],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":21762,"depth":165,"text":21763},{"id":21872,"depth":165,"text":21873},{"id":21902,"depth":165,"text":21903,"children":23058},[23059,23060,23061,23062],{"id":21906,"depth":210,"text":21907},{"id":21939,"depth":210,"text":21940},{"id":21967,"depth":210,"text":21968},{"id":21995,"depth":210,"text":21996},{"id":22132,"depth":165,"text":22133,"children":23064},[23065,23066],{"id":22139,"depth":210,"text":22140},{"id":22153,"depth":210,"text":22154},{"id":22180,"depth":165,"text":22181,"children":23068},[23069,23070,23071],{"id":22193,"depth":210,"text":22194},{"id":22359,"depth":210,"text":22360},{"id":22403,"depth":210,"text":22404},{"id":22433,"depth":165,"text":22434},{"id":22460,"depth":165,"text":22461},{"id":22535,"depth":165,"text":22536},{"id":22592,"depth":165,"text":22593},{"id":22665,"depth":165,"text":22666},{"id":22692,"depth":165,"text":22693},{"id":22760,"depth":165,"text":22761,"children":23079},[23080,23081,23082],{"id":22764,"depth":210,"text":22764},{"id":22784,"depth":210,"text":22784},{"id":22804,"depth":210,"text":22804},{"id":22827,"depth":165,"text":22828},{"id":22860,"depth":165,"text":22861,"children":23085},[23086,23087,23088],{"id":22864,"depth":210,"text":22865},{"id":22882,"depth":210,"text":22882},{"id":22916,"depth":210,"text":22916},{"id":22936,"depth":165,"text":22937,"children":23090},[23091,23092,23093,23094,23095],{"id":22940,"depth":210,"text":22941},{"id":22947,"depth":210,"text":22948},{"id":22954,"depth":210,"text":22955},{"id":22961,"depth":210,"text":22962},{"id":22968,"depth":210,"text":22969},{"id":22975,"depth":165,"text":22976},{"id":5605,"depth":165,"text":5605},"wiki:java:java-oom-troubleshooting","从线上止损、现场保留、OOM 类型识别、Heap Dump 与 GC 日志分析，到堆、元空间、直接内存、线程和容器内存定位，系统讲解 Java OOM 的处理方法。",{},81,"\u002Fjava\u002Fjava-oom-troubleshooting",{"title":21698,"description":23099},"java\u002Fjava-oom-troubleshooting","2026-07-28","y7MSNq1nIooPfRKJm5-oCcbDEXb3CosxwJ-RFf7BvaI",{"id":23108,"title":23109,"body":23110,"commentId":25039,"description":25040,"difficulty":3462,"draft":1943,"extension":1944,"meta":25041,"navigation":206,"order":25042,"path":25043,"section":1948,"seo":25044,"stem":25045,"updated":25046,"__hash__":25047},"java\u002Fjava\u002Fjava-high-cpu-troubleshooting.md","如果一个系统 CPU 飙高，应该如何排查处理？",{"type":7,"value":23111,"toc":24990},[23112,23115,23117,23120,23138,23141,23144,23146,23153,23155,23164,23166,23170,23176,23179,23182,23195,23198,23240,23252,23256,23259,23270,23273,23308,23311,23315,23318,23333,23336,23356,23360,23364,23367,23407,23410,23463,23466,23544,23547,23551,23554,23571,23578,23582,23585,23643,23649,23653,23657,23659,23681,23683,23711,23721,23728,23744,23747,23753,23757,23760,23789,23792,23839,23842,23848,23853,23869,23873,23876,23886,23897,23901,23905,23908,23919,23921,23966,23969,23973,23976,24008,24011,24015,24018,24024,24027,24031,24034,24051,24054,24058,24061,24075,24078,24082,24085,24102,24105,24109,24116,24119,24151,24154,24177,24191,24195,24198,24201,24237,24240,24254,24257,24261,24264,24281,24287,24290,24293,24306,24309,24312,24345,24351,24354,24371,24374,24378,24382,24385,24402,24405,24448,24454,24486,24489,24495,24499,24502,24509,24513,24516,24530,24536,24539,24594,24597,24601,24604,24621,24624,24627,24650,24653,24663,24669,24673,24776,24780,24783,24809,24812,24816,24819,24848,24863,24867,24871,24874,24878,24881,24885,24893,24897,24900,24904,24907,24911,24914,24920,24922,24987],[10,23113,23109],{"id":23114},"如果一个系统-cpu-飙高应该如何排查处理",[14,23116,16],{"id":16},[18,23118,23119],{},"系统 CPU 飙高时，我会先确认影响范围并止损，通过摘除异常实例、限流、降级或临时扩容保护系统，同时保存故障时间、流量、发布变更、CPU、负载、GC、线程数和容器限流等现场数据。CPU 高不一定来自当前 Java 进程，因此要先从机器、容器和进程三个层级确认消耗主体；如果机器 CPU 高而 JVM CPU 不高，应继续检查同机其他进程、内核态、I\u002FO wait 和 steal time。",[18,23121,23122,23123,6067,23126,23129,23130,23133,23134,23137],{},"确认是 Java 进程后，我会定位高 CPU 线程。可以通过 ",[22,23124,23125],{},"top -H -p \u003Cpid>",[22,23127,23128],{},"ps -Lp"," 找到线程 ID，将十进制 TID 转成十六进制，再与 ",[22,23131,23132],{},"jcmd \u003Cpid> Thread.print -l"," 中的 ",[22,23135,23136],{},"nid"," 对应。线程栈要间隔数秒连续采集多次，只有持续出现在相同执行位置的热点线程，才更可能是死循环、频繁重试、正则回溯、序列化、加解密或其他热点代码。",[18,23139,23140],{},"如果没有稳定的单个热点线程，或者问题持续时间很短，我会使用 JFR 或 async-profiler 做一段时间的采样，通过 Hot Methods、Call Tree 或 CPU 火焰图确认 CPU 时间消耗在哪里。同时结合 GC 日志和分配分析判断是否是对象分配过快导致 GC 消耗 CPU；结合线程数、上下文切换和锁事件判断是否是线程膨胀、CAS 自旋或锁竞争；还要检查 JIT 编译线程、原生库和内核调用。",[18,23142,23143],{},"修复时要针对根因处理，而不是只增加 CPU：死循环和无上限重试要修正退出条件并增加退避；高分配要减少临时对象和批次大小；热点计算要优化算法或缓存结果；线程膨胀要设置线程池和队列上限；流量超出容量则需要限流、扩容和容量规划。最后使用接近真实的流量验证 CPU、吞吐、延迟、GC 和错误率是否恢复，并补齐分层 CPU、线程、GC、容器限流和热点方法监控。",[18,23145,57],{},[59,23147,23148],{},[18,23149,23150],{},[64,23151,23152],{},"CPU 飙高的排查主线是先止损，再确认是机器、容器还是 JVM 消耗 CPU，然后把高 CPU 线程关联到 Java 栈或火焰图，最后结合 GC、线程和流量定位根因。",[14,23154,69],{"id":69},[18,23156,23157],{},[73,23158,23161],{"href":23159,"target":76,"rel":23160},"\u002Fimages\u002Fwiki\u002Fjava\u002Fjava-high-cpu-troubleshooting.svg",[78,79],[81,23162],{"src":23159,"alt":23163},"Java 系统 CPU 飙高的止损、分层定位、线程关联、根因分析和修复验证流程",[14,23165,86],{"id":86},[638,23167,23169],{"id":23168},"先理解容器-cpu-限流","先理解容器 CPU 限流",[18,23171,23172,23173,4878],{},"在容器环境中，CPU 使用量会受到 cgroup 配额约束。容器在一个统计周期内用完可用 CPU 时间后，内核会暂时停止调度其中的线程，等下一个周期再恢复运行，这就是",[64,23174,23175],{},"容器 CPU 限流（CPU throttling）",[18,23177,23178],{},"它不代表应用主动休眠，也不一定表现为整机 CPU 100%。即使宿主机仍有空闲 CPU，只要容器自己的配额已经耗尽，应用也会被限制运行，接口延迟和任务处理时间可能因此升高。",[18,23180,23181],{},"在 cgroup v2 中可以查看：",[95,23183,23185],{"className":7782,"code":23184,"language":7784,"meta":101,"style":101},"cat \u002Fsys\u002Ffs\u002Fcgroup\u002Fcpu.stat\n",[22,23186,23187],{"__ignoreMap":101},[141,23188,23189,23192],{"class":143,"line":144},[141,23190,23191],{"class":158},"cat",[141,23193,23194],{"class":911}," \u002Fsys\u002Ffs\u002Fcgroup\u002Fcpu.stat\n",[18,23196,23197],{},"常见字段包括：",[1309,23199,23200,23208],{},[1312,23201,23202],{},[1315,23203,23204,23206],{},[1318,23205,2344],{},[1318,23207,2347],{},[1328,23209,23210,23220,23230],{},[1315,23211,23212,23217],{},[1333,23213,23214],{},[22,23215,23216],{},"nr_periods",[1333,23218,23219],{},"已经经过的 CPU 配额统计周期数",[1315,23221,23222,23227],{},[1333,23223,23224],{},[22,23225,23226],{},"nr_throttled",[1333,23228,23229],{},"容器在多少个周期内触发过 CPU 限流",[1315,23231,23232,23237],{},[1333,23233,23234],{},[22,23235,23236],{},"throttled_usec",[1333,23238,23239],{},"容器累计被限制运行的时间，单位为微秒",[18,23241,23242,23243,23245,23246,23248,23249,23251],{},"排查时应观察这些计数在一段时间内的增长速度，而不是只看某个累计值。",[22,23244,23226],{}," 占 ",[22,23247,23216],{}," 的比例持续较高，或 ",[22,23250,23236],{}," 快速增长，说明容器经常受 CPU 配额限制；还要继续判断是 CPU limit 配置过低，还是应用存在异常计算。",[14,23253,23255],{"id":23254},"一cpu-高并不等于业务代码一定有死循环","一、CPU 高并不等于业务代码一定有死循环",[18,23257,23258],{},"看到 CPU 告警后，首先要明确三个问题：",[2489,23260,23261,23264,23267],{},[117,23262,23263],{},"是整台机器 CPU 高，还是某个容器 CPU 高？",[117,23265,23266],{},"是 Java 进程消耗 CPU，还是同机其他进程或内核消耗 CPU？",[117,23268,23269],{},"是真实计算压力增加，还是容器 CPU 配额不足、线程调度或 GC 等问题？",[18,23271,23272],{},"常见根因包括：",[114,23274,23275,23278,23281,23284,23287,23290,23293,23296,23299,23302,23305],{},[117,23276,23277],{},"流量或任务量突然上升；",[117,23279,23280],{},"死循环、无上限重试或消息空转；",[117,23282,23283],{},"正则表达式灾难性回溯；",[117,23285,23286],{},"JSON 序列化、压缩、加解密等计算热点；",[117,23288,23289],{},"对象分配速度过快，引发频繁 GC；",[117,23291,23292],{},"线程数量膨胀和上下文切换；",[117,23294,23295],{},"CAS 竞争、自旋等待或热点锁；",[117,23297,23298],{},"异常大量抛出、堆栈生成和同步日志输出；",[117,23300,23301],{},"JIT 编译、GC 线程或第三方原生库消耗 CPU；",[117,23303,23304],{},"其他进程、内核中断或虚拟机宿主机争抢 CPU；",[117,23306,23307],{},"容器 CPU limit 太低或持续发生 CPU 限流。",[18,23309,23310],{},"因此不能一看到 CPU 高，就直接重启、扩容或者抓一份线程栈后认定某段代码有问题。",[14,23312,23314],{"id":23313},"二第一阶段先控制故障影响","二、第一阶段：先控制故障影响",[18,23316,23317],{},"线上处理应先恢复系统可用性：",[2489,23319,23320,23323,23325,23328,23330],{},[117,23321,23322],{},"从负载均衡中摘除最异常的实例；",[117,23324,21887],{},[117,23326,23327],{},"暂停可能造成空转、重试风暴或计算放大的任务；",[117,23329,21884],{},[117,23331,23332],{},"如果线程已经长期占满 CPU 且服务不可用，保留必要现场后重启实例。",[18,23334,23335],{},"重启能够暂时清除异常状态，但也会丢失最有价值的线程和性能现场。条件允许时，至少先保存：",[114,23337,23338,23341,23344,23347,23350,23353],{},[117,23339,23340],{},"告警开始和结束时间；",[117,23342,23343],{},"进程 CPU、机器 CPU、负载和容器 CPU；",[117,23345,23346],{},"请求量、任务量、消息消费速率和错误率；",[117,23348,23349],{},"线程数、GC 次数和 GC 线程消耗的 CPU；",[117,23351,23352],{},"最近的发布、配置和数据变更；",[117,23354,23355],{},"多份线程栈或一段 JFR、async-profiler 记录。",[14,23357,23359],{"id":23358},"三第二阶段确认-cpu-到底消耗在哪里","三、第二阶段：确认 CPU 到底消耗在哪里",[638,23361,23363],{"id":23362},"_1-机器层面","1. 机器层面",[18,23365,23366],{},"先查看整机情况：",[95,23368,23370],{"className":7782,"code":23369,"language":7784,"meta":101,"style":101},"top\nmpstat -P ALL 1\npidstat -u 1\nvmstat 1\n",[22,23371,23372,23377,23390,23400],{"__ignoreMap":101},[141,23373,23374],{"class":143,"line":144},[141,23375,23376],{"class":158},"top\n",[141,23378,23379,23382,23385,23388],{"class":143,"line":165},[141,23380,23381],{"class":158},"mpstat",[141,23383,23384],{"class":428}," -P",[141,23386,23387],{"class":911}," ALL",[141,23389,11261],{"class":428},[141,23391,23392,23395,23398],{"class":143,"line":210},[141,23393,23394],{"class":158},"pidstat",[141,23396,23397],{"class":428}," -u",[141,23399,11261],{"class":428},[141,23401,23402,23405],{"class":143,"line":219},[141,23403,23404],{"class":158},"vmstat",[141,23406,11261],{"class":428},[18,23408,23409],{},"这些命令观察的层次不同：",[1309,23411,23412,23421],{},[1312,23413,23414],{},[1315,23415,23416,23419],{},[1318,23417,23418],{},"命令",[1318,23420,15373],{},[1328,23422,23423,23433,23443,23453],{},[1315,23424,23425,23430],{},[1333,23426,23427],{},[22,23428,23429],{},"top",[1333,23431,23432],{},"查看整机负载、CPU 和内存概况，并找出资源占用较高的进程",[1315,23434,23435,23440],{},[1333,23436,23437],{},[22,23438,23439],{},"mpstat -P ALL 1",[1333,23441,23442],{},"每秒输出一次每个 CPU 核的使用情况，用于判断负载是否集中在少数核心，并区分用户态、内核态、I\u002FO wait 和 steal time",[1315,23444,23445,23450],{},[1333,23446,23447],{},[22,23448,23449],{},"pidstat -u 1",[1333,23451,23452],{},"每秒按进程输出一次 CPU 使用情况，用于确认哪个进程正在消耗 CPU",[1315,23454,23455,23460],{},[1333,23456,23457],{},[22,23458,23459],{},"vmstat 1",[1333,23461,23462],{},"每秒输出一次系统运行队列、内存、交换、I\u002FO、上下文切换和 CPU 概况，用于判断 CPU 高是否伴随排队、换页或 I\u002FO 压力",[18,23464,23465],{},"重点区分：",[1309,23467,23468,23479],{},[1312,23469,23470],{},[1315,23471,23472,23474,23476],{},[1318,23473,6831],{},[1318,23475,2347],{},[1318,23477,23478],{},"常见方向",[1328,23480,23481,23494,23507,23520,23533],{},[1315,23482,23483,23488,23491],{},[1333,23484,23485],{},[22,23486,23487],{},"us",[1333,23489,23490],{},"用户态 CPU",[1333,23492,23493],{},"Java 业务代码、GC、JIT 或其他用户进程",[1315,23495,23496,23501,23504],{},[1333,23497,23498],{},[22,23499,23500],{},"sy",[1333,23502,23503],{},"内核态 CPU",[1333,23505,23506],{},"系统调用、网络、磁盘、驱动或内核开销",[1315,23508,23509,23514,23517],{},[1333,23510,23511],{},[22,23512,23513],{},"wa",[1333,23515,23516],{},"CPU 等待 I\u002FO 的时间占比",[1333,23518,23519],{},"磁盘或存储瓶颈，不等同于 CPU 计算饱和",[1315,23521,23522,23527,23530],{},[1333,23523,23524],{},[22,23525,23526],{},"st",[1333,23528,23529],{},"虚拟机被宿主机拿走的 CPU 时间",[1333,23531,23532],{},"宿主机资源争抢",[1315,23534,23535,23538,23541],{},[1333,23536,23537],{},"Load Average",[1333,23539,23540],{},"正在运行或不可中断等待的任务压力",[1333,23542,23543],{},"不是 CPU 使用率，需结合 CPU 核数和任务状态判断",[18,23545,23546],{},"如果机器 CPU 很高，但目标 JVM CPU 不高，应先找出真正的高 CPU 进程，而不是继续分析 Java 线程。",[638,23548,23550],{"id":23549},"_2-容器层面","2. 容器层面",[18,23552,23553],{},"在 Kubernetes 或其他容器环境中，还要关注：",[114,23555,23556,23559,23562,23565,23568],{},[117,23557,23558],{},"Pod 实际 CPU 使用量；",[117,23560,23561],{},"CPU request 和 limit；",[117,23563,23564],{},"容器是否发生 CPU 限流；",[117,23566,23567],{},"Node 是否整体繁忙；",[117,23569,23570],{},"Pod 是否频繁扩缩容、重启或迁移。",[18,23572,23573,23574,23577],{},"前文已经介绍了 CPU 限流的含义和 ",[22,23575,23576],{},"cpu.stat"," 指标。这里还应将 Pod 的 CPU 使用量、limit、限流时间与业务延迟放到同一时间线上，避免只根据某一时刻的 CPU 百分比判断。",[638,23579,23581],{"id":23580},"_3-进程层面","3. 进程层面",[18,23583,23584],{},"确认 Java 进程：",[95,23586,23588],{"className":7782,"code":23587,"language":7784,"meta":101,"style":101},"# 每秒查看一次指定进程的用户态、内核态及总 CPU 使用率\npidstat -u -p \u003Cpid> 1\n\n# 查看进程 ID、父进程 ID、CPU、内存、线程数和启动命令\nps -p \u003Cpid> -o pid,ppid,%cpu,%mem,nlwp,cmd\n",[22,23589,23590,23595,23614,23618,23623],{"__ignoreMap":101},[141,23591,23592],{"class":143,"line":144},[141,23593,23594],{"class":237},"# 每秒查看一次指定进程的用户态、内核态及总 CPU 使用率\n",[141,23596,23597,23599,23601,23604,23606,23608,23610,23612],{"class":143,"line":165},[141,23598,23394],{"class":158},[141,23600,23397],{"class":428},[141,23602,23603],{"class":428}," -p",[141,23605,22009],{"class":151},[141,23607,22012],{"class":911},[141,23609,22015],{"class":147},[141,23611,9174],{"class":151},[141,23613,11261],{"class":428},[141,23615,23616],{"class":143,"line":210},[141,23617,207],{"emptyLinePlaceholder":206},[141,23619,23620],{"class":143,"line":219},[141,23621,23622],{"class":237},"# 查看进程 ID、父进程 ID、CPU、内存、线程数和启动命令\n",[141,23624,23625,23627,23629,23631,23633,23635,23637,23640],{"class":143,"line":234},[141,23626,22656],{"class":158},[141,23628,23603],{"class":428},[141,23630,22009],{"class":151},[141,23632,22012],{"class":911},[141,23634,22015],{"class":147},[141,23636,9174],{"class":151},[141,23638,23639],{"class":428}," -o",[141,23641,23642],{"class":911}," pid,ppid,%cpu,%mem,nlwp,cmd\n",[18,23644,23645,23648],{},[22,23646,23647],{},"%CPU"," 在多核系统中可能超过 100%。例如一个进程稳定使用两个 CPU 核，在某些工具中可能显示约 200%，不能机械地把超过 100% 当成监控错误。",[14,23650,23652],{"id":23651},"四第三阶段定位高-cpu-线程","四、第三阶段：定位高 CPU 线程",[638,23654,23656],{"id":23655},"_1-找到进程内的热点线程","1. 找到进程内的热点线程",[18,23658,20898],{},[95,23660,23662],{"className":7782,"code":23661,"language":7784,"meta":101,"style":101},"top -H -p \u003Cpid>\n",[22,23663,23664],{"__ignoreMap":101},[141,23665,23666,23668,23671,23673,23675,23677,23679],{"class":143,"line":144},[141,23667,23429],{"class":158},[141,23669,23670],{"class":428}," -H",[141,23672,23603],{"class":428},[141,23674,22009],{"class":151},[141,23676,22012],{"class":911},[141,23678,22015],{"class":147},[141,23680,3108],{"class":151},[18,23682,3541],{},[95,23684,23686],{"className":7782,"code":23685,"language":7784,"meta":101,"style":101},"ps -Lp \u003Cpid> -o pid,tid,pcpu,stat,comm --sort=-pcpu\n",[22,23687,23688],{"__ignoreMap":101},[141,23689,23690,23692,23695,23697,23699,23701,23703,23705,23708],{"class":143,"line":144},[141,23691,22656],{"class":158},[141,23693,23694],{"class":428}," -Lp",[141,23696,22009],{"class":151},[141,23698,22012],{"class":911},[141,23700,22015],{"class":147},[141,23702,9174],{"class":151},[141,23704,23639],{"class":428},[141,23706,23707],{"class":911}," pid,tid,pcpu,stat,comm",[141,23709,23710],{"class":428}," --sort=-pcpu\n",[18,23712,23713,23714,23717,23718,23720],{},"记录 CPU 最高的 TID。",[64,23715,23716],{},"TID（Thread ID）是操作系统为线程分配的标识","；在 Linux 中，Java 线程会对应一个可调度的本地线程，因此可以先按 TID 找到消耗 CPU 的操作系统线程，再通过 JVM 线程栈中的 ",[22,23719,23136],{}," 定位对应的 Java 调用栈。",[18,23722,23723,23724,23727],{},"假设十进制线程 ID 为 ",[22,23725,23726],{},"12345","，转换成十六进制：",[95,23729,23731],{"className":7782,"code":23730,"language":7784,"meta":101,"style":101},"printf '%x\\n' 12345\n",[22,23732,23733],{"__ignoreMap":101},[141,23734,23735,23738,23741],{"class":143,"line":144},[141,23736,23737],{"class":428},"printf",[141,23739,23740],{"class":911}," '%x\\n'",[141,23742,23743],{"class":428}," 12345\n",[18,23745,23746],{},"输出：",[95,23748,23751],{"className":23749,"code":23750,"language":100,"meta":101},[98],"3039\n",[22,23752,23750],{"__ignoreMap":101},[638,23754,23756],{"id":23755},"_2-获取-java-线程栈","2. 获取 Java 线程栈",[18,23758,23759],{},"推荐使用：",[95,23761,23763],{"className":7782,"code":23762,"language":7784,"meta":101,"style":101},"jcmd \u003Cpid> Thread.print -l > thread-1.txt\n",[22,23764,23765],{"__ignoreMap":101},[141,23766,23767,23769,23771,23773,23775,23777,23780,23783,23786],{"class":143,"line":144},[141,23768,22006],{"class":158},[141,23770,22009],{"class":151},[141,23772,22012],{"class":911},[141,23774,22015],{"class":147},[141,23776,9174],{"class":151},[141,23778,23779],{"class":911}," Thread.print",[141,23781,23782],{"class":428}," -l",[141,23784,23785],{"class":151}," >",[141,23787,23788],{"class":911}," thread-1.txt\n",[18,23790,23791],{},"间隔数秒再采集：",[95,23793,23795],{"className":7782,"code":23794,"language":7784,"meta":101,"style":101},"jcmd \u003Cpid> Thread.print -l > thread-2.txt\njcmd \u003Cpid> Thread.print -l > thread-3.txt\n",[22,23796,23797,23818],{"__ignoreMap":101},[141,23798,23799,23801,23803,23805,23807,23809,23811,23813,23815],{"class":143,"line":144},[141,23800,22006],{"class":158},[141,23802,22009],{"class":151},[141,23804,22012],{"class":911},[141,23806,22015],{"class":147},[141,23808,9174],{"class":151},[141,23810,23779],{"class":911},[141,23812,23782],{"class":428},[141,23814,23785],{"class":151},[141,23816,23817],{"class":911}," thread-2.txt\n",[141,23819,23820,23822,23824,23826,23828,23830,23832,23834,23836],{"class":143,"line":165},[141,23821,22006],{"class":158},[141,23823,22009],{"class":151},[141,23825,22012],{"class":911},[141,23827,22015],{"class":147},[141,23829,9174],{"class":151},[141,23831,23779],{"class":911},[141,23833,23782],{"class":428},[141,23835,23785],{"class":151},[141,23837,23838],{"class":911}," thread-3.txt\n",[18,23840,23841],{},"然后在文件中查找：",[95,23843,23846],{"className":23844,"code":23845,"language":100,"meta":101},[98],"nid=0x3039\n",[22,23847,23845],{"__ignoreMap":101},[18,23849,23850,23852],{},[22,23851,23136],{}," 是 JVM 线程对应的本地线程 ID，通常以十六进制展示。找到线程后，要同时观察：",[114,23854,23855,23857,23860,23863,23866],{},[117,23856,17401],{},[117,23858,23859],{},"线程状态；",[117,23861,23862],{},"当前方法和完整调用链；",[117,23864,23865],{},"是否连续多次停留在相同或相邻代码位置；",[117,23867,23868],{},"是否属于业务线程、GC 线程、JIT 编译线程或第三方原生线程。",[638,23870,23872],{"id":23871},"_3-为什么要连续采集多份线程栈","3. 为什么要连续采集多份线程栈",[18,23874,23875],{},"单份线程栈只是一瞬间的快照。一个正常执行请求的线程也可能恰好位于某个计算方法中，不能仅凭一次采样就认定它是根因。",[18,23877,23878,23879,23882,23883,23885],{},"如果同一线程在多份栈中持续处于 ",[22,23880,23881],{},"RUNNABLE","，并反复出现在相同调用路径，同时该线程的 TID CPU 持续较高，才更能说明它正在消耗 CPU。Oracle 的故障排查文档也建议对疑似循环线程采集一系列线程转储，重点观察持续处于 ",[22,23884,23881],{}," 状态的线程。",[18,23887,23888,23890,23891,23893,23894,23896],{},[22,23889,23881],{}," 线程数是线程转储或监控中处于 Java ",[22,23892,23881],{}," 状态的线程数量。它可以辅助发现大量活跃任务、忙循环或线程池膨胀，但不能单独等同于“正在占用 CPU 的线程数”：Java 的 ",[22,23895,23881],{}," 同时覆盖正在执行 Java 代码以及部分处于原生调用中的线程，最终仍要结合线程级 CPU 和连续栈判断。",[14,23898,23900],{"id":23899},"五线程栈中重点看什么","五、线程栈中重点看什么",[638,23902,23904],{"id":23903},"_1-死循环或条件无法退出","1. 死循环或条件无法退出",[18,23906,23907],{},"典型表现：",[114,23909,23910,23913,23916],{},[117,23911,23912],{},"某个线程长期接近占满一个 CPU 核；",[117,23914,23915],{},"多次线程栈都停在同一段业务代码；",[117,23917,23918],{},"请求量下降后 CPU 仍不回落。",[18,23920,1398],{},[95,23922,23924],{"className":135,"code":23923,"language":137,"meta":101,"style":101},"while (running) {\n if (queue.poll() == null) {\n continue;\n }\n}\n",[22,23925,23926,23933,23951,23958,23962],{"__ignoreMap":101},[141,23927,23928,23930],{"class":143,"line":144},[141,23929,4277],{"class":151},[141,23931,23932],{"class":147}," (running) {\n",[141,23934,23935,23937,23940,23942,23944,23947,23949],{"class":143,"line":165},[141,23936,4696],{"class":151},[141,23938,23939],{"class":147}," (queue.",[141,23941,4994],{"class":158},[141,23943,16196],{"class":147},[141,23945,23946],{"class":151},"==",[141,23948,4705],{"class":428},[141,23950,507],{"class":147},[141,23952,23953,23956],{"class":143,"line":210},[141,23954,23955],{"class":151}," continue",[141,23957,8560],{"class":147},[141,23959,23960],{"class":143,"line":219},[141,23961,244],{"class":147},[141,23963,23964],{"class":143,"line":234},[141,23965,250],{"class":147},[18,23967,23968],{},"队列为空时仍然持续空转。可以根据场景改为阻塞队列、条件等待或带退避的重试。",[638,23970,23972],{"id":23971},"_2-无上限重试","2. 无上限重试",[18,23974,23975],{},"例如远程调用或 CAS 更新失败后立即重试：",[95,23977,23979],{"className":135,"code":23978,"language":137,"meta":101,"style":101},"while (!success) {\n success = callRemoteService();\n}\n",[22,23980,23981,23992,24004],{"__ignoreMap":101},[141,23982,23983,23985,23987,23989],{"class":143,"line":144},[141,23984,4277],{"class":151},[141,23986,4965],{"class":147},[141,23988,18167],{"class":151},[141,23990,23991],{"class":147},"success) {\n",[141,23993,23994,23997,23999,24002],{"class":143,"line":165},[141,23995,23996],{"class":147}," success ",[141,23998,152],{"class":151},[141,24000,24001],{"class":158}," callRemoteService",[141,24003,162],{"class":147},[141,24005,24006],{"class":143,"line":210},[141,24007,250],{"class":147},[18,24009,24010],{},"当下游持续失败时，它会形成重试风暴。应设置最大次数、指数退避、随机抖动、熔断和失败后的补偿路径。",[638,24012,24014],{"id":24013},"_3-正则表达式回溯","3. 正则表达式回溯",[18,24016,24017],{},"复杂正则在特定输入下可能产生大量回溯，线程栈常出现：",[95,24019,24022],{"className":24020,"code":24021,"language":100,"meta":101},[98],"java.util.regex.Pattern\njava.util.regex.Matcher\n",[22,24023,24021],{"__ignoreMap":101},[18,24025,24026],{},"需要结合具体表达式、输入数据和耗时复现，不能简单认为所有正则调用都有问题。",[638,24028,24030],{"id":24029},"_4-序列化压缩加解密和大集合计算","4. 序列化、压缩、加解密和大集合计算",[18,24032,24033],{},"常见热点包括：",[114,24035,24036,24039,24042,24045,24048],{},[117,24037,24038],{},"大 JSON 的序列化和反序列化；",[117,24040,24041],{},"GZIP 压缩与解压；",[117,24043,24044],{},"哈希、签名和加解密；",[117,24046,24047],{},"大集合排序、去重和嵌套遍历；",[117,24049,24050],{},"图片、音视频或文档转换。",[18,24052,24053],{},"这类问题通常不是线程异常，而是单位请求计算量过大或流量超过容量。需要从算法、数据规模、缓存、批次和并行度处理。",[638,24055,24057],{"id":24056},"_5-异常和日志风暴","5. 异常和日志风暴",[18,24059,24060],{},"频繁创建异常会生成堆栈信息；大量同步日志还会增加格式化、锁和 I\u002FO 开销。监控中常伴随：",[114,24062,24063,24066,24069,24072],{},[117,24064,24065],{},"异常计数骤增；",[117,24067,24068],{},"日志量骤增；",[117,24070,24071],{},"相同错误重复打印；",[117,24073,24074],{},"CPU 与错误率同步上升。",[18,24076,24077],{},"应修复异常根因，同时对可预期失败避免无意义的完整堆栈，并对重复日志做采样或限速。",[14,24079,24081],{"id":24080},"六没有明显热点线程时怎么办","六、没有明显热点线程时怎么办",[18,24083,24084],{},"线程 ID 与线程栈关联适合定位持续占用 CPU 的线程，但以下场景可能看不到稳定热点：",[114,24086,24087,24090,24093,24096,24099],{},[117,24088,24089],{},"大量短任务分散到多个线程；",[117,24091,24092],{},"热点线程变化很快；",[117,24094,24095],{},"问题只持续几十秒；",[117,24097,24098],{},"CPU 消耗发生在 GC、JIT、原生库或内核中；",[117,24100,24101],{},"CPU 时间分散在多个方法上，没有单一调用栈长期占用 CPU。",[18,24103,24104],{},"这时更适合使用采样分析。",[638,24106,24108],{"id":24107},"_1-使用-jfr","1. 使用 JFR",[18,24110,24111,24112,24115],{},"JFR（Java Flight Recorder）是 JDK 内置的低开销事件记录器。它会在一段时间内记录 CPU 采样、线程、GC、对象分配、同步和 I\u002FO 等事件，生成 ",[22,24113,24114],{},".jfr"," 文件，再通过 JDK Mission Control 分析时间趋势、热点方法和调用关系。这里所说的“一段 JFR 记录”，就是限定时间采集到的一份 JVM 运行现场。",[18,24117,24118],{},"可以对运行中的 JVM 启动一段性能记录：",[95,24120,24122],{"className":7782,"code":24121,"language":7784,"meta":101,"style":101},"jcmd \u003Cpid> JFR.start name=cpu-check settings=profile duration=60s filename=\u002Ftmp\u002Fcpu-check.jfr\n",[22,24123,24124],{"__ignoreMap":101},[141,24125,24126,24128,24130,24132,24134,24136,24139,24142,24145,24148],{"class":143,"line":144},[141,24127,22006],{"class":158},[141,24129,22009],{"class":151},[141,24131,22012],{"class":911},[141,24133,22015],{"class":147},[141,24135,9174],{"class":151},[141,24137,24138],{"class":911}," JFR.start",[141,24140,24141],{"class":911}," name=cpu-check",[141,24143,24144],{"class":911}," settings=profile",[141,24146,24147],{"class":911}," duration=60s",[141,24149,24150],{"class":911}," filename=\u002Ftmp\u002Fcpu-check.jfr\n",[18,24152,24153],{},"在 JDK Mission Control 中重点查看：",[114,24155,24156,24162,24168,24171,24174],{},[117,24157,24158,24161],{},[22,24159,24160],{},"jdk.CPULoad","：JVM 和机器 CPU 趋势；",[117,24163,24164,24167],{},[22,24165,24166],{},"jdk.ThreadCPULoad","：线程 CPU 使用；",[117,24169,24170],{},"Hot Methods：热点方法；",[117,24172,24173],{},"Call Tree：热点方法的调用来源；",[117,24175,24176],{},"GC、分配、锁竞争和线程事件。",[18,24178,24179,24180,24183,24184,24187,24188,24190],{},"JFR 是采样和事件记录工具，不保证每次短暂热点都能被完整捕获。",[22,24181,24182],{},"default"," 配置偏向持续、低开销记录，",[22,24185,24186],{},"profile"," 配置会采集更多性能信息，开销也相对更高。采样数量过少时，应延长记录时间或在可控范围内使用 ",[22,24189,24186],{}," 配置。",[638,24192,24194],{"id":24193},"_2-使用-async-profiler","2. 使用 async-profiler",[18,24196,24197],{},"async-profiler 是面向 HotSpot JVM 的低开销采样分析器，可以按固定频率采集 CPU、分配、锁等事件，并输出火焰图。这里所说的“一段 async-profiler 记录”，是指在问题发生期间采样数十秒，将大量调用栈汇总为热点分布，而不是只抓取某一个瞬间的线程栈。",[18,24199,24200],{},"CPU 火焰图示例：",[95,24202,24204],{"className":7782,"code":24203,"language":7784,"meta":101,"style":101},"asprof -e cpu -d 30 -f \u002Ftmp\u002Fcpu-flamegraph.html \u003Cpid>\n",[22,24205,24206],{"__ignoreMap":101},[141,24207,24208,24211,24214,24217,24220,24223,24226,24229,24231,24233,24235],{"class":143,"line":144},[141,24209,24210],{"class":158},"asprof",[141,24212,24213],{"class":428}," -e",[141,24215,24216],{"class":911}," cpu",[141,24218,24219],{"class":428}," -d",[141,24221,24222],{"class":428}," 30",[141,24224,24225],{"class":428}," -f",[141,24227,24228],{"class":911}," \u002Ftmp\u002Fcpu-flamegraph.html",[141,24230,22009],{"class":151},[141,24232,22012],{"class":911},[141,24234,22015],{"class":147},[141,24236,3108],{"class":151},[18,24238,24239],{},"火焰图中：",[114,24241,24242,24245,24248,24251],{},[117,24243,24244],{},"横向宽度表示该调用栈被采样到的比例，不表示时间先后；",[117,24246,24247],{},"纵向表示调用栈深度；",[117,24249,24250],{},"越宽的方法越值得优先分析；",[117,24252,24253],{},"应从宽栈向下查看是谁调用了热点方法，而不是只修改最顶部的方法。",[18,24255,24256],{},"async-profiler 还能看到部分原生和内核栈，适合 Java 栈无法解释 CPU 去向的场景。",[14,24258,24260],{"id":24259},"七判断是不是-gc-导致-cpu-高","七、判断是不是 GC 导致 CPU 高",[18,24262,24263],{},"对象创建速度过快时，GC 线程可能消耗大量 CPU。此时通常同时出现：",[114,24265,24266,24269,24272,24275,24278],{},[117,24267,24268],{},"分配速率明显升高；",[117,24270,24271],{},"Young GC 变得频繁；",[117,24273,24274],{},"GC CPU 占比升高；",[117,24276,24277],{},"吞吐下降但堆未必持续增长；",[117,24279,24280],{},"热点线程可能是 GC 工作线程，而不是业务线程。",[18,24282,8323,24283,24286],{},[64,24284,24285],{},"GC CPU"," 是诊断中的简写，不是所有平台都具有完全一致口径的单一 JVM 指标。它通常表示 GC 线程执行并发标记、复制、整理、引用处理等垃圾回收工作所消耗的 CPU 时间或 CPU 占比。",[18,24288,24289],{},"GC CPU 与 GC 停顿不是同一个概念：停顿时间描述应用线程被暂停多久，GC CPU 描述垃圾回收工作消耗了多少计算资源。并发收集器可能在停顿不长时仍消耗较多 CPU，因此要把 GC 日志中的次数和阶段、JFR 的 GC 事件、进程或线程 CPU，以及分配速率结合起来判断。",[18,24291,24292],{},"GC 日志不是业务代码通过日志框架主动打印的，而是 JVM 自身输出的诊断日志，但通常需要在 JVM 启动参数中提前开启。JDK 9 及以上可以使用统一日志参数，例如：",[95,24294,24296],{"className":7782,"code":24295,"language":7784,"meta":101,"style":101},"-Xlog:gc*:file=\u002Fvar\u002Flog\u002Fapp\u002Fgc.log:time,uptime,level,tags:filecount=10,filesize=100M\n",[22,24297,24298],{"__ignoreMap":101},[141,24299,24300,24303],{"class":143,"line":144},[141,24301,24302],{"class":158},"-Xlog:gc*:file",[141,24304,24305],{"class":911},"=\u002Fvar\u002Flog\u002Fapp\u002Fgc.log:time,uptime,level,tags:filecount=10,filesize=100M\n",[18,24307,24308],{},"如果故障前没有开启 GC 日志，就无法事后补回完整的历史 GC 明细，只能结合现有监控、JFR 记录和当前 JVM 状态分析。因此生产环境应提前配置 GC 日志轮转，避免日志无限增长。",[18,24310,24311],{},"需要结合 GC 日志、JFR 和分配采样分析：",[95,24313,24315],{"className":7782,"code":24314,"language":7784,"meta":101,"style":101},"jcmd \u003Cpid> GC.heap_info\njcmd \u003Cpid> GC.class_histogram\n",[22,24316,24317,24331],{"__ignoreMap":101},[141,24318,24319,24321,24323,24325,24327,24329],{"class":143,"line":144},[141,24320,22006],{"class":158},[141,24322,22009],{"class":151},[141,24324,22012],{"class":911},[141,24326,22015],{"class":147},[141,24328,9174],{"class":151},[141,24330,22035],{"class":911},[141,24332,24333,24335,24337,24339,24341,24343],{"class":143,"line":165},[141,24334,22006],{"class":158},[141,24336,22009],{"class":151},[141,24338,22012],{"class":911},[141,24340,22015],{"class":147},[141,24342,9174],{"class":151},[141,24344,22050],{"class":911},[18,24346,24347,24350],{},[22,24348,24349],{},"GC.class_histogram"," 可能带来额外开销，不应在高压环境下无节制频繁执行。更重要的是确认哪些调用路径在高速分配对象，而不是只观察当前对象数量。",[18,24352,24353],{},"常见修复方向：",[114,24355,24356,24359,24362,24365,24368],{},[117,24357,24358],{},"减少循环内临时对象；",[117,24360,24361],{},"避免不必要的装箱、字符串拼接和重复序列化；",[117,24363,24364],{},"限制查询结果、批次和消息大小；",[117,24366,24367],{},"复用代价高但线程安全的对象；",[117,24369,24370],{},"根据真实存活集和分配速率重新评估堆与 GC 参数。",[18,24372,24373],{},"不要在没有证据时首先调整 GC 参数。很多所谓的“GC 问题”，根因其实是业务代码制造对象的速度过快。",[14,24375,24377],{"id":24376},"八线程和锁也可能把-cpu-推高","八、线程和锁也可能把 CPU 推高",[638,24379,24381],{"id":24380},"_1-线程数量过多","1. 线程数量过多",[18,24383,24384],{},"线程越多不代表吞吐越高。大量可运行线程会产生：",[114,24386,24387,24390,24393,24396,24399],{},[117,24388,24389],{},"上下文切换；",[117,24391,24392],{},"调度开销；",[117,24394,24395],{},"CPU 缓存失效；",[117,24397,24398],{},"线程栈和原生内存占用；",[117,24400,24401],{},"请求超时后继续执行，形成任务堆积。",[18,24403,24404],{},"可以观察：",[95,24406,24408],{"className":7782,"code":24407,"language":7784,"meta":101,"style":101},"pidstat -w -p \u003Cpid> 1\nps -p \u003Cpid> -o nlwp\n",[22,24409,24410,24429],{"__ignoreMap":101},[141,24411,24412,24414,24417,24419,24421,24423,24425,24427],{"class":143,"line":144},[141,24413,23394],{"class":158},[141,24415,24416],{"class":428}," -w",[141,24418,23603],{"class":428},[141,24420,22009],{"class":151},[141,24422,22012],{"class":911},[141,24424,22015],{"class":147},[141,24426,9174],{"class":151},[141,24428,11261],{"class":428},[141,24430,24431,24433,24435,24437,24439,24441,24443,24445],{"class":143,"line":165},[141,24432,22656],{"class":158},[141,24434,23603],{"class":428},[141,24436,22009],{"class":151},[141,24438,22012],{"class":911},[141,24440,22015],{"class":147},[141,24442,9174],{"class":151},[141,24444,23639],{"class":428},[141,24446,24447],{"class":911}," nlwp\n",[18,24449,24450,24453],{},[22,24451,24452],{},"pidstat -w"," 用于查看任务切换活动，常见字段包括：",[1309,24455,24456,24464],{},[1312,24457,24458],{},[1315,24459,24460,24462],{},[1318,24461,2344],{},[1318,24463,2347],{},[1328,24465,24466,24476],{},[1315,24467,24468,24473],{},[1333,24469,24470],{},[22,24471,24472],{},"cswch\u002Fs",[1333,24474,24475],{},"每秒自愿上下文切换次数，例如线程因为等待锁、I\u002FO 或条件而主动让出 CPU",[1315,24477,24478,24483],{},[1333,24479,24480],{},[22,24481,24482],{},"nvcswch\u002Fs",[1333,24484,24485],{},"每秒非自愿上下文切换次数，例如线程时间片用完或被更高优先级任务抢占",[18,24487,24488],{},"切换次数升高本身不是根因，但如果它与线程数、CPU 和延迟同步激增，通常说明线程过多、锁竞争频繁或调度压力增大。",[18,24490,24491,24494],{},[22,24492,24493],{},"nlwp"," 表示轻量级进程数量，在 Linux 上可近似理解为该进程的线程数。",[638,24496,24498],{"id":24497},"_2-cas-自旋和热点竞争","2. CAS 自旋和热点竞争",[18,24500,24501],{},"CAS 失败后通常需要重试。多个线程持续竞争同一个变量时，可能产生大量失败和自旋，CPU 很高但有效吞吐不高。",[18,24503,24504,24505,24508],{},"例如高并发统计可以考虑 ",[22,24506,24507],{},"LongAdder"," 分散热点；业务状态更新则要重新评估数据分片、临界区、锁粒度和是否真的需要所有线程竞争同一资源。",[638,24510,24512],{"id":24511},"_3-锁竞争为什么不一定直接表现为高-cpu","3. 锁竞争为什么不一定直接表现为高 CPU",[18,24514,24515],{},"普通阻塞锁竞争中的线程可能进入等待状态，CPU 不一定高；但以下情况可能提高 CPU：",[114,24517,24518,24521,24524,24527],{},[117,24519,24520],{},"自旋锁或轻量级锁长时间竞争；",[117,24522,24523],{},"大量线程频繁唤醒又重新阻塞；",[117,24525,24526],{},"临界区过小但竞争极其频繁；",[117,24528,24529],{},"公平竞争和线程调度造成大量切换。",[18,24531,24532,24533,4878],{},"因此要结合 JFR 同步事件、线程状态、上下文切换和吞吐判断，而不是只看线程栈里是否出现 ",[22,24534,24535],{},"BLOCKED",[18,24537,24538],{},"JFR 中常用的同步与等待事件包括：",[1309,24540,24541,24551],{},[1312,24542,24543],{},[1315,24544,24545,24548],{},[1318,24546,24547],{},"事件",[1318,24549,24550],{},"主要表示什么",[1328,24552,24553,24566,24580],{},[1315,24554,24555,24560],{},[1333,24556,24557],{},[22,24558,24559],{},"jdk.JavaMonitorEnter",[1333,24561,24562,24563,24565],{},"线程进入 ",[22,24564,1967],{}," 监视器时发生了阻塞，可用于分析锁竞争",[1315,24567,24568,24573],{},[1333,24569,24570],{},[22,24571,24572],{},"jdk.JavaMonitorWait",[1333,24574,24575,24576,24579],{},"线程执行 ",[22,24577,24578],{},"Object.wait()"," 后等待监视器通知或超时",[1315,24581,24582,24587],{},[1333,24583,24584],{},[22,24585,24586],{},"jdk.ThreadPark",[1333,24588,24589,24590,24593],{},"线程通过 ",[22,24591,24592],{},"LockSupport.park()"," 等机制进入等待，AQS 锁和并发组件经常使用它",[18,24595,24596],{},"这些事件是否记录以及记录多短的等待，取决于所使用的 JFR 配置和事件阈值。分析时要关注累计等待时间、事件次数、关联线程和调用栈，不能把正常的短暂等待都判断为性能问题。",[14,24598,24600],{"id":24599},"九区分-cpu-使用率饱和度和业务压力","九、区分 CPU 使用率、饱和度和业务压力",[18,24602,24603],{},"CPU 使用率高本身不一定是故障。如果系统在高流量下：",[114,24605,24606,24609,24612,24615,24618],{},[117,24607,24608],{},"吞吐正常；",[117,24610,24611],{},"P99 延迟可接受；",[117,24613,24614],{},"错误率稳定；",[117,24616,24617],{},"没有明显排队和超时；",[117,24619,24620],{},"CPU 仍保留安全余量；",[18,24622,24623],{},"那么它可能只是有效使用计算资源。",[18,24625,24626],{},"真正需要警惕的是：",[114,24628,24629,24632,24635,24638,24641,24644,24647],{},[117,24630,24631],{},"CPU 长时间接近上限；",[117,24633,24634],{},"Run Queue 持续增长；",[117,24636,24637],{},"延迟和超时显著上升；",[117,24639,24640],{},"吞吐不再增加；",[117,24642,24643],{},"容器 CPU 限流持续加重；",[117,24645,24646],{},"单实例负载明显倾斜；",[117,24648,24649],{},"流量下降后 CPU 无法恢复。",[18,24651,24652],{},"处理时应把 CPU 与 QPS、任务速率、延迟、错误率和实例数放在同一时间线上分析。",[18,24654,24655,24656,24658,24659,24662],{},"**Run Queue（运行队列）**可以理解为已经具备运行条件、正在使用 CPU 或正在等待 CPU 时间片的任务数量。在 ",[22,24657,23404],{}," 中通常观察 ",[22,24660,24661],{},"r"," 列。它不是线程池任务队列，也不包含普通的休眠线程。",[18,24664,24665,24666,24668],{},"判断 Run Queue 是否异常要结合 CPU 核数：短时波动很常见；如果 ",[22,24667,24661],{}," 长时间明显高于可用 CPU 核数，同时 CPU 接近饱和、延迟上升，说明可运行任务持续排队，系统已经出现 CPU 调度压力。",[14,24670,24672],{"id":24671},"十常见场景与证据对应","十、常见场景与证据对应",[1309,24674,24675,24687],{},[1312,24676,24677],{},[1315,24678,24679,24681,24684],{},[1318,24680,1795],{},[1318,24682,24683],{},"重点证据",[1318,24685,24686],{},"常见根因",[1328,24688,24689,24700,24711,24722,24736,24751,24765],{},[1315,24690,24691,24694,24697],{},[1333,24692,24693],{},"单个线程稳定占满一个核",[1333,24695,24696],{},"热点 TID + 多份线程栈",[1333,24698,24699],{},"死循环、重试、单线程热点计算",[1315,24701,24702,24705,24708],{},[1333,24703,24704],{},"多个业务线程共同升高",[1333,24706,24707],{},"JFR、CPU 火焰图、请求量",[1333,24709,24710],{},"流量增长、序列化、压缩、算法热点",[1315,24712,24713,24716,24719],{},[1333,24714,24715],{},"GC 线程 CPU 高",[1333,24717,24718],{},"GC 日志、JFR、分配火焰图",[1333,24720,24721],{},"分配速率过高、存活对象过多",[1315,24723,24724,24727,24733],{},[1333,24725,24726],{},"线程数与切换次数激增",[1333,24728,24729,24730,24732],{},"线程数、",[22,24731,24452],{},"、线程栈",[1333,24734,24735],{},"线程池失控、任务堆积、阻塞补偿过度",[1315,24737,24738,24741,24748],{},[1333,24739,24740],{},"机器 CPU 高但 JVM CPU 低",[1333,24742,24743,24744,44,24746],{},"进程 CPU、",[22,24745,23381],{},[22,24747,23394],{},[1333,24749,24750],{},"其他进程、内核、中断或宿主机问题",[1315,24752,24753,24756,24762],{},[1333,24754,24755],{},"CPU 未满但延迟很高",[1333,24757,24758,24759,24761],{},"cgroup ",[22,24760,23576],{},"、容器 limit",[1333,24763,24764],{},"容器 CPU 限流或配额过低",[1315,24766,24767,24770,24773],{},[1333,24768,24769],{},"CPU 高且异常日志暴增",[1333,24771,24772],{},"异常指标、日志速率、火焰图",[1333,24774,24775],{},"异常堆栈生成、重复日志和失败重试",[14,24777,24779],{"id":24778},"十一修复后的验证","十一、修复后的验证",[18,24781,24782],{},"修复完成后至少验证：",[2489,24784,24785,24788,24791,24794,24797,24800,24803,24806],{},[117,24786,24787],{},"相同或更高流量下 CPU 是否恢复到合理范围；",[117,24789,24790],{},"吞吐、平均延迟和 P99 延迟是否改善；",[117,24792,24793],{},"错误率和超时率是否恢复；",[117,24795,24796],{},"GC 频率、分配速率和 GC 线程 CPU 是否正常；",[117,24798,24799],{},"线程数和上下文切换是否稳定；",[117,24801,24802],{},"容器 CPU 限流是否下降；",[117,24804,24805],{},"降峰后 CPU 是否能够及时回落；",[117,24807,24808],{},"是否出现把 CPU 问题转移成内存、队列积压或下游压力的问题。",[18,24810,24811],{},"不能只看某个热点方法消失就宣布修复。优化可能降低单次计算成本，也可能只是把任务积压到了队列或下游系统。",[14,24813,24815],{"id":24814},"十二预防与监控","十二、预防与监控",[18,24817,24818],{},"建议建立以下监控：",[114,24820,24821,24824,24827,24830,24833,24836,24839,24842,24845],{},[117,24822,24823],{},"机器、容器和 JVM 进程 CPU；",[117,24825,24826],{},"用户态、内核态、I\u002FO wait 和 steal time；",[117,24828,24829],{},"CPU request、limit 与容器 CPU 限流；",[117,24831,24832],{},"线程总数、RUNNABLE 线程数和上下文切换；",[117,24834,24835],{},"GC 线程 CPU、停顿、频率和分配速率；",[117,24837,24838],{},"接口 QPS、任务速率、延迟和错误率；",[117,24840,24841],{},"消息积压、线程池活跃线程、队列长度和拒绝次数；",[117,24843,24844],{},"异常数量和日志写入速率；",[117,24846,24847],{},"单实例负载分布。",[18,24849,24850,24851,6067,24854,24857,24858,24860,24861,24190],{},"对于偶发且持续时间很短的问题，可以考虑常态化开启低开销的 JFR 连续记录。连续记录是让 JFR 在后台长期以较低开销采集事件，并通过 ",[22,24852,24853],{},"maxage",[22,24855,24856],{},"maxsize"," 维护一个循环缓冲区；旧数据会被自动覆盖，告警发生后再导出最近数小时的运行现场。长期记录通常使用偏低开销的 ",[22,24859,24182],{}," 配置，需要更细采样时再短时开启 ",[22,24862,24186],{},[14,24864,24866],{"id":24865},"十三常见误区","十三、常见误区",[638,24868,24870],{"id":24869},"_1-cpu-高就立即扩容","1. CPU 高就立即扩容",[18,24872,24873],{},"扩容可以缓解容量不足，但无法根治死循环、重试风暴或热点数据倾斜。异常逻辑可能在每个新实例上再次出现。",[638,24875,24877],{"id":24876},"_2-只抓一份线程栈","2. 只抓一份线程栈",[18,24879,24880],{},"单个快照不能证明某个线程持续占用 CPU，应连续采样并与线程 CPU 数据关联。",[638,24882,24884],{"id":24883},"_3-只看线程状态","3. 只看线程状态",[18,24886,24887,24889,24890,24892],{},[22,24888,23881],{}," 不等于线程一定正在消耗大量 CPU。Java 的 ",[22,24891,23881],{}," 还可能包含正在执行某些原生或网络操作的线程，需要结合 TID CPU、连续线程栈和采样分析。",[638,24894,24896],{"id":24895},"_4-看到-gc-线程就直接调大堆","4. 看到 GC 线程就直接调大堆",[18,24898,24899],{},"堆变大可能降低 GC 频率，也可能增加停顿和资源占用。应先确认分配热点、存活对象和容量模型。",[638,24901,24903],{"id":24902},"_5-在线上长时间开启重型分析","5. 在线上长时间开启重型分析",[18,24905,24906],{},"诊断工具本身也有开销。应优先使用低开销采样，限定持续时间和输出大小，并评估目标实例当前承压能力。",[14,24908,24910],{"id":24909},"十四推荐排查顺序","十四、推荐排查顺序",[18,24912,24913],{},"可以记成下面这条主线：",[95,24915,24918],{"className":24916,"code":24917,"language":100,"meta":101},[98],"止损并保留现场\n ↓\n确认机器、容器、进程哪一层 CPU 高\n ↓\n确认是否为 Java 进程\n ↓\n找到高 CPU TID，并与线程栈 nid 对应\n ↓\n连续线程栈仍不明确时，使用 JFR 或 async-profiler\n ↓\n结合 GC、线程数、锁、流量和容器限流定位根因\n ↓\n修复后用真实负载验证，并补齐监控和容量保护\n",[22,24919,24917],{"__ignoreMap":101},[14,24921,5605],{"id":5605},[114,24923,24924,24931,24938,24945,24952,24959,24966,24973,24980],{},[117,24925,24926],{},[73,24927,24930],{"href":24928,"rel":24929},"https:\u002F\u002Fdocs.oracle.com\u002Fen\u002Fjava\u002Fjavase\u002F17\u002Ftroubleshoot\u002Ftroubleshoot-process-hangs-and-loops.html",[1876],"Oracle：Troubleshoot Process Hangs and Loops",[117,24932,24933],{},[73,24934,24937],{"href":24935,"rel":24936},"https:\u002F\u002Fdocs.oracle.com\u002Fen\u002Fjava\u002Fjavase\u002F26\u002Ftroubleshoot\u002Ftroubleshoot-performance-issues-using-jfr.html",[1876],"Oracle：Troubleshoot Performance Issues Using Flight Recorder",[117,24939,24940],{},[73,24941,24944],{"href":24942,"rel":24943},"https:\u002F\u002Fdocs.oracle.com\u002Fen\u002Fjava\u002Fjavase\u002F26\u002Fjfapi\u002Fflight-recorder-configurations.html",[1876],"Oracle：Flight Recorder Configurations",[117,24946,24947],{},[73,24948,24951],{"href":24949,"rel":24950},"https:\u002F\u002Fdocs.oracle.com\u002Fen\u002Fjava\u002Fjavase\u002F22\u002Fdocs\u002Fspecs\u002Fman\u002Fjcmd.html",[1876],"Oracle：jcmd Command",[117,24953,24954],{},[73,24955,24958],{"href":24956,"rel":24957},"https:\u002F\u002Fgithub.com\u002Fasync-profiler\u002Fasync-profiler",[1876],"async-profiler 官方项目",[117,24960,24961],{},[73,24962,24965],{"href":24963,"rel":24964},"https:\u002F\u002Fwww.kernel.org\u002Fdoc\u002Fhtml\u002Flatest\u002Fadmin-guide\u002Fcgroup-v2.html",[1876],"Linux Kernel：Control Group v2",[117,24967,24968],{},[73,24969,24972],{"href":24970,"rel":24971},"https:\u002F\u002Fman7.org\u002Flinux\u002Fman-pages\u002Fman1\u002Fmpstat.1.html",[1876],"Linux man-pages：mpstat",[117,24974,24975],{},[73,24976,24979],{"href":24977,"rel":24978},"https:\u002F\u002Fman7.org\u002Flinux\u002Fman-pages\u002Fman1\u002Fpidstat.1.html",[1876],"Linux man-pages：pidstat",[117,24981,24982],{},[73,24983,24986],{"href":24984,"rel":24985},"https:\u002F\u002Fman7.org\u002Flinux\u002Fman-pages\u002Fman8\u002Fvmstat.8.html",[1876],"Linux man-pages：vmstat",[1907,24988,24989],{},"html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .sJ8bj, html code.shiki .sJ8bj{--shiki-default:#6A737D;--shiki-dark:#6A737D}html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}",{"title":101,"searchDepth":165,"depth":165,"links":24991},[24992,24993,24994,24997,24998,24999,25004,25009,25016,25020,25021,25026,25027,25028,25029,25030,25037,25038],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86,"children":24995},[24996],{"id":23168,"depth":210,"text":23169},{"id":23254,"depth":165,"text":23255},{"id":23313,"depth":165,"text":23314},{"id":23358,"depth":165,"text":23359,"children":25000},[25001,25002,25003],{"id":23362,"depth":210,"text":23363},{"id":23549,"depth":210,"text":23550},{"id":23580,"depth":210,"text":23581},{"id":23651,"depth":165,"text":23652,"children":25005},[25006,25007,25008],{"id":23655,"depth":210,"text":23656},{"id":23755,"depth":210,"text":23756},{"id":23871,"depth":210,"text":23872},{"id":23899,"depth":165,"text":23900,"children":25010},[25011,25012,25013,25014,25015],{"id":23903,"depth":210,"text":23904},{"id":23971,"depth":210,"text":23972},{"id":24013,"depth":210,"text":24014},{"id":24029,"depth":210,"text":24030},{"id":24056,"depth":210,"text":24057},{"id":24080,"depth":165,"text":24081,"children":25017},[25018,25019],{"id":24107,"depth":210,"text":24108},{"id":24193,"depth":210,"text":24194},{"id":24259,"depth":165,"text":24260},{"id":24376,"depth":165,"text":24377,"children":25022},[25023,25024,25025],{"id":24380,"depth":210,"text":24381},{"id":24497,"depth":210,"text":24498},{"id":24511,"depth":210,"text":24512},{"id":24599,"depth":165,"text":24600},{"id":24671,"depth":165,"text":24672},{"id":24778,"depth":165,"text":24779},{"id":24814,"depth":165,"text":24815},{"id":24865,"depth":165,"text":24866,"children":25031},[25032,25033,25034,25035,25036],{"id":24869,"depth":210,"text":24870},{"id":24876,"depth":210,"text":24877},{"id":24883,"depth":210,"text":24884},{"id":24895,"depth":210,"text":24896},{"id":24902,"depth":210,"text":24903},{"id":24909,"depth":165,"text":24910},{"id":5605,"depth":165,"text":5605},"wiki:java:java-high-cpu-troubleshooting","从线上止损、确认 CPU 消耗主体、定位高 CPU 线程、关联 Java 栈与火焰图，到死循环、GC、锁竞争、线程膨胀和热点计算分析，系统讲解 Java 服务 CPU 飙高的排查方法。",{},82,"\u002Fjava\u002Fjava-high-cpu-troubleshooting",{"title":23109,"description":25040},"java\u002Fjava-high-cpu-troubleshooting","2026-07-29","rR74pFuh7iWZlh88nnawzfp43Tnwi0qpY3xk0tzgWoI",{"id":25049,"title":25050,"body":25051,"commentId":27293,"description":27294,"difficulty":3462,"draft":1943,"extension":1944,"meta":27295,"navigation":206,"order":27296,"path":27297,"section":1948,"seo":27298,"stem":27299,"updated":27300,"__hash__":27301},"java\u002Fjava\u002Fhow-to-design-a-configuration-center.md","如何设计一个配置中心？",{"type":7,"value":25052,"toc":27231},[25053,25056,25058,25061,25064,25067,25088,25091,25093,25098,25100,25109,25111,25115,25118,25138,25141,25161,25164,25181,25188,25192,25195,25201,25204,25269,25272,25276,25297,25300,25304,25340,25343,25346,25350,25354,25357,25380,25383,25387,25390,25410,25413,25417,25420,25426,25430,25433,25436,25453,25457,25467,25473,25480,25484,25487,25493,25496,25500,25503,25509,25512,25515,25519,25522,25526,25529,25535,25538,25542,25545,25548,25552,25555,25558,25572,25576,25579,25585,25588,25592,25595,25609,25612,25616,25619,25623,25626,25632,25636,25639,25657,25660,25664,25667,25760,25769,25772,25801,25804,25808,25811,25817,25821,25824,25830,25833,25837,25883,25887,25890,25907,25910,25914,25917,25923,25926,25930,25939,25944,25950,25953,25959,25963,26054,26062,26066,26071,26196,26199,26205,26217,26226,26235,26252,26256,26263,26269,26272,26290,26293,26299,26305,26309,26312,26402,26411,26414,26420,26425,26428,26434,26440,26452,26459,26494,26506,26510,26513,26554,26557,26563,26566,26570,26573,26590,26593,26599,26605,26609,26612,26618,26621,26627,26634,26638,26641,26658,26661,26667,26670,26673,26677,26681,26684,26709,26712,26715,26719,26722,26728,26731,26735,26738,26752,26755,26758,26762,26765,26785,26788,26794,26797,26803,26806,26829,26832,26836,26839,26842,26871,26874,26877,26881,26884,26916,26919,26925,26928,26932,27018,27021,27025,27029,27032,27036,27039,27043,27046,27050,27053,27057,27060,27064,27067,27073,27076,27080,27083,27087,27107,27111,27131,27135,27158,27161,27163,27228],[10,25054,25050],{"id":25055},"如何设计一个配置中心",[14,25057,16],{"id":16},[18,25059,25060],{},"设计配置中心时，我会先把系统分成管理面和运行时分发面。管理面负责配置编辑、校验、审批、发布、灰度、回滚、权限和审计；分发面负责客户端查询、变更通知、版本校准和本地容灾。配置按照环境、租户、应用、命名空间和配置标识进行隔离，每次发布都生成不可变版本，数据库保存权威的已发布快照和历史记录。",[18,25062,25063],{},"发布时不能直接覆盖线上值，而应经过“编辑草稿、格式与规则校验、审批、事务生成新版本、写变更事件、通知客户端”的流程。客户端启动时主动拉取完整快照，运行期间通过长轮询或长连接监听变化；服务端通常只通知配置标识和版本，客户端再拉取内容。为了防止通知丢失，客户端还要定时校准版本。",[18,25065,25066],{},"客户端获取新配置后，应先校验版本、格式和完整性，再原子替换内存快照并落盘保存最后一次正确版本，然后通知业务监听器。配置中心不可用时，已运行实例继续使用内存配置，新实例优先读取本地快照；如果关键配置既无法远程获取也没有本地快照，应按业务要求失败退出，而不是用不明确的默认值启动。",[18,25068,25069,25070,25072,25073,25076,25077,25080,25081,25083,25084,25087],{},"在 Spring 应用中，配置中心 SDK 获取新版本只是第一步。集成层还需要先更新 Spring ",[22,25071,20436],{}," 中对应的 ",[22,25074,25075],{},"PropertySource","，再发布变更事件，使 ",[22,25078,25079],{},"@ConfigurationProperties"," 重新绑定；对于只在 Bean 创建时注入的 ",[22,25082,19625],{}," 或需要整体重建的组件，则应通过 ",[22,25085,25086],{},"@RefreshScope","、显式监听器或不可变配置对象原子替换来应用新值。",[18,25089,25090],{},"高可用方面，配置读取和通知服务应无状态多实例部署，权威存储使用高可用数据库或一致性存储；服务端和客户端都要有缓存，通知链路需要重试和定时校准兜底。平台还必须具备灰度发布、版本回滚、RBAC、敏感信息保护、操作审计、客户端版本观测、容量限制和发布成功率监控。",[18,25092,57],{},[59,25094,25095],{},[18,25096,25097],{},"配置中心的核心不是保存 Key-Value，而是让正确的配置经过可审计的发布流程，以版本化、可恢复的方式安全送达客户端。",[14,25099,69],{"id":69},[18,25101,25102],{},[73,25103,25106],{"href":25104,"target":76,"rel":25105},"\u002Fimages\u002Fwiki\u002Fjava\u002Fhow-to-design-a-configuration-center.svg",[78,79],[81,25107],{"src":25104,"alt":25108},"配置中心管理面、发布链路、运行时分发、客户端容灾和安全治理总览",[14,25110,86],{"id":86},[14,25112,25114],{"id":25113},"一先明确配置中心要解决什么","一、先明确配置中心要解决什么",[18,25116,25117],{},"配置中心主要解决以下问题：",[114,25119,25120,25123,25126,25129,25132,25135],{},[117,25121,25122],{},"不重新构建和部署应用，也能修改运行参数；",[117,25124,25125],{},"集中管理不同环境、租户、集群和应用的配置；",[117,25127,25128],{},"让大量应用实例及时感知配置变化；",[117,25130,25131],{},"知道谁在什么时间发布了什么内容；",[117,25133,25134],{},"支持灰度验证、版本回滚和故障恢复；",[117,25136,25137],{},"在配置中心或网络异常时，应用仍能使用最后一次正确配置。",[18,25139,25140],{},"适合放入配置中心的内容包括：",[114,25142,25143,25146,25149,25152,25155,25158],{},[117,25144,25145],{},"功能开关；",[117,25147,25148],{},"超时、重试次数和线程池参数；",[117,25150,25151],{},"业务规则和路由规则；",[117,25153,25154],{},"限流阈值；",[117,25156,25157],{},"非敏感的外部服务地址；",[117,25159,25160],{},"可以安全热更新的运行参数。",[18,25162,25163],{},"以下内容不宜直接混在普通配置中：",[114,25165,25166,25169,25172,25175,25178],{},[117,25167,25168],{},"大文件、图片和安装包；",[117,25170,25171],{},"高频变化的业务状态；",[117,25173,25174],{},"需要复杂查询的业务数据；",[117,25176,25177],{},"密码、私钥、访问令牌等完整生命周期的密钥数据；",[117,25179,25180],{},"修改后必须重启或迁移数据才能生效的参数。",[18,25182,25183,25184,25187],{},"密钥可以在配置中保存引用，例如 ",[22,25185,25186],{},"secret:\u002F\u002Fpayment\u002Fprod\u002Fdb-password","，真实密文由专门的密钥管理系统保存、轮换和审计。配置中心不应被扩展成文档存储、业务数据库或密钥中心。",[14,25189,25191],{"id":25190},"二先做领域模型而不是直接建一张-key-value-表","二、先做领域模型，而不是直接建一张 Key-Value 表",[18,25193,25194],{},"一个通用配置身份可以设计为：",[95,25196,25199],{"className":25197,"code":25198,"language":100,"meta":101},[98],"tenant\n └── environment\n └── application\n └── namespace\n └── config key \u002F document\n",[22,25200,25198],{"__ignoreMap":101},[18,25202,25203],{},"各维度的作用：",[1309,25205,25206,25216],{},[1312,25207,25208],{},[1315,25209,25210,25213],{},[1318,25211,25212],{},"维度",[1318,25214,25215],{},"作用",[1328,25217,25218,25228,25238,25247,25257],{},[1315,25219,25220,25225],{},[1333,25221,25222],{},[22,25223,25224],{},"tenant",[1333,25226,25227],{},"隔离不同租户或组织",[1315,25229,25230,25235],{},[1333,25231,25232],{},[22,25233,25234],{},"environment",[1333,25236,25237],{},"隔离开发、测试、预发和生产环境",[1315,25239,25240,25244],{},[1333,25241,25242],{},[22,25243,21414],{},[1333,25245,25246],{},"标识配置归属的应用",[1315,25248,25249,25254],{},[1333,25250,25251],{},[22,25252,25253],{},"namespace",[1333,25255,25256],{},"按模块或用途组织配置，并支持共享配置",[1315,25258,25259,25266],{},[1333,25260,25261,6067,25263],{},[22,25262,11115],{},[22,25264,25265],{},"dataId",[1333,25267,25268],{},"唯一定位一个配置项或配置文档",[18,25270,25271],{},"配置内容有两种常见模型。",[638,25273,25275],{"id":25274},"_1-独立-key-value","1. 独立 Key-Value",[95,25277,25279],{"className":4553,"code":25278,"language":4555,"meta":101,"style":101},"payment.timeout=3000\npayment.retry-count=3\n",[22,25280,25281,25289],{"__ignoreMap":101},[141,25282,25283,25286],{"class":143,"line":144},[141,25284,25285],{"class":151},"payment.timeout",[141,25287,25288],{"class":147},"=3000\n",[141,25290,25291,25294],{"class":143,"line":165},[141,25292,25293],{"class":151},"payment.retry-count",[141,25295,25296],{"class":147},"=3\n",[18,25298,25299],{},"优点是可以单独修改和审计某个配置项；缺点是一次业务变更涉及多个 Key 时，需要额外保证它们作为一个整体发布。",[638,25301,25303],{"id":25302},"_2-配置文档","2. 配置文档",[95,25305,25309],{"className":25306,"code":25307,"language":25308,"meta":101,"style":101},"language-yaml shiki shiki-themes github-light github-dark","payment:\n timeout: 3000\n retry-count: 3\n","yaml",[22,25310,25311,25319,25330],{"__ignoreMap":101},[141,25312,25313,25316],{"class":143,"line":144},[141,25314,25315],{"class":3104},"payment",[141,25317,25318],{"class":147},":\n",[141,25320,25321,25324,25327],{"class":143,"line":165},[141,25322,25323],{"class":3104}," timeout",[141,25325,25326],{"class":147},": ",[141,25328,25329],{"class":428},"3000\n",[141,25331,25332,25335,25337],{"class":143,"line":210},[141,25333,25334],{"class":3104}," retry-count",[141,25336,25326],{"class":147},[141,25338,25339],{"class":428},"3\n",[18,25341,25342],{},"整个 YAML、JSON 或 Properties 文档作为一个发布单元，天然适合原子替换一组相关配置，但文档过大时会增加传输、对比和解析成本。",[18,25344,25345],{},"工程中可以同时支持两种模型，但必须明确最小发布单元。客户端不能先看到新超时、后看到旧重试次数，形成不存在于任何正式版本中的中间状态。",[14,25347,25349],{"id":25348},"三管理面与分发面要分开","三、管理面与分发面要分开",[638,25351,25353],{"id":25352},"_1-管理面","1. 管理面",[18,25355,25356],{},"管理面面向开发、测试和运维人员，负责：",[114,25358,25359,25362,25365,25368,25371,25374,25377],{},[117,25360,25361],{},"应用、环境和命名空间管理；",[117,25363,25364],{},"配置编辑与差异对比；",[117,25366,25367],{},"格式、类型和业务规则校验；",[117,25369,25370],{},"审批与发布；",[117,25372,25373],{},"灰度规则；",[117,25375,25376],{},"历史版本和回滚；",[117,25378,25379],{},"权限与操作审计。",[18,25381,25382],{},"管理接口的 QPS 通常不高，但对权限、数据正确性和审计完整性要求很高。",[638,25384,25386],{"id":25385},"_2-运行时分发面","2. 运行时分发面",[18,25388,25389],{},"分发面面向应用 SDK，负责：",[114,25391,25392,25395,25398,25401,25404,25407],{},[117,25393,25394],{},"查询当前已发布配置；",[117,25396,25397],{},"监听配置变化；",[117,25399,25400],{},"返回版本和校验摘要；",[117,25402,25403],{},"维护服务端缓存；",[117,25405,25406],{},"记录客户端正在使用的版本；",[117,25408,25409],{},"在大量客户端之间高效分发变更。",[18,25411,25412],{},"分发面的特点是读多写少、连接数量大、发布时可能出现瞬时通知扇出。因此应与控制台和管理接口隔离资源，避免一次批量查询或错误发布拖垮所有客户端的配置读取。",[14,25414,25416],{"id":25415},"四配置发布链路怎么设计","四、配置发布链路怎么设计",[18,25418,25419],{},"推荐发布流程：",[95,25421,25424],{"className":25422,"code":25423,"language":100,"meta":101},[98],"编辑草稿\n→ 语法和规则校验\n→ 查看差异\n→ 审批\n→ 生成不可变版本\n→ 更新当前正式版本指针\n→ 写入变更事件\n→ 通知分发节点和客户端\n",[22,25425,25423],{"__ignoreMap":101},[638,25427,25429],{"id":25428},"_1-编辑与发布分离","1. 编辑与发布分离",[18,25431,25432],{},"编辑操作只修改草稿，不能直接影响线上实例。发布才会生成正式版本。",[18,25434,25435],{},"这样可以支持：",[114,25437,25438,25441,25444,25447,25450],{},[117,25439,25440],{},"多次修改后一次发布；",[117,25442,25443],{},"发布前 Diff；",[117,25445,25446],{},"双人复核或审批；",[117,25448,25449],{},"定时发布；",[117,25451,25452],{},"取消未完成的修改。",[638,25454,25456],{"id":25455},"_2-发布必须有版本","2. 发布必须有版本",[18,25458,25459,25460,25463,25464,4039],{},"每次正式发布生成单调递增的 ",[22,25461,25462],{},"revision"," 或唯一 ",[22,25465,25466],{},"releaseId",[95,25468,25471],{"className":25469,"code":25470,"language":100,"meta":101},[98],"revision 101 → timeout=3000\nrevision 102 → timeout=5000\nrevision 103 → timeout=4000\n",[22,25472,25470],{"__ignoreMap":101},[18,25474,25475,25476,25479],{},"回滚到 ",[22,25477,25478],{},"revision 101"," 时，不应删除 102 和 103，也不应把版本号改回 101，而是以 101 的内容生成新版本 104。这样历史始终完整，客户端版本也只向前推进。",[638,25481,25483],{"id":25482},"_3-使用乐观锁防止覆盖","3. 使用乐观锁防止覆盖",[18,25485,25486],{},"两个用户可能同时基于版本 101 编辑。发布接口应携带期望版本：",[95,25488,25491],{"className":25489,"code":25490,"language":100,"meta":101},[98],"publish(\n configId,\n expectedRevision = 101,\n newContent\n)\n",[22,25492,25490],{"__ignoreMap":101},[18,25494,25495],{},"如果当前版本已经是 102，发布应失败并提示重新对比，而不是静默覆盖其他人的修改。这相当于配置发布场景中的 CAS。",[638,25497,25499],{"id":25498},"_4-配置与变更事件要可靠衔接","4. 配置与变更事件要可靠衔接",[18,25501,25502],{},"如果数据库写入成功，但通知事件发送失败，客户端可能无法及时感知变化。可以在同一个数据库事务中写入：",[95,25504,25507],{"className":25505,"code":25506,"language":100,"meta":101},[98],"正式版本\n+ 发布历史\n+ Outbox 变更事件\n",[22,25508,25506],{"__ignoreMap":101},[18,25510,25511],{},"后台任务再可靠投递 Outbox 事件。即使消息系统短暂故障，事件仍可重试。客户端的定时版本校准是最后一道兜底，因此系统正确性不能只依赖一次通知。",[18,25513,25514],{},"Outbox 是“事务发件箱”模式：业务数据和待发送事件先写入同一个数据库事务，事务提交后再由后台任务把事件投递到消息系统。它解决的是“数据库已经提交，但消息没发出去”的双写不一致问题。",[14,25516,25518],{"id":25517},"五为什么通常采用通知变化再主动拉取","五、为什么通常采用“通知变化，再主动拉取”",[18,25520,25521],{},"客户端同步配置有三种方式。",[638,25523,25525],{"id":25524},"_1-定时轮询","1. 定时轮询",[18,25527,25528],{},"客户端每隔固定时间请求服务端：",[95,25530,25533],{"className":25531,"code":25532,"language":100,"meta":101},[98],"当前版本是 101，有更新吗？\n",[22,25534,25532],{"__ignoreMap":101},[18,25536,25537],{},"优点是简单、天然可以修复通知丢失；缺点是实时性与请求量难以兼顾。轮询越频繁，没有发生配置变更却仍然访问服务端的请求越多；间隔越长，配置生效越慢。",[638,25539,25541],{"id":25540},"_2-长轮询","2. 长轮询",[18,25543,25544],{},"客户端发起请求，版本未变化时服务端暂不返回；配置变化或请求超时后再响应。客户端收到响应后立即重新发起下一次监听。",[18,25546,25547],{},"它可以减少无效轮询，并保持较好的变更实时性。Apollo 的经典实现就使用 HTTP Long Polling。",[638,25549,25551],{"id":25550},"_3-长连接推送","3. 长连接推送",[18,25553,25554],{},"客户端与服务端维持 gRPC、WebSocket 或自定义 TCP 长连接。配置变化时，服务端沿连接发送通知。当前 Nacos SDK 的监听采用长连接机制。",[18,25556,25557],{},"长连接实时性更好，但需要处理：",[114,25559,25560,25563,25566,25569],{},[117,25561,25562],{},"连接保活和重连；",[117,25564,25565],{},"服务端连接容量；",[117,25567,25568],{},"网络抖动；",[117,25570,25571],{},"节点迁移。",[638,25573,25575],{"id":25574},"_4-推荐组合","4. 推荐组合",[18,25577,25578],{},"无论使用长轮询还是长连接，都推荐：",[95,25580,25583],{"className":25581,"code":25582,"language":100,"meta":101},[98],"服务端通知：configId + newRevision\n客户端查询：获取 newRevision 对应的完整内容\n定时校准：周期性比较服务端与本地 revision\n",[22,25584,25582],{"__ignoreMap":101},[18,25586,25587],{},"通知只告诉客户端“哪里变了”，不携带大段配置内容。这样能降低扇出流量，也让所有内容读取统一走查询、鉴权、灰度匹配和校验链路。",[14,25589,25591],{"id":25590},"六如何保证客户端最终拿到正确版本","六、如何保证客户端最终拿到正确版本",[18,25593,25594],{},"配置中心通常不是所有链路都强一致。",[114,25596,25597,25600,25603,25606],{},[117,25598,25599],{},"发布事务需要保证版本、历史和当前正式指针原子更新；",[117,25601,25602],{},"配置查询要能读取确定的已发布版本；",[117,25604,25605],{},"变更通知可以最终一致，因为网络和客户端状态不可控；",[117,25607,25608],{},"客户端应用配置应保证单个发布单元原子替换。",[18,25610,25611],{},"客户端需要遵守以下规则：",[638,25613,25615],{"id":25614},"_1-版本只能前进","1. 版本只能前进",[18,25617,25618],{},"如果本地已经应用版本 103，后来收到延迟到达的版本 102 通知，应直接丢弃，不能回退。",[638,25620,25622],{"id":25621},"_2-通知必须幂等","2. 通知必须幂等",[18,25624,25625],{},"同一个版本被重复通知，不应重复执行有副作用的刷新逻辑。客户端可以比较：",[95,25627,25630],{"className":25628,"code":25629,"language":100,"meta":101},[98],"newRevision \u003C= localRevision\n→ 忽略\n",[22,25631,25629],{"__ignoreMap":101},[638,25633,25635],{"id":25634},"_3-内容必须校验","3. 内容必须校验",[18,25637,25638],{},"服务端响应通常携带：",[114,25640,25641,25645,25648,25651,25654],{},[117,25642,25643,2159],{},[22,25644,25462],{},[117,25646,25647],{},"内容类型；",[117,25649,25650],{},"内容摘要，例如 SHA-256；",[117,25652,25653],{},"修改时间；",[117,25655,25656],{},"灰度或正式版本标识。",[18,25658,25659],{},"客户端应先验证内容摘要和格式，再应用新配置。校验失败时继续使用旧版本并告警，不能用半解析数据覆盖当前配置。",[638,25661,25663],{"id":25662},"_4-原子替换快照","4. 原子替换快照",[18,25665,25666],{},"推荐把相关配置解析成不可变对象：",[95,25668,25670],{"className":135,"code":25669,"language":137,"meta":101,"style":101},"final class PaymentConfig {\n private final Duration timeout;\n private final int retryCount;\n\n PaymentConfig(Duration timeout, int retryCount) {\n this.timeout = timeout;\n this.retryCount = retryCount;\n }\n}\n",[22,25671,25672,25683,25692,25704,25708,25729,25741,25752,25756],{"__ignoreMap":101},[141,25673,25674,25676,25678,25681],{"class":143,"line":144},[141,25675,47],{"class":151},[141,25677,196],{"class":151},[141,25679,25680],{"class":158}," PaymentConfig",[141,25682,201],{"class":147},[141,25684,25685,25687,25689],{"class":143,"line":165},[141,25686,481],{"class":151},[141,25688,484],{"class":151},[141,25690,25691],{"class":147}," Duration timeout;\n",[141,25693,25694,25696,25698,25701],{"class":143,"line":210},[141,25695,481],{"class":151},[141,25697,484],{"class":151},[141,25699,25700],{"class":151}," int",[141,25702,25703],{"class":147}," retryCount;\n",[141,25705,25706],{"class":143,"line":219},[141,25707,207],{"emptyLinePlaceholder":206},[141,25709,25710,25713,25716,25719,25721,25724,25727],{"class":143,"line":234},[141,25711,25712],{"class":158}," PaymentConfig",[141,25714,25715],{"class":147},"(Duration ",[141,25717,25718],{"class":503},"timeout",[141,25720,4981],{"class":147},[141,25722,25723],{"class":151},"int",[141,25725,25726],{"class":503}," retryCount",[141,25728,507],{"class":147},[141,25730,25731,25733,25736,25738],{"class":143,"line":241},[141,25732,512],{"class":428},[141,25734,25735],{"class":147},".timeout ",[141,25737,152],{"class":151},[141,25739,25740],{"class":147}," timeout;\n",[141,25742,25743,25745,25748,25750],{"class":143,"line":247},[141,25744,512],{"class":428},[141,25746,25747],{"class":147},".retryCount ",[141,25749,152],{"class":151},[141,25751,25703],{"class":147},[141,25753,25754],{"class":143,"line":307},[141,25755,244],{"class":147},[141,25757,25758],{"class":143,"line":379},[141,25759,250],{"class":147},[18,25761,25762,25763,25765,25766,25768],{},"不可变对象是指：对象完成构造后，其内部可观察状态不能再被修改。常见做法是把字段声明为 ",[22,25764,47],{},"，不提供修改状态的 Setter，并对集合等可变成员进行防御性复制。需要注意，",[22,25767,47],{}," 引用只表示引用不能改指向，并不自动保证它指向的对象不可变。",[18,25770,25771],{},"刷新时先完整构造新对象，最后一次性替换引用：",[95,25773,25775],{"className":135,"code":25774,"language":137,"meta":101,"style":101},"private volatile PaymentConfig currentConfig;\n\ncurrentConfig = newConfig;\n",[22,25776,25777,25787,25791],{"__ignoreMap":101},[141,25778,25779,25781,25784],{"class":143,"line":144},[141,25780,43],{"class":151},[141,25782,25783],{"class":151}," volatile",[141,25785,25786],{"class":147}," PaymentConfig currentConfig;\n",[141,25788,25789],{"class":143,"line":165},[141,25790,207],{"emptyLinePlaceholder":206},[141,25792,25793,25796,25798],{"class":143,"line":210},[141,25794,25795],{"class":147},"currentConfig ",[141,25797,152],{"class":151},[141,25799,25800],{"class":147}," newConfig;\n",[18,25802,25803],{},"读线程要么看到旧快照，要么看到新快照，不会读取到部分更新状态。",[14,25805,25807],{"id":25806},"七客户端-sdk-是可用性的关键","七、客户端 SDK 是可用性的关键",[18,25809,25810],{},"一个可靠的 SDK 至少包含：",[95,25812,25815],{"className":25813,"code":25814,"language":100,"meta":101},[98],"服务寻址\n身份认证\n启动拉取\n内存快照\n本地文件快照\n变更监听\n版本校验\n监听器调度\n定时校准\n指标上报\n",[22,25816,25814],{"__ignoreMap":101},[638,25818,25820],{"id":25819},"_1-启动流程","1. 启动流程",[18,25822,25823],{},"推荐顺序：",[95,25825,25828],{"className":25826,"code":25827,"language":100,"meta":101},[98],"读取本地最后正确快照\n→ 连接配置中心\n→ 拉取当前版本\n→ 校验并更新内存\n→ 建立监听\n→ 启动定时校准\n",[22,25829,25827],{"__ignoreMap":101},[18,25831,25832],{},"本地快照不是权威数据，而是服务端或网络故障时的容灾副本。",[638,25834,25836],{"id":25835},"_2-配置中心不可用时怎么办","2. 配置中心不可用时怎么办",[1309,25838,25839,25849],{},[1312,25840,25841],{},[1315,25842,25843,25846],{},[1318,25844,25845],{},"场景",[1318,25847,25848],{},"推荐行为",[1328,25850,25851,25859,25867,25875],{},[1315,25852,25853,25856],{},[1333,25854,25855],{},"已运行实例与服务端断开",[1333,25857,25858],{},"继续使用当前内存快照，同时重连和告警",[1315,25860,25861,25864],{},[1333,25862,25863],{},"新实例远程拉取失败但存在本地快照",[1333,25865,25866],{},"校验后使用最后正确快照，并标记为降级启动",[1315,25868,25869,25872],{},[1333,25870,25871],{},"关键配置远程拉取失败且没有本地快照",[1333,25873,25874],{},"失败退出，避免用未知默认值运行",[1315,25876,25877,25880],{},[1333,25878,25879],{},"非关键配置缺失",[1333,25881,25882],{},"可以使用经过明确登记的安全默认值",[638,25884,25886],{"id":25885},"_3-业务监听器必须隔离","3. 业务监听器必须隔离",[18,25888,25889],{},"配置变更回调不能直接阻塞 SDK 的网络线程。应通过独立、有界的执行器调用业务监听器，并设置：",[114,25891,25892,25895,25898,25901,25904],{},[117,25893,25894],{},"单次执行超时；",[117,25896,25897],{},"异常隔离；",[117,25899,25900],{},"慢监听器告警；",[117,25902,25903],{},"合并相同配置的连续更新；",[117,25905,25906],{},"必要时只保留最新版本。",[18,25908,25909],{},"如果版本 101、102、103 快速连续发布，而业务只关心当前状态，可以合并中间通知，直接应用 103；如果每个版本都代表必须执行的命令，则它本质上不是配置，应该使用消息系统。",[638,25911,25913],{"id":25912},"_4-spring-应用如何获取并应用最新配置","4. Spring 应用如何获取并应用最新配置",[18,25915,25916],{},"Spring 应用中的完整刷新链路可以分成两层：",[95,25918,25921],{"className":25919,"code":25920,"language":100,"meta":101},[98],"配置中心 SDK\n监听变更 → 拉取新版本 → 校验 revision、格式和摘要 → 更新本地快照\n\nSpring 集成层\n更新 PropertySource → 计算变化的 Key → 发布变更事件\n→ 重新绑定配置对象或重建指定 Bean → 业务代码读取新配置\n",[22,25922,25920],{"__ignoreMap":101},[18,25924,25925],{},"配置中心负责把新内容可靠送到应用，Spring 负责把这些内容接入自己的属性体系并更新使用配置的对象。新配置已经到达客户端，不等于业务 Bean 已经使用新值。",[6264,25927,25929],{"id":25928},"_41-先更新-environment-中的-propertysource","4.1 先更新 Environment 中的 PropertySource",[18,25931,25932,25933,25935,25936,25938],{},"Spring Boot 会把系统属性、环境变量、本地配置文件和远程配置等统一组织到 ",[22,25934,20436],{}," 中，每类来源对应一个或多个 ",[22,25937,25075],{},"，并按照优先级决定最终值。",[18,25940,25941,25942,4039],{},"配置中心 SDK 拉取并校验新版本后，Spring 集成组件需要用新快照替换远程配置对应的 ",[22,25943,25075],{},[95,25945,25948],{"className":25946,"code":25947,"language":100,"meta":101},[98],"旧远程 PropertySource：revision 101\npayment.timeout = 3000\n\n新远程 PropertySource：revision 102\npayment.timeout = 5000\n",[22,25949,25947],{"__ignoreMap":101},[18,25951,25952],{},"替换必须发生在发布变更事件之前。否则监听器已经开始重新绑定，读取到的却仍然是旧值。",[18,25954,25955,25956,25958],{},"还要保留确定的配置源优先级。例如，设计上如果命令行参数应覆盖远程配置，那么刷新时不能把远程 ",[22,25957,25075],{}," 插到命令行参数之前，悄悄改变原有覆盖关系。",[6264,25960,25962],{"id":25961},"_42-environment-更新后不同使用方式的刷新行为不同","4.2 Environment 更新后，不同使用方式的刷新行为不同",[1309,25964,25965,25978],{},[1312,25966,25967],{},[1315,25968,25969,25972,25975],{},[1318,25970,25971],{},"使用方式",[1318,25973,25974],{},"配置变化后的行为",[1318,25976,25977],{},"推荐做法",[1328,25979,25980,25998,26010,26029,26043],{},[1315,25981,25982,25989,25995],{},[1333,25983,25984,25985,25988],{},"每次通过 ",[22,25986,25987],{},"Environment#getProperty"," 读取",[1333,25990,25991,25992,25994],{},"后续读取可以看到新 ",[22,25993,25075],{}," 中的值",[1333,25996,25997],{},"适合少量需要实时读取的简单参数",[1315,25999,26000,26004,26007],{},[1333,26001,26002],{},[22,26003,25079],{},[1333,26005,26006],{},"在 Spring Cloud 的变更事件处理机制下可以重新绑定",[1333,26008,26009],{},"适合一组结构化、需要类型校验的配置",[1315,26011,26012,26017,26023],{},[1333,26013,26014,26015],{},"普通单例 Bean 中的 ",[22,26016,19625],{},[1333,26018,26019,26020,26022],{},"不会仅因 ",[22,26021,20436],{}," 被替换而自动重新注入",[1333,26024,26025,26026,26028],{},"将 Bean 放入 ",[22,26027,25086],{},"，或改用配置对象和显式监听",[1315,26030,26031,26034,26037],{},[1333,26032,26033],{},"初始化时根据配置创建的组件",[1333,26035,26036],{},"已有组件不会自动重建",[1333,26038,26039,26040,26042],{},"通过 ",[22,26041,25086],{}," 重建，或编写明确的组件更新逻辑",[1315,26044,26045,26048,26051],{},[1333,26046,26047],{},"不可变配置快照",[1333,26049,26050],{},"构造新对象后整体替换引用",[1333,26052,26053],{},"适合高并发读取和原子切换",[18,26055,26056,26058,26059,26061],{},[22,26057,19625],{}," 的注入发生在 Bean 创建和属性填充阶段。运行期间即使 ",[22,26060,20436],{}," 已经包含新值，普通单例 Bean 中原来注入的字段也不会因此自动再执行一次注入。",[6264,26063,26065],{"id":26064},"_43-configurationproperties-的绑定与刷新机制","4.3 @ConfigurationProperties 的绑定与刷新机制",[18,26067,26068,26070],{},[22,26069,25079],{}," 用来把具有相同前缀的一组外部属性绑定成一个类型明确的 Java 对象。例如：",[95,26072,26074],{"className":135,"code":26073,"language":137,"meta":101,"style":101},"@ConfigurationProperties(prefix = \"payment\")\npublic class PaymentProperties {\n\n private Duration timeout;\n private int retryCount;\n\n public void setTimeout(Duration timeout) {\n this.timeout = timeout;\n }\n\n public void setRetryCount(int retryCount) {\n this.retryCount = retryCount;\n }\n}\n",[22,26075,26076,26095,26106,26110,26116,26124,26128,26143,26153,26157,26161,26178,26188,26192],{"__ignoreMap":101},[141,26077,26078,26080,26083,26085,26088,26090,26093],{"class":143,"line":144},[141,26079,263],{"class":147},[141,26081,26082],{"class":151},"ConfigurationProperties",[141,26084,908],{"class":147},[141,26086,26087],{"class":428},"prefix",[141,26089,946],{"class":151},[141,26091,26092],{"class":911}," \"payment\"",[141,26094,1481],{"class":147},[141,26096,26097,26099,26101,26104],{"class":143,"line":165},[141,26098,193],{"class":151},[141,26100,196],{"class":151},[141,26102,26103],{"class":158}," PaymentProperties",[141,26105,201],{"class":147},[141,26107,26108],{"class":143,"line":210},[141,26109,207],{"emptyLinePlaceholder":206},[141,26111,26112,26114],{"class":143,"line":219},[141,26113,481],{"class":151},[141,26115,25691],{"class":147},[141,26117,26118,26120,26122],{"class":143,"line":234},[141,26119,481],{"class":151},[141,26121,25700],{"class":151},[141,26123,25703],{"class":147},[141,26125,26126],{"class":143,"line":241},[141,26127,207],{"emptyLinePlaceholder":206},[141,26129,26130,26132,26134,26137,26139,26141],{"class":143,"line":247},[141,26131,222],{"class":151},[141,26133,225],{"class":151},[141,26135,26136],{"class":158}," setTimeout",[141,26138,25715],{"class":147},[141,26140,25718],{"class":503},[141,26142,507],{"class":147},[141,26144,26145,26147,26149,26151],{"class":143,"line":307},[141,26146,512],{"class":428},[141,26148,25735],{"class":147},[141,26150,152],{"class":151},[141,26152,25740],{"class":147},[141,26154,26155],{"class":143,"line":379},[141,26156,244],{"class":147},[141,26158,26159],{"class":143,"line":391},[141,26160,207],{"emptyLinePlaceholder":206},[141,26162,26163,26165,26167,26170,26172,26174,26176],{"class":143,"line":396},[141,26164,222],{"class":151},[141,26166,225],{"class":151},[141,26168,26169],{"class":158}," setRetryCount",[141,26171,908],{"class":147},[141,26173,25723],{"class":151},[141,26175,25726],{"class":503},[141,26177,507],{"class":147},[141,26179,26180,26182,26184,26186],{"class":143,"line":401},[141,26181,512],{"class":428},[141,26183,25747],{"class":147},[141,26185,152],{"class":151},[141,26187,25703],{"class":147},[141,26189,26190],{"class":143,"line":554},[141,26191,244],{"class":147},[141,26193,26194],{"class":143,"line":559},[141,26195,250],{"class":147},[18,26197,26198],{},"应用启动时，其核心过程可以简化为：",[95,26200,26203],{"className":26201,"code":26202,"language":100,"meta":101},[98],"Environment 中的多个 PropertySource\n→ 按优先级解析 payment.* 属性\n→ ConfigurationPropertiesBindingPostProcessor 触发绑定\n→ Binder 完成名称匹配、类型转换和校验\n→ 将结果绑定到 PaymentProperties Bean\n",[22,26204,26202],{"__ignoreMap":101},[18,26206,26207,26210,26211,26213,26214,4878],{},[22,26208,26209],{},"ConfigurationPropertiesBindingPostProcessor"," 是参与 Bean 初始化的后处理器，负责识别需要进行配置绑定的 Bean；真正读取 ",[22,26212,20436],{},"、匹配属性名称并进行类型转换的核心组件是 ",[22,26215,26216],{},"Binder",[18,26218,26219,26220,26222,26223,26225],{},"与单个 ",[22,26221,19625],{}," 相比，",[22,26224,25079],{}," 更适合结构化配置，因为它支持前缀聚合、宽松名称匹配、类型转换、嵌套对象和配置校验。",[18,26227,26228,26229,26231,26232,26234],{},"运行期间配置变化后，Spring Cloud 的刷新机制会根据最新 ",[22,26230,20436],{}," 再次执行绑定，使相应的 ",[22,26233,25079],{}," Bean 更新。对于基于 Setter 的可变配置对象，通常是在原 Bean 上重新设置属性，而不是一定创建一个新对象。因此需要注意：",[114,26236,26237,26240,26243,26249],{},[117,26238,26239],{},"多个字段重新绑定期间，不天然等于一次原子快照切换；",[117,26241,26242],{},"业务代码不应在 Setter 中执行网络请求等重副作用；",[117,26244,26245,26246,26248],{},"当前 Spring Cloud Commons 文档明确说明，使用 Java Record 声明的 ",[22,26247,25079],{}," 不能通过该机制动态刷新；构造器绑定或其他不可变形式也应结合实际 Spring Boot、Spring Cloud 版本验证；",[117,26250,26251],{},"要求多字段严格一致时，更适合先构造完整不可变对象，再原子替换引用。",[6264,26253,26255],{"id":26254},"_44-environmentchangeevent-负责通知哪些-key-变了","4.4 EnvironmentChangeEvent 负责通知“哪些 Key 变了”",[18,26257,26258,26259,26262],{},"Spring Cloud 监听 ",[22,26260,26261],{},"EnvironmentChangeEvent","。事件中包含发生变化的 Key，例如：",[95,26264,26267],{"className":26265,"code":26266,"language":100,"meta":101},[98],"payment.timeout\npayment.retry-count\nlogging.level.com.example.payment\n",[22,26268,26266],{"__ignoreMap":101},[18,26270,26271],{},"收到事件后，框架可以：",[114,26273,26274,26280,26287],{},[117,26275,26276,26277,26279],{},"重新绑定受影响的 ",[22,26278,25079],{}," Bean；",[117,26281,26282,26283,26286],{},"更新 ",[22,26284,26285],{},"logging.level.*"," 对应的日志级别；",[117,26288,26289],{},"触发应用自行注册的变更监听器。",[18,26291,26292],{},"因此顺序应该是：",[95,26294,26297],{"className":26295,"code":26296,"language":100,"meta":101},[98],"替换远程 PropertySource\n→ 发布 EnvironmentChangeEvent(changedKeys)\n→ 重新绑定或执行监听逻辑\n",[22,26298,26296],{"__ignoreMap":101},[18,26300,26301,26302,26304],{},"事件本身通常不携带完整配置内容或配置对象，也不应该绕过 ",[22,26303,20436],{}," 直接修改业务字段。它表达的是“这些属性发生了变化”，真正的新值仍从已经更新的属性源中读取。",[6264,26306,26308],{"id":26307},"_45-refreshscope-如何让-bean-使用新值","4.5 @RefreshScope 如何让 Bean 使用新值",[18,26310,26311],{},"有些 Bean 在创建时读取配置并形成内部状态，仅重新绑定属性对象并不够。例如：",[95,26313,26315],{"className":135,"code":26314,"language":137,"meta":101,"style":101},"@RefreshScope\n@Service\npublic class PaymentClient {\n\n private final Duration timeout;\n\n public PaymentClient(\n @Value(\"${payment.timeout}\") Duration timeout) {\n this.timeout = timeout;\n }\n}\n",[22,26316,26317,26324,26330,26340,26344,26352,26356,26364,26384,26394,26398],{"__ignoreMap":101},[141,26318,26319,26321],{"class":143,"line":144},[141,26320,263],{"class":147},[141,26322,26323],{"class":151},"RefreshScope\n",[141,26325,26326,26328],{"class":143,"line":165},[141,26327,263],{"class":147},[141,26329,266],{"class":151},[141,26331,26332,26334,26336,26338],{"class":143,"line":210},[141,26333,193],{"class":151},[141,26335,196],{"class":151},[141,26337,20578],{"class":158},[141,26339,201],{"class":147},[141,26341,26342],{"class":143,"line":219},[141,26343,207],{"emptyLinePlaceholder":206},[141,26345,26346,26348,26350],{"class":143,"line":234},[141,26347,481],{"class":151},[141,26349,484],{"class":151},[141,26351,25691],{"class":147},[141,26353,26354],{"class":143,"line":241},[141,26355,207],{"emptyLinePlaceholder":206},[141,26357,26358,26360,26362],{"class":143,"line":247},[141,26359,222],{"class":151},[141,26361,20578],{"class":158},[141,26363,17073],{"class":147},[141,26365,26366,26369,26372,26374,26377,26380,26382],{"class":143,"line":307},[141,26367,26368],{"class":147}," @",[141,26370,26371],{"class":151},"Value",[141,26373,908],{"class":147},[141,26375,26376],{"class":911},"\"${payment.timeout}\"",[141,26378,26379],{"class":147},") Duration ",[141,26381,25718],{"class":503},[141,26383,507],{"class":147},[141,26385,26386,26388,26390,26392],{"class":143,"line":379},[141,26387,512],{"class":428},[141,26389,25735],{"class":147},[141,26391,152],{"class":151},[141,26393,25740],{"class":147},[141,26395,26396],{"class":143,"line":391},[141,26397,244],{"class":147},[141,26399,26400],{"class":143,"line":396},[141,26401,250],{"class":147},[18,26403,26404,26406,26407,26410],{},[22,26405,25086],{}," 是 Spring Cloud 提供的一种自定义 Bean Scope。容器注册 Bean 时，对外暴露的通常是一个作用域代理；真正的目标对象由 ",[22,26408,26409],{},"RefreshScope"," 延迟创建并缓存。其他 Bean 注入的是这个稳定的代理，而不是直接长期持有目标对象。",[18,26412,26413],{},"发生刷新时，核心过程是：",[95,26415,26418],{"className":26416,"code":26417,"language":100,"meta":101},[98],"更新 Environment\n→ 清除 RefreshScope 中指定 Bean 的目标对象缓存\n→ 销毁旧目标对象\n→ 代理本身仍保留在其他 Bean 中\n→ 下一次调用代理时重新执行 Bean 创建流程\n→ 从最新 Environment 注入 @Value 或其他依赖\n→ 缓存并使用新目标对象\n",[22,26419,26417],{"__ignoreMap":101},[18,26421,14275,26422,26424],{},[22,26423,25086],{}," 并不是在原对象上逐个修改字段，而是让代理在刷新后切换到重新创建的目标对象。",[18,26426,26427],{},"可以把过程理解为：",[95,26429,26432],{"className":26430,"code":26431,"language":100,"meta":101},[98],"业务 Bean 持有 PaymentClient 代理\n ↓\n刷新前调用 → revision 101 对应的旧目标对象\n\n清除 RefreshScope 中的目标对象缓存\n ↓\n刷新后第一次调用 → 使用 revision 102 创建新目标对象\n ↓\n后续调用 → 使用新的目标对象\n",[22,26433,26431],{"__ignoreMap":101},[18,26435,26436,26437,26439],{},"刷新范围应尽量小，只重建确实需要更新的 Bean。刷新整个 ",[22,26438,20466],{}," 成本高、影响范围大，也更容易产生短暂不可用。",[18,26441,26442,26443,26445,26446,26448,26449,26451],{},"还要注意，给一个 ",[22,26444,19380],{}," 类添加 ",[22,26447,25086],{},"，并不意味着它声明的所有 ",[22,26450,19215],{}," 都自动进入刷新作用域；需要刷新哪些 Bean，应逐个确认依赖关系。",[18,26453,26454,2818,26456,26458],{},[22,26455,25079],{},[22,26457,25086],{}," 解决的问题不同：",[1309,26460,26461,26471],{},[1312,26462,26463],{},[1315,26464,26465,26468],{},[1318,26466,26467],{},"机制",[1318,26469,26470],{},"主要作用",[1328,26472,26473,26485],{},[1315,26474,26475,26479],{},[1333,26476,26477],{},[22,26478,25079],{},[1333,26480,26481,26482,26484],{},"把 ",[22,26483,20436],{}," 中的一组属性绑定为类型明确的配置对象，刷新时可以重新绑定",[1315,26486,26487,26491],{},[1333,26488,26489],{},[22,26490,25086],{},[1333,26492,26493],{},"清除旧目标对象并在下次调用时重建 Bean，使只在创建阶段读取配置的组件重新初始化",[18,26495,26496,26497,26499,26500,26502,26503,26505],{},"一个 ",[22,26498,25086],{}," Bean 可以依赖 ",[22,26501,25079],{},"，也可以在构造器中使用 ",[22,26504,19625],{},"。是否组合使用，要看业务需要的是“更新配置字段”，还是“根据新配置重建整个组件”。",[6264,26507,26509],{"id":26508},"_46-结构化业务配置更适合不可变快照","4.6 结构化业务配置更适合不可变快照",[18,26511,26512],{},"对于路由规则、限流规则或多字段业务策略，仅依靠多个字段分别重新绑定，业务线程可能在切换过程中观察到不一致组合。更稳妥的方式是：",[95,26514,26516],{"className":135,"code":26515,"language":137,"meta":101,"style":101},"public record PaymentRule(\n Duration timeout,\n int retryCount,\n boolean enabled) {\n}\n",[22,26517,26518,26530,26535,26542,26550],{"__ignoreMap":101},[141,26519,26520,26522,26525,26528],{"class":143,"line":144},[141,26521,193],{"class":151},[141,26523,26524],{"class":151}," record",[141,26526,26527],{"class":158}," PaymentRule",[141,26529,17073],{"class":147},[141,26531,26532],{"class":143,"line":165},[141,26533,26534],{"class":147}," Duration timeout,\n",[141,26536,26537,26539],{"class":143,"line":210},[141,26538,17078],{"class":151},[141,26540,26541],{"class":147}," retryCount,\n",[141,26543,26544,26547],{"class":143,"line":219},[141,26545,26546],{"class":151}," boolean",[141,26548,26549],{"class":147}," enabled) {\n",[141,26551,26552],{"class":143,"line":234},[141,26553,250],{"class":147},[18,26555,26556],{},"监听器收到新版本后：",[95,26558,26561],{"className":26559,"code":26560,"language":100,"meta":101},[98],"读取完整配置文档\n→ 类型转换和业务校验\n→ 构造新的 PaymentRule\n→ 一次性替换 volatile 或 AtomicReference 中的引用\n",[22,26562,26560],{"__ignoreMap":101},[18,26564,26565],{},"这样业务请求要么使用完整旧规则，要么使用完整新规则，不会同时看到新超时和旧重试次数。若校验失败，应保留旧对象并告警。",[6264,26567,26569],{"id":26568},"_47-线程池和连接池不能只更新一个数字","4.7 线程池和连接池不能只更新一个数字",[18,26571,26572],{},"有些配置代表正在运行的资源：",[114,26574,26575,26578,26581,26584,26587],{},[117,26576,26577],{},"线程池核心线程数和最大线程数；",[117,26579,26580],{},"数据库连接池地址和容量；",[117,26582,26583],{},"HTTP 客户端连接数、超时和证书；",[117,26585,26586],{},"MQ 消费并发度；",[117,26588,26589],{},"定时任务周期。",[18,26591,26592],{},"这类组件是否支持动态更新，取决于组件本身：",[95,26594,26597],{"className":26595,"code":26596,"language":100,"meta":101},[98],"支持安全 Setter 更新\n→ 按正确顺序修改参数并验证结果\n\n不支持原地更新但允许重建\n→ 创建新组件 → 健康检查 → 原子切换 → 优雅关闭旧组件\n\n不支持安全热更新\n→ 标记为“重启生效”，不要伪装成动态配置\n",[22,26598,26596],{"__ignoreMap":101},[18,26600,26601,26602,4878],{},"例如同时修改线程池的核心线程数和最大线程数时，还要根据增大或减小选择设置顺序，否则中间状态可能违反 ",[22,26603,26604],{},"corePoolSize \u003C= maximumPoolSize",[6264,26606,26608],{"id":26607},"_48-一次可靠的-spring-刷新流程","4.8 一次可靠的 Spring 刷新流程",[18,26610,26611],{},"可以将一次配置刷新设计为：",[95,26613,26616],{"className":26614,"code":26615,"language":100,"meta":101},[98],"1. SDK 收到 configId + revision 通知\n2. 拉取完整新内容\n3. 校验 revision、摘要、格式和业务规则\n4. 保存本地最后正确快照\n5. 替换 Spring Environment 中的远程 PropertySource\n6. 计算 changedKeys\n7. 发布 EnvironmentChangeEvent\n8. 重新绑定 @ConfigurationProperties\n9. 清除指定 RefreshScope Bean 的目标缓存\n10. 执行需要显式切换资源的业务监听器\n11. 上报已应用 revision、耗时和结果\n",[22,26617,26615],{"__ignoreMap":101},[18,26619,26620],{},"如果第 8～10 步失败，不能只记录“配置拉取成功”。客户端应分别记录：",[95,26622,26625],{"className":26623,"code":26624,"language":100,"meta":101},[98],"receivedRevision：已经收到的版本\nappliedRevision：业务已经成功应用的版本\n",[22,26626,26624],{"__ignoreMap":101},[18,26628,26629,26630,26633],{},"只有 ",[22,26631,26632],{},"appliedRevision"," 更新后，平台才能认为配置真正生效。否则控制台显示“所有客户端已收到”，实际业务仍可能运行在旧配置上。",[14,26635,26637],{"id":26636},"八灰度发布如何设计","八、灰度发布如何设计",[18,26639,26640],{},"高风险配置不应直接全量生效。灰度规则可以按以下维度匹配：",[114,26642,26643,26646,26649,26652,26655],{},[117,26644,26645],{},"实例 IP；",[117,26647,26648],{},"实例标签；",[117,26650,26651],{},"集群或机房；",[117,26653,26654],{},"用户或租户范围；",[117,26656,26657],{},"固定实例百分比。",[18,26659,26660],{},"推荐流程：",[95,26662,26665],{"className":26663,"code":26664,"language":100,"meta":101},[98],"创建灰度版本\n→ 命中少量实例\n→ 观察错误率、延迟和业务指标\n→ 扩大灰度范围\n→ 转为正式版本\n\n异常时\n→ 停止灰度\n→ 客户端恢复正式版本\n",[22,26666,26664],{"__ignoreMap":101},[18,26668,26669],{},"灰度内容是同一个配置资源的另一个发布状态，不应伪装成新的配置 Key。客户端查询时，服务端根据客户端标签决定返回灰度版本还是正式版本，并在响应中明确标记版本类型。",[18,26671,26672],{},"对于功能开关，还可以同时在业务代码中保留熔断或总开关，防止配置中心的灰度规则与业务规则互相覆盖而难以理解。",[14,26674,26676],{"id":26675},"九存储与服务端架构","九、存储与服务端架构",[638,26678,26680],{"id":26679},"_1-权威存储","1. 权威存储",[18,26682,26683],{},"需要保存：",[114,26685,26686,26689,26692,26695,26698,26700,26703,26706],{},[117,26687,26688],{},"配置身份和元数据；",[117,26690,26691],{},"当前正式版本指针；",[117,26693,26694],{},"不可变发布版本；",[117,26696,26697],{},"草稿；",[117,26699,25373],{},[117,26701,26702],{},"发布历史；",[117,26704,26705],{},"权限和审批记录；",[117,26707,26708],{},"Outbox 变更事件。",[18,26710,26711],{},"普通企业配置中心可以使用高可用关系型数据库作为权威存储，利用事务、唯一索引和审计查询能力。需要严格线性一致的通用协调能力时，也可以采用基于 Raft 的一致性 KV 存储，但这会增加部署和运维复杂度。",[18,26713,26714],{},"服务端本地缓存、Redis 或本地 Dump 都只能用于加速和容灾，不能成为绕过权威存储的另一个真相来源。",[638,26716,26718],{"id":26717},"_2-服务节点","2. 服务节点",[18,26720,26721],{},"运行时查询和通知节点尽量设计为无状态：",[95,26723,26726],{"className":26724,"code":26725,"language":100,"meta":101},[98],"Client SDK\n ↓\n负载均衡 \u002F 服务发现\n ↓\nConfig Server × N\n ↓\n权威存储\n",[22,26727,26725],{"__ignoreMap":101},[18,26729,26730],{},"节点在本地维护热点配置缓存和订阅关系。节点故障后，客户端能够重连到其他节点并根据本地版本继续监听。",[638,26732,26734],{"id":26733},"_3-变更传播","3. 变更传播",[18,26736,26737],{},"发布节点写入权威存储后，需要让其他服务节点刷新缓存。可以使用：",[114,26739,26740,26743,26746,26749],{},[117,26741,26742],{},"数据库 Outbox + MQ；",[117,26744,26745],{},"数据库变更日志 CDC；",[117,26747,26748],{},"一致性存储的 Watch；",[117,26750,26751],{},"定时扫描版本表。",[18,26753,26754],{},"CDC（Change Data Capture，变更数据捕获）是从数据库 Binlog 等变更日志中读取已提交的数据变化，再转换成事件通知其他节点。它能减少业务代码中的消息双写，但仍需要处理重复事件、延迟和断点恢复。",[18,26756,26757],{},"无论选择哪种方式，都要有版本校准，防止某个服务节点因漏事件长期返回旧配置。",[14,26759,26761],{"id":26760},"十容量与性能怎么估算","十、容量与性能怎么估算",[18,26763,26764],{},"配置中心的主要压力不是配置写入，而是：",[114,26766,26767,26770,26773,26776,26779,26782],{},[117,26768,26769],{},"客户端连接数；",[117,26771,26772],{},"启动时的全量拉取；",[117,26774,26775],{},"发布瞬间的通知扇出；",[117,26777,26778],{},"大量客户端同时回拉内容；",[117,26780,26781],{},"热点公共配置；",[117,26783,26784],{},"本地缓存和订阅关系占用。",[18,26786,26787],{},"需要重点估算：",[95,26789,26792],{"className":26790,"code":26791,"language":100,"meta":101},[98],"实例总数\n× 每个实例监听的配置数量\n= 总订阅关系\n",[22,26793,26791],{"__ignoreMap":101},[18,26795,26796],{},"以及：",[95,26798,26801],{"className":26799,"code":26800,"language":100,"meta":101},[98],"单次配置大小\n× 命中实例数\n÷ 期望分发时间\n= 发布后的网络吞吐需求\n",[22,26802,26800],{"__ignoreMap":101},[18,26804,26805],{},"常见优化包括：",[114,26807,26808,26811,26814,26817,26820,26823,26826],{},[117,26809,26810],{},"通知只携带配置标识和版本；",[117,26812,26813],{},"相同配置的通知批量合并；",[117,26815,26816],{},"客户端回拉增加随机抖动，避免惊群；",[117,26818,26819],{},"服务端缓存热点正式版本；",[117,26821,26822],{},"对配置大小、数量和发布频率设置配额；",[117,26824,26825],{},"公共配置分层缓存；",[117,26827,26828],{},"大规模发布时分批推进。",[18,26830,26831],{},"不能为了实时性让所有客户端在同一毫秒回源，应通过随机抖动、缓存和分批推进控制集中回拉造成的瞬时压力。",[14,26833,26835],{"id":26834},"十一权限安全和审计","十一、权限、安全和审计",[18,26837,26838],{},"配置中心通常可以直接改变生产行为，因此权限应比普通管理后台更严格。",[18,26840,26841],{},"至少需要：",[114,26843,26844,26847,26850,26853,26856,26859,26862,26865,26868],{},[117,26845,26846],{},"SSO 或统一身份认证；",[117,26848,26849],{},"基于租户、环境、应用和命名空间的 RBAC；",[117,26851,26852],{},"编辑、审批、发布、回滚权限分离；",[117,26854,26855],{},"生产环境高风险配置双人复核；",[117,26857,26858],{},"API Token 最小权限和定期轮换；",[117,26860,26861],{},"传输层 TLS；",[117,26863,26864],{},"敏感字段加密或脱敏展示；",[117,26866,26867],{},"完整的操作人、时间、来源、Diff 和审批记录；",[117,26869,26870],{},"批量导出、删除和回滚的风险控制。",[18,26872,26873],{},"其中，SSO（Single Sign-On）指统一登录；RBAC（Role-Based Access Control）指基于角色分配权限，例如开发者可以编辑测试环境配置，但只有发布者或审批者能够变更生产环境。",[18,26875,26876],{},"应用 SDK 通常只需要读取自己所属范围的配置，不应拥有发布权限。配置服务也不应直接暴露在公网。",[14,26878,26880],{"id":26879},"十二可观测性","十二、可观测性",[18,26882,26883],{},"平台侧建议监控：",[114,26885,26886,26889,26892,26895,26898,26901,26904,26907,26910,26913],{},[117,26887,26888],{},"发布成功率和发布延迟；",[117,26890,26891],{},"通知延迟和积压；",[117,26893,26894],{},"在线连接数与重连次数；",[117,26896,26897],{},"各版本客户端数量；",[117,26899,26900],{},"配置查询 QPS、P95\u002FP99 延迟和错误率；",[117,26902,26903],{},"服务端缓存命中率；",[117,26905,26906],{},"版本校准发现的不一致数量；",[117,26908,26909],{},"本地快照降级启动数量；",[117,26911,26912],{},"慢监听器和回调失败次数；",[117,26914,26915],{},"灰度实例范围与实际命中数量。",[18,26917,26918],{},"非常重要的一项是客户端版本分布：",[95,26920,26923],{"className":26921,"code":26922,"language":100,"meta":101},[98],"revision 103：9,980 个实例\nrevision 102：20 个实例\n",[22,26924,26922],{"__ignoreMap":101},[18,26926,26927],{},"它能回答“配置是否真的生效”，而不是只证明“控制台发布成功”。对长期停留在旧版本的实例，应能查询其连接节点、最近心跳、拉取错误和本地版本。",[14,26929,26931],{"id":26930},"十三故障场景要提前设计","十三、故障场景要提前设计",[1309,26933,26934,26944],{},[1312,26935,26936],{},[1315,26937,26938,26941],{},[1318,26939,26940],{},"故障",[1318,26942,26943],{},"系统应该如何处理",[1328,26945,26946,26954,26962,26970,26978,26986,26994,27002,27010],{},[1315,26947,26948,26951],{},[1333,26949,26950],{},"数据库短暂不可用",[1333,26952,26953],{},"禁止新发布；读取节点使用已确认缓存，恢复后校准",[1315,26955,26956,26959],{},[1333,26957,26958],{},"某个配置服务节点故障",[1333,26960,26961],{},"客户端重连其他节点，携带当前版本继续监听",[1315,26963,26964,26967],{},[1333,26965,26966],{},"通知消息丢失",[1333,26968,26969],{},"客户端定时校准发现新版本并补拉",[1315,26971,26972,26975],{},[1333,26973,26974],{},"客户端收到乱序通知",[1333,26976,26977],{},"比较 revision，只允许版本前进",[1315,26979,26980,26983],{},[1333,26981,26982],{},"新内容格式错误",[1333,26984,26985],{},"发布前校验；客户端再次校验，失败后保留旧版本",[1315,26987,26988,26991],{},[1333,26989,26990],{},"业务监听器执行失败",[1333,26992,26993],{},"隔离回调、告警并保留旧的业务快照或按策略重试",[1315,26995,26996,26999],{},[1333,26997,26998],{},"错误配置已经全量发布",[1333,27000,27001],{},"以历史内容生成新版本并紧急发布",[1315,27003,27004,27007],{},[1333,27005,27006],{},"大量实例同时启动",[1333,27008,27009],{},"启动随机抖动、限流、缓存和分批扩容",[1315,27011,27012,27015],{},[1333,27013,27014],{},"本地快照损坏",[1333,27016,27017],{},"摘要校验失败后拒绝使用，回源或失败退出",[18,27019,27020],{},"配置中心追求的不是“永远不会失败”，而是每个失败点都有确定的降级行为，并且不会悄悄把错误配置传播给更多实例。",[14,27022,27024],{"id":27023},"十四常见设计误区","十四、常见设计误区",[638,27026,27028],{"id":27027},"_1-只做一张配置表和几个-crud-接口","1. 只做一张配置表和几个 CRUD 接口",[18,27030,27031],{},"这只能算配置管理页面，缺少版本、发布、通知、客户端容灾、灰度、权限和审计，无法承担生产配置中心职责。",[638,27033,27035],{"id":27034},"_2-每次编辑立即推送线上","2. 每次编辑立即推送线上",[18,27037,27038],{},"编辑与发布不分离，会放大误操作风险，也无法进行审批、Diff 和定时发布。",[638,27040,27042],{"id":27041},"_3-把-mq-通知当成唯一正确性保障","3. 把 MQ 通知当成唯一正确性保障",[18,27044,27045],{},"MQ 只能提高变更传播效率，不能代替权威版本查询和客户端定时校准。",[638,27047,27049],{"id":27048},"_4-服务端把完整配置直接推给所有客户端","4. 服务端把完整配置直接推给所有客户端",[18,27051,27052],{},"大配置和大规模实例会造成瞬时流量放大，而且推送路径还要重复实现查询链路中的鉴权、灰度和校验逻辑。通常只推变更标识和版本更稳妥。",[638,27054,27056],{"id":27055},"_5-客户端原地修改可变对象","5. 客户端原地修改可变对象",[18,27058,27059],{},"多个字段逐个更新时，业务线程可能读取到中间状态。应该构造完整新快照后原子替换。",[638,27061,27063],{"id":27062},"_6-所有参数都支持热更新","6. 所有参数都支持热更新",[18,27065,27066],{},"数据库连接池、线程池、序列化协议等配置是否能安全热更新，取决于组件能力。每个配置应标记：",[95,27068,27071],{"className":27069,"code":27070,"language":100,"meta":101},[98],"动态立即生效\n动态但需要组件重建\n只在应用启动时读取\n变更后必须重新部署\n",[22,27072,27070],{"__ignoreMap":101},[18,27074,27075],{},"配置中心负责传递变化，不会自动让不支持热更新的代码变得安全。",[14,27077,27079],{"id":27078},"十五一个可落地的最小版本","十五、一个可落地的最小版本",[18,27081,27082],{},"如果从零建设，可以分阶段实现。",[638,27084,27086],{"id":27085},"第一阶段正确发布","第一阶段：正确发布",[114,27088,27089,27092,27095,27098,27101,27104],{},[117,27090,27091],{},"环境、应用和命名空间隔离；",[117,27093,27094],{},"草稿与正式发布分离；",[117,27096,27097],{},"不可变版本和历史；",[117,27099,27100],{},"乐观锁；",[117,27102,27103],{},"权限和审计；",[117,27105,27106],{},"客户端查询与本地快照。",[638,27108,27110],{"id":27109},"第二阶段动态分发","第二阶段：动态分发",[114,27112,27113,27116,27119,27122,27125,27128],{},[117,27114,27115],{},"长轮询或长连接；",[117,27117,27118],{},"版本通知；",[117,27120,27121],{},"客户端监听器；",[117,27123,27124],{},"定时版本校准；",[117,27126,27127],{},"服务端缓存和多实例部署；",[117,27129,27130],{},"客户端版本上报。",[638,27132,27134],{"id":27133},"第三阶段发布安全与规模化","第三阶段：发布安全与规模化",[114,27136,27137,27140,27143,27146,27149,27152,27155],{},[117,27138,27139],{},"灰度发布；",[117,27141,27142],{},"审批流；",[117,27144,27145],{},"规则校验；",[117,27147,27148],{},"一键回滚；",[117,27150,27151],{},"容量配额；",[117,27153,27154],{},"多机房容灾；",[117,27156,27157],{},"发布效果观测和全链路告警。",[18,27159,27160],{},"优先保证版本正确、能够回滚和客户端可恢复，再优化毫秒级通知。对配置中心而言，错误配置传播得越快，故障也会扩散得越快。",[14,27162,5605],{"id":5605},[114,27164,27165,27172,27179,27186,27193,27200,27207,27214,27221],{},[117,27166,27167],{},[73,27168,27171],{"href":27169,"rel":27170},"https:\u002F\u002Fnacos.io\u002Fen\u002Fdocs\u002Fnext\u002Fmanual\u002Fuser\u002Fconfig\u002Foverview\u002F",[1876],"Nacos：Configuration Overview",[117,27173,27174],{},[73,27175,27178],{"href":27176,"rel":27177},"https:\u002F\u002Fnacos.io\u002Fen\u002Fdocs\u002Flatest\u002Fmanual\u002Fuser\u002Fconfig\u002Fpublish-query-listen\u002F",[1876],"Nacos：Publish, Query, And Listen",[117,27180,27181],{},[73,27182,27185],{"href":27183,"rel":27184},"https:\u002F\u002Fwww.nacos.io\u002Fen\u002Fdocs\u002Fnext\u002Fmanual\u002Fuser\u002Fconfig\u002Fgray-release\u002F",[1876],"Nacos：Configuration Gray Release",[117,27187,27188],{},[73,27189,27192],{"href":27190,"rel":27191},"https:\u002F\u002Fnacos.io\u002Fen\u002Fdocs\u002Flatest\u002Fmanual\u002Fuser\u002Fconfig\u002Fops-and-troubleshooting\u002F",[1876],"Nacos：Operations And Troubleshooting",[117,27194,27195],{},[73,27196,27199],{"href":27197,"rel":27198},"https:\u002F\u002Fgithub.com\u002Fapolloconfig\u002Fapollo\u002Fwiki\u002FApollo%E9%85%8D%E7%BD%AE%E4%B8%AD%E5%BF%83%E8%AE%BE%E8%AE%A1",[1876],"Apollo：配置中心设计",[117,27201,27202],{},[73,27203,27206],{"href":27204,"rel":27205},"https:\u002F\u002Fetcd.io\u002Fdocs\u002Fv3.5\u002Flearning\u002Fapi_guarantees\u002F",[1876],"etcd：API Guarantees",[117,27208,27209],{},[73,27210,27213],{"href":27211,"rel":27212},"https:\u002F\u002Fdeveloper.hashicorp.com\u002Fconsul\u002Fdocs\u002Fautomate\u002Fwatch",[1876],"Consul：Watches Overview",[117,27215,27216],{},[73,27217,27220],{"href":27218,"rel":27219},"https:\u002F\u002Fdocs.spring.io\u002Fspring-boot\u002Freference\u002Ffeatures\u002Fexternal-config.html",[1876],"Spring Boot：Externalized Configuration",[117,27222,27223],{},[73,27224,27227],{"href":27225,"rel":27226},"https:\u002F\u002Fdocs.spring.io\u002Fspring-cloud-commons\u002Freference\u002Fspring-cloud-commons\u002Fapplication-context-services.html",[1876],"Spring Cloud Commons：Environment Changes 与 Refresh Scope",[1907,27229,27230],{},"html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .s9eBZ, html code.shiki .s9eBZ{--shiki-default:#22863A;--shiki-dark:#85E89D}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .s4XuR, html code.shiki .s4XuR{--shiki-default:#E36209;--shiki-dark:#FFAB70}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}",{"title":101,"searchDepth":165,"depth":165,"links":27232},[27233,27234,27235,27236,27237,27241,27245,27251,27257,27263,27269,27270,27275,27276,27277,27278,27279,27287,27292],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":25113,"depth":165,"text":25114},{"id":25190,"depth":165,"text":25191,"children":27238},[27239,27240],{"id":25274,"depth":210,"text":25275},{"id":25302,"depth":210,"text":25303},{"id":25348,"depth":165,"text":25349,"children":27242},[27243,27244],{"id":25352,"depth":210,"text":25353},{"id":25385,"depth":210,"text":25386},{"id":25415,"depth":165,"text":25416,"children":27246},[27247,27248,27249,27250],{"id":25428,"depth":210,"text":25429},{"id":25455,"depth":210,"text":25456},{"id":25482,"depth":210,"text":25483},{"id":25498,"depth":210,"text":25499},{"id":25517,"depth":165,"text":25518,"children":27252},[27253,27254,27255,27256],{"id":25524,"depth":210,"text":25525},{"id":25540,"depth":210,"text":25541},{"id":25550,"depth":210,"text":25551},{"id":25574,"depth":210,"text":25575},{"id":25590,"depth":165,"text":25591,"children":27258},[27259,27260,27261,27262],{"id":25614,"depth":210,"text":25615},{"id":25621,"depth":210,"text":25622},{"id":25634,"depth":210,"text":25635},{"id":25662,"depth":210,"text":25663},{"id":25806,"depth":165,"text":25807,"children":27264},[27265,27266,27267,27268],{"id":25819,"depth":210,"text":25820},{"id":25835,"depth":210,"text":25836},{"id":25885,"depth":210,"text":25886},{"id":25912,"depth":210,"text":25913},{"id":26636,"depth":165,"text":26637},{"id":26675,"depth":165,"text":26676,"children":27271},[27272,27273,27274],{"id":26679,"depth":210,"text":26680},{"id":26717,"depth":210,"text":26718},{"id":26733,"depth":210,"text":26734},{"id":26760,"depth":165,"text":26761},{"id":26834,"depth":165,"text":26835},{"id":26879,"depth":165,"text":26880},{"id":26930,"depth":165,"text":26931},{"id":27023,"depth":165,"text":27024,"children":27280},[27281,27282,27283,27284,27285,27286],{"id":27027,"depth":210,"text":27028},{"id":27034,"depth":210,"text":27035},{"id":27041,"depth":210,"text":27042},{"id":27048,"depth":210,"text":27049},{"id":27055,"depth":210,"text":27056},{"id":27062,"depth":210,"text":27063},{"id":27078,"depth":165,"text":27079,"children":27288},[27289,27290,27291],{"id":27085,"depth":210,"text":27086},{"id":27109,"depth":210,"text":27110},{"id":27133,"depth":210,"text":27134},{"id":5605,"depth":165,"text":5605},"wiki:java:how-to-design-a-configuration-center","从配置模型、管理面与分发面、发布流程、推拉结合、版本一致性、本地容灾、Spring 动态刷新、灰度回滚、权限审计和容量治理，系统讲解配置中心的设计方法。",{},83,"\u002Fjava\u002Fhow-to-design-a-configuration-center",{"title":25050,"description":27294},"java\u002Fhow-to-design-a-configuration-center","2026-07-31","qZy75UH-4auSNXHGeAua8V-8unzvIuA989ZLU2drY_Y",{"id":27303,"title":27304,"body":27305,"commentId":28978,"description":28979,"difficulty":1942,"draft":1943,"extension":1944,"meta":28980,"navigation":206,"order":28981,"path":28982,"section":1948,"seo":28983,"stem":28984,"updated":1951,"__hash__":28985},"java\u002Fjava\u002Fhow-to-implement-singleton-pattern.md","Java 如何实现单例模式？",{"type":7,"value":27306,"toc":28951},[27307,27310,27312,27315,27322,27325,27327,27334,27336,27345,27347,27351,27354,27362,27365,27371,27374,27378,27381,27471,27478,27506,27512,27518,27528,27538,27541,27552,27555,27566,27569,27573,27576,27680,27691,27697,27721,27727,27736,27742,27753,27756,27760,27763,27904,27908,27911,27930,27933,27936,27981,27984,27988,27991,27997,28000,28015,28020,28028,28032,28035,28240,28243,28291,28297,28300,28314,28317,28321,28324,28431,28437,28440,28444,28448,28504,28511,28515,28581,28584,28588,28592,28595,28651,28654,28658,28665,28691,28694,28698,28712,28716,28719,28722,28727,28730,28734,28835,28839,28842,28906,28916,28922,28926,28948],[10,27308,27304],{"id":27309},"java-如何实现单例模式",[14,27311,16],{"id":16},[18,27313,27314],{},"单例模式用于保证一个类在指定作用域内只有一个实例，并提供统一的访问入口。Java 中常见实现包括饿汉式、静态内部类、双重检查锁和枚举。",[18,27316,27317,27318,27321],{},"饿汉式依靠 JVM 的类初始化机制保证线程安全，实现简单，但不能按需加载；静态内部类同时具备线程安全和懒加载，通常是普通业务代码中的推荐实现；双重检查锁适合需要显式控制懒加载过程的场景，但实例引用必须使用 ",[22,27319,27320],{},"volatile","，防止对象发布与初始化发生不安全的重排序；枚举写法最简洁，还能天然抵御常规反射和反序列化破坏，是实现严格单例的可靠方式。",[18,27323,27324],{},"需要注意，单例的唯一性通常只限定在同一个 ClassLoader 中。分布式系统中的“全局唯一实例”不能只靠 Java 单例模式实现。",[18,27326,57],{},[59,27328,27329],{},[18,27330,27331],{},[64,27332,27333],{},"普通懒加载优先使用静态内部类，强调防反射和反序列化时使用枚举；使用双重检查锁时，实例引用必须声明为 volatile。",[14,27335,69],{"id":69},[18,27337,27338],{},[73,27339,27342],{"href":27340,"target":76,"rel":27341},"\u002Fimages\u002Fwiki\u002Fjava\u002Fhow-to-implement-singleton-pattern.svg",[78,79],[81,27343],{"src":27340,"alt":27344},"Java 单例模式四种常见实现及选择方式",[14,27346,86],{"id":86},[14,27348,27350],{"id":27349},"一什么是单例模式","一、什么是单例模式",[18,27352,27353],{},"单例模式主要解决两个问题：",[2489,27355,27356,27359],{},[117,27357,27358],{},"限制对象创建，保证一个类在指定作用域内只有一个实例；",[117,27360,27361],{},"提供统一入口，让其他代码能够获取这个实例。",[18,27363,27364],{},"一个典型的单例类通常包含：",[95,27366,27369],{"className":27367,"code":27368,"language":100,"meta":101},[98],"私有构造方法\n+ 类内部持有唯一实例\n+ 对外提供获取实例的方法\n",[22,27370,27368],{"__ignoreMap":101},[18,27372,27373],{},"例如配置管理器、无状态工具服务或共享资源协调器，可能只需要一个实例。单例并不等于全局变量，它还负责控制对象的创建过程。",[14,27375,27377],{"id":27376},"二饿汉式","二、饿汉式",[18,27379,27380],{},"饿汉式在类初始化阶段直接创建对象：",[95,27382,27384],{"className":135,"code":27383,"language":137,"meta":101,"style":101},"public final class Singleton {\n\n private static final Singleton INSTANCE = new Singleton();\n\n private Singleton() {\n }\n\n public static Singleton getInstance() {\n return INSTANCE;\n }\n}\n",[22,27385,27386,27399,27403,27422,27426,27434,27438,27442,27456,27463,27467],{"__ignoreMap":101},[141,27387,27388,27390,27392,27394,27397],{"class":143,"line":144},[141,27389,193],{"class":151},[141,27391,484],{"class":151},[141,27393,196],{"class":151},[141,27395,27396],{"class":158}," Singleton",[141,27398,201],{"class":147},[141,27400,27401],{"class":143,"line":165},[141,27402,207],{"emptyLinePlaceholder":206},[141,27404,27405,27407,27409,27411,27414,27416,27418,27420],{"class":143,"line":210},[141,27406,481],{"class":151},[141,27408,728],{"class":151},[141,27410,484],{"class":151},[141,27412,27413],{"class":147}," Singleton INSTANCE ",[141,27415,152],{"class":151},[141,27417,155],{"class":151},[141,27419,27396],{"class":158},[141,27421,162],{"class":147},[141,27423,27424],{"class":143,"line":219},[141,27425,207],{"emptyLinePlaceholder":206},[141,27427,27428,27430,27432],{"class":143,"line":234},[141,27429,481],{"class":151},[141,27431,27396],{"class":158},[141,27433,231],{"class":147},[141,27435,27436],{"class":143,"line":241},[141,27437,244],{"class":147},[141,27439,27440],{"class":143,"line":247},[141,27441,207],{"emptyLinePlaceholder":206},[141,27443,27444,27446,27448,27451,27454],{"class":143,"line":307},[141,27445,222],{"class":151},[141,27447,728],{"class":151},[141,27449,27450],{"class":147}," Singleton ",[141,27452,27453],{"class":158},"getInstance",[141,27455,231],{"class":147},[141,27457,27458,27460],{"class":143,"line":379},[141,27459,17912],{"class":151},[141,27461,27462],{"class":147}," INSTANCE;\n",[141,27464,27465],{"class":143,"line":391},[141,27466,244],{"class":147},[141,27468,27469],{"class":143,"line":396},[141,27470,250],{"class":147},[18,27472,27473,27474,27477],{},"它的线程安全来自 JVM 的类初始化机制。静态字段的赋值会进入类初始化方法 ",[22,27475,27476],{},"\u003Cclinit>()","，可以近似理解为：",[95,27479,27481],{"className":135,"code":27480,"language":137,"meta":101,"style":101},"static {\n INSTANCE = new Singleton();\n}\n",[22,27482,27483,27489,27502],{"__ignoreMap":101},[141,27484,27485,27487],{"class":143,"line":144},[141,27486,50],{"class":151},[141,27488,201],{"class":147},[141,27490,27491,27494,27496,27498,27500],{"class":143,"line":165},[141,27492,27493],{"class":147}," INSTANCE ",[141,27495,152],{"class":151},[141,27497,155],{"class":151},[141,27499,27396],{"class":158},[141,27501,162],{"class":147},[141,27503,27504],{"class":143,"line":210},[141,27505,250],{"class":147},[18,27507,27508,27509,27511],{},"JVM 会同步一个类的初始化过程：同一个 ClassLoader 下，只有一个线程能够执行该类的 ",[22,27510,27476],{},"；其他首次使用该类的线程需要等待初始化完成。类初始化完成后，初始化过程中的写入 happens-before 其他线程后续对该类的使用。",[95,27513,27516],{"className":27514,"code":27515,"language":100,"meta":101},[98],"线程 A 首次主动使用 Singleton\n ↓\n获得 Singleton 的类初始化权\n ↓\n执行 \u003Cclinit>()，创建并初始化对象\n ↓\n将引用赋给 INSTANCE\n ↓\nSingleton 类初始化完成\n ↓\n等待中的线程才能继续读取 INSTANCE\n",[22,27517,27515],{"__ignoreMap":101},[18,27519,27520,27521,27523,27524,27527],{},"创建对象可以概念性地分为“分配内存、执行构造方法、发布引用”。JVM 和处理器可以进行不改变程序语义的优化，但类初始化机制保证其他线程不能在 ",[22,27522,27476],{}," 尚未完成时，把这个类当作已经初始化完成来使用。因此，其他线程不会合法地观察到“",[22,27525,27526],{},"INSTANCE"," 已经非空，但构造结果还不可见”的状态。",[18,27529,8323,27530,27532,27533,27535,27536,4878],{},[22,27531,47],{}," 主要用于防止 ",[22,27534,27526],{}," 后续重新指向其他对象；饿汉式的只初始化一次和安全发布，主要由 JVM 的类初始化机制保证，而不是单独依赖 ",[22,27537,47],{},[18,27539,27540],{},"优点：",[114,27542,27543,27546,27549],{},[117,27544,27545],{},"实现简单；",[117,27547,27548],{},"天然线程安全；",[117,27550,27551],{},"实例通过类初始化安全发布，不需要额外加锁。",[18,27553,27554],{},"缺点：",[114,27556,27557,27560,27563],{},[117,27558,27559],{},"类被初始化时就会创建实例；",[117,27561,27562],{},"如果实例创建成本较高且最终没有使用，会提前占用资源；",[117,27564,27565],{},"构造失败会导致类初始化失败。",[18,27567,27568],{},"适合对象创建成本不高、启动时即可创建的场景。",[14,27570,27572],{"id":27571},"三静态内部类","三、静态内部类",[18,27574,27575],{},"静态内部类可以同时实现线程安全与懒加载：",[95,27577,27579],{"className":135,"code":27578,"language":137,"meta":101,"style":101},"public final class Singleton {\n\n private Singleton() {\n }\n\n private static class Holder {\n private static final Singleton INSTANCE = new Singleton();\n }\n\n public static Singleton getInstance() {\n return Holder.INSTANCE;\n }\n}\n",[22,27580,27581,27593,27597,27605,27609,27613,27626,27645,27649,27653,27665,27672,27676],{"__ignoreMap":101},[141,27582,27583,27585,27587,27589,27591],{"class":143,"line":144},[141,27584,193],{"class":151},[141,27586,484],{"class":151},[141,27588,196],{"class":151},[141,27590,27396],{"class":158},[141,27592,201],{"class":147},[141,27594,27595],{"class":143,"line":165},[141,27596,207],{"emptyLinePlaceholder":206},[141,27598,27599,27601,27603],{"class":143,"line":210},[141,27600,481],{"class":151},[141,27602,27396],{"class":158},[141,27604,231],{"class":147},[141,27606,27607],{"class":143,"line":219},[141,27608,244],{"class":147},[141,27610,27611],{"class":143,"line":234},[141,27612,207],{"emptyLinePlaceholder":206},[141,27614,27615,27617,27619,27621,27624],{"class":143,"line":241},[141,27616,481],{"class":151},[141,27618,728],{"class":151},[141,27620,196],{"class":151},[141,27622,27623],{"class":158}," Holder",[141,27625,201],{"class":147},[141,27627,27628,27631,27633,27635,27637,27639,27641,27643],{"class":143,"line":247},[141,27629,27630],{"class":151}," private",[141,27632,728],{"class":151},[141,27634,484],{"class":151},[141,27636,27413],{"class":147},[141,27638,152],{"class":151},[141,27640,155],{"class":151},[141,27642,27396],{"class":158},[141,27644,162],{"class":147},[141,27646,27647],{"class":143,"line":307},[141,27648,244],{"class":147},[141,27650,27651],{"class":143,"line":379},[141,27652,207],{"emptyLinePlaceholder":206},[141,27654,27655,27657,27659,27661,27663],{"class":143,"line":391},[141,27656,222],{"class":151},[141,27658,728],{"class":151},[141,27660,27450],{"class":147},[141,27662,27453],{"class":158},[141,27664,231],{"class":147},[141,27666,27667,27669],{"class":143,"line":396},[141,27668,17912],{"class":151},[141,27670,27671],{"class":147}," Holder.INSTANCE;\n",[141,27673,27674],{"class":143,"line":401},[141,27675,244],{"class":147},[141,27677,27678],{"class":143,"line":554},[141,27679,250],{"class":147},[18,27681,27682,27683,27686,27687,27690],{},"虽然 ",[22,27684,27685],{},"Holder"," 写在 ",[22,27688,27689],{},"Singleton"," 内部，但编译后它们是两个独立的类：",[95,27692,27695],{"className":27693,"code":27694,"language":100,"meta":101},[98],"Singleton.class\nSingleton$Holder.class\n",[22,27696,27694],{"__ignoreMap":101},[18,27698,27699,27700,27702,27703,27705,27706,27709,27710,27713,27714,27716,27717,27720],{},"初始化外部类 ",[22,27701,27689],{},"，不会因此立即初始化内部类 ",[22,27704,27685],{},"。第一次调用 ",[22,27707,27708],{},"getInstance()"," 并读取 ",[22,27711,27712],{},"Holder.INSTANCE"," 属于对 ",[22,27715,27685],{}," 的主动使用，此时 JVM 才执行 ",[22,27718,27719],{},"Holder.\u003Cclinit>()"," 并创建实例。",[95,27722,27725],{"className":27723,"code":27724,"language":100,"meta":101},[98],"加载 Singleton\n ↓\n尚未初始化 Holder，不创建实例\n ↓\n第一次调用 getInstance()\n ↓\nJVM 初始化 Holder\n ↓\n创建并安全发布 INSTANCE\n",[22,27726,27724],{"__ignoreMap":101},[18,27728,27729,27730,27732,27733,27735],{},"如果多个线程同时第一次调用 ",[22,27731,27708],{},"，它们可能同时执行到读取 ",[22,27734,27712],{},"，但不会分别创建对象：",[95,27737,27740],{"className":27738,"code":27739,"language":100,"meta":101},[98],"线程 A ──→ 获得 Holder 的类初始化权\n线程 B ──→ 等待 Holder 初始化完成\n线程 C ──→ 等待 Holder 初始化完成\n\n线程 A 执行 Holder.\u003Cclinit>()\n ↓\n创建 Singleton 并赋值给 INSTANCE\n ↓\nHolder 初始化完成\n ↓\n线程 B、C 继续执行并读取同一个 INSTANCE\n",[22,27741,27739],{"__ignoreMap":101},[18,27743,27744,27745,27747,27748,27750,27751,4878],{},"它的懒加载来自“内部类到首次主动使用时才初始化”，线程安全和可见性则来自 JVM 对 ",[22,27746,27685],{}," 类初始化过程的同步与 happens-before 保证。因此这里不需要再使用 ",[22,27749,27320],{}," 或显式的 ",[22,27752,1967],{},[18,27754,27755],{},"这种写法读取实例时没有业务代码中的锁竞争，通常是普通业务代码中实现懒加载单例的优先选择。",[14,27757,27759],{"id":27758},"四双重检查锁","四、双重检查锁",[18,27761,27762],{},"双重检查锁也称 DCL，即 Double-Checked Locking：",[95,27764,27766],{"className":135,"code":27765,"language":137,"meta":101,"style":101},"public final class Singleton {\n\n private static volatile Singleton instance;\n\n private Singleton() {\n }\n\n public static Singleton getInstance() {\n if (instance == null) {\n synchronized (Singleton.class) {\n if (instance == null) {\n instance = new Singleton();\n }\n }\n }\n\n return instance;\n }\n}\n",[22,27767,27768,27780,27784,27795,27799,27807,27811,27815,27827,27840,27848,27860,27873,27877,27881,27885,27889,27896,27900],{"__ignoreMap":101},[141,27769,27770,27772,27774,27776,27778],{"class":143,"line":144},[141,27771,193],{"class":151},[141,27773,484],{"class":151},[141,27775,196],{"class":151},[141,27777,27396],{"class":158},[141,27779,201],{"class":147},[141,27781,27782],{"class":143,"line":165},[141,27783,207],{"emptyLinePlaceholder":206},[141,27785,27786,27788,27790,27792],{"class":143,"line":210},[141,27787,481],{"class":151},[141,27789,728],{"class":151},[141,27791,25783],{"class":151},[141,27793,27794],{"class":147}," Singleton instance;\n",[141,27796,27797],{"class":143,"line":219},[141,27798,207],{"emptyLinePlaceholder":206},[141,27800,27801,27803,27805],{"class":143,"line":234},[141,27802,481],{"class":151},[141,27804,27396],{"class":158},[141,27806,231],{"class":147},[141,27808,27809],{"class":143,"line":241},[141,27810,244],{"class":147},[141,27812,27813],{"class":143,"line":247},[141,27814,207],{"emptyLinePlaceholder":206},[141,27816,27817,27819,27821,27823,27825],{"class":143,"line":307},[141,27818,222],{"class":151},[141,27820,728],{"class":151},[141,27822,27450],{"class":147},[141,27824,27453],{"class":158},[141,27826,231],{"class":147},[141,27828,27829,27831,27834,27836,27838],{"class":143,"line":379},[141,27830,19881],{"class":151},[141,27832,27833],{"class":147}," (instance ",[141,27835,23946],{"class":151},[141,27837,4705],{"class":428},[141,27839,507],{"class":147},[141,27841,27842,27845],{"class":143,"line":391},[141,27843,27844],{"class":151}," synchronized",[141,27846,27847],{"class":147}," (Singleton.class) {\n",[141,27849,27850,27852,27854,27856,27858],{"class":143,"line":396},[141,27851,18207],{"class":151},[141,27853,27833],{"class":147},[141,27855,23946],{"class":151},[141,27857,4705],{"class":428},[141,27859,507],{"class":147},[141,27861,27862,27865,27867,27869,27871],{"class":143,"line":401},[141,27863,27864],{"class":147}," instance ",[141,27866,152],{"class":151},[141,27868,155],{"class":151},[141,27870,27396],{"class":158},[141,27872,162],{"class":147},[141,27874,27875],{"class":143,"line":554},[141,27876,18258],{"class":147},[141,27878,27879],{"class":143,"line":559},[141,27880,18302],{"class":147},[141,27882,27883],{"class":143,"line":564},[141,27884,18114],{"class":147},[141,27886,27887],{"class":143,"line":571},[141,27888,207],{"emptyLinePlaceholder":206},[141,27890,27891,27893],{"class":143,"line":583},[141,27892,17912],{"class":151},[141,27894,27895],{"class":147}," instance;\n",[141,27897,27898],{"class":143,"line":588},[141,27899,244],{"class":147},[141,27901,27902],{"class":143,"line":595},[141,27903,250],{"class":147},[638,27905,27907],{"id":27906},"_1-为什么检查两次","1. 为什么检查两次",[18,27909,27910],{},"第一次检查发生在同步块外：",[95,27912,27914],{"className":135,"code":27913,"language":137,"meta":101,"style":101},"if (result == null)\n",[22,27915,27916],{"__ignoreMap":101},[141,27917,27918,27921,27924,27926,27928],{"class":143,"line":144},[141,27919,27920],{"class":151},"if",[141,27922,27923],{"class":147}," (result ",[141,27925,23946],{"class":151},[141,27927,4705],{"class":428},[141,27929,1481],{"class":147},[18,27931,27932],{},"实例已经创建后，绝大多数调用可以直接返回，不必再竞争锁。",[18,27934,27935],{},"第二次检查发生在同步块内：",[95,27937,27939],{"className":135,"code":27938,"language":137,"meta":101,"style":101},"synchronized (Singleton.class) {\n result = instance;\n if (result == null) {\n \u002F\u002F 创建实例\n }\n}\n",[22,27940,27941,27947,27956,27968,27973,27977],{"__ignoreMap":101},[141,27942,27943,27945],{"class":143,"line":144},[141,27944,1967],{"class":151},[141,27946,27847],{"class":147},[141,27948,27949,27952,27954],{"class":143,"line":165},[141,27950,27951],{"class":147}," result ",[141,27953,152],{"class":151},[141,27955,27895],{"class":147},[141,27957,27958,27960,27962,27964,27966],{"class":143,"line":210},[141,27959,4696],{"class":151},[141,27961,27923],{"class":147},[141,27963,23946],{"class":151},[141,27965,4705],{"class":428},[141,27967,507],{"class":147},[141,27969,27970],{"class":143,"line":219},[141,27971,27972],{"class":237}," \u002F\u002F 创建实例\n",[141,27974,27975],{"class":143,"line":234},[141,27976,244],{"class":147},[141,27978,27979],{"class":143,"line":241},[141,27980,250],{"class":147},[18,27982,27983],{},"假设线程 A 和线程 B 同时通过第一次检查，线程 A 先获得锁并创建对象。线程 B 随后获得锁时，必须再次检查，否则还会创建第二个对象。",[638,27985,27987],{"id":27986},"_2-为什么必须使用-volatile","2. 为什么必须使用 volatile",[18,27989,27990],{},"创建对象可以概念性地分为：",[95,27992,27995],{"className":27993,"code":27994,"language":100,"meta":101},[98],"1. 分配内存\n2. 初始化对象\n3. 将引用赋给 instance\n",[22,27996,27994],{"__ignoreMap":101},[18,27998,27999],{},"如果没有适当的内存语义约束，其他线程可能观察到非空引用，却没有可靠地观察到对象完整初始化后的状态。",[95,28001,28003],{"className":135,"code":28002,"language":137,"meta":101,"style":101},"private static volatile Singleton instance;\n",[22,28004,28005],{"__ignoreMap":101},[141,28006,28007,28009,28011,28013],{"class":143,"line":144},[141,28008,43],{"class":151},[141,28010,728],{"class":151},[141,28012,25783],{"class":151},[141,28014,27794],{"class":147},[18,28016,28017,28019],{},[22,28018,27320],{}," 在这里有两个关键作用：",[114,28021,28022,28025],{},[117,28023,28024],{},"禁止对象初始化与引用发布之间发生不安全的重排序；",[117,28026,28027],{},"建立 volatile 写与后续 volatile 读之间的 happens-before 关系，使初始化结果对读取线程可见。",[14,28029,28031],{"id":28030},"五枚举单例","五、枚举单例",[18,28033,28034],{},"枚举是更简洁、约束更强的单例实现：",[95,28036,28038],{"className":135,"code":28037,"language":137,"meta":101,"style":101},"public enum Singleton {\n INSTANCE(\"default-service\", 3000);\n\n private final String serviceName;\n private final int timeoutMillis;\n\n Singleton(String serviceName, int timeoutMillis) {\n this.serviceName = serviceName;\n this.timeoutMillis = timeoutMillis;\n }\n\n public String getServiceName() {\n return serviceName;\n }\n\n public int getTimeoutMillis() {\n return timeoutMillis;\n }\n\n public void execute() {\n System.out.println(\n serviceName + \" timeout=\" + timeoutMillis);\n }\n}\n",[22,28039,28040,28051,28068,28072,28081,28092,28096,28116,28128,28139,28143,28147,28159,28165,28169,28173,28184,28190,28194,28198,28208,28217,28232,28236],{"__ignoreMap":101},[141,28041,28042,28044,28047,28049],{"class":143,"line":144},[141,28043,193],{"class":151},[141,28045,28046],{"class":151}," enum",[141,28048,27396],{"class":158},[141,28050,201],{"class":147},[141,28052,28053,28056,28058,28061,28063,28066],{"class":143,"line":165},[141,28054,28055],{"class":428}," INSTANCE",[141,28057,908],{"class":147},[141,28059,28060],{"class":911},"\"default-service\"",[141,28062,4981],{"class":147},[141,28064,28065],{"class":428},"3000",[141,28067,915],{"class":147},[141,28069,28070],{"class":143,"line":210},[141,28071,207],{"emptyLinePlaceholder":206},[141,28073,28074,28076,28078],{"class":143,"line":219},[141,28075,481],{"class":151},[141,28077,484],{"class":151},[141,28079,28080],{"class":147}," String serviceName;\n",[141,28082,28083,28085,28087,28089],{"class":143,"line":234},[141,28084,481],{"class":151},[141,28086,484],{"class":151},[141,28088,25700],{"class":151},[141,28090,28091],{"class":147}," timeoutMillis;\n",[141,28093,28094],{"class":143,"line":241},[141,28095,207],{"emptyLinePlaceholder":206},[141,28097,28098,28101,28104,28107,28109,28111,28114],{"class":143,"line":247},[141,28099,28100],{"class":158}," Singleton",[141,28102,28103],{"class":147},"(String ",[141,28105,28106],{"class":503},"serviceName",[141,28108,4981],{"class":147},[141,28110,25723],{"class":151},[141,28112,28113],{"class":503}," timeoutMillis",[141,28115,507],{"class":147},[141,28117,28118,28120,28123,28125],{"class":143,"line":307},[141,28119,512],{"class":428},[141,28121,28122],{"class":147},".serviceName ",[141,28124,152],{"class":151},[141,28126,28127],{"class":147}," serviceName;\n",[141,28129,28130,28132,28135,28137],{"class":143,"line":379},[141,28131,512],{"class":428},[141,28133,28134],{"class":147},".timeoutMillis ",[141,28136,152],{"class":151},[141,28138,28091],{"class":147},[141,28140,28141],{"class":143,"line":391},[141,28142,244],{"class":147},[141,28144,28145],{"class":143,"line":396},[141,28146,207],{"emptyLinePlaceholder":206},[141,28148,28149,28151,28154,28157],{"class":143,"line":401},[141,28150,222],{"class":151},[141,28152,28153],{"class":147}," String ",[141,28155,28156],{"class":158},"getServiceName",[141,28158,231],{"class":147},[141,28160,28161,28163],{"class":143,"line":554},[141,28162,17912],{"class":151},[141,28164,28127],{"class":147},[141,28166,28167],{"class":143,"line":559},[141,28168,244],{"class":147},[141,28170,28171],{"class":143,"line":564},[141,28172,207],{"emptyLinePlaceholder":206},[141,28174,28175,28177,28179,28182],{"class":143,"line":571},[141,28176,222],{"class":151},[141,28178,25700],{"class":151},[141,28180,28181],{"class":158}," getTimeoutMillis",[141,28183,231],{"class":147},[141,28185,28186,28188],{"class":143,"line":583},[141,28187,17912],{"class":151},[141,28189,28091],{"class":147},[141,28191,28192],{"class":143,"line":588},[141,28193,244],{"class":147},[141,28195,28196],{"class":143,"line":595},[141,28197,207],{"emptyLinePlaceholder":206},[141,28199,28200,28202,28204,28206],{"class":143,"line":606},[141,28201,222],{"class":151},[141,28203,225],{"class":151},[141,28205,18053],{"class":158},[141,28207,231],{"class":147},[141,28209,28210,28213,28215],{"class":143,"line":611},[141,28211,28212],{"class":147}," System.out.",[141,28214,3194],{"class":158},[141,28216,17073],{"class":147},[141,28218,28219,28222,28224,28227,28229],{"class":143,"line":616},[141,28220,28221],{"class":147}," serviceName ",[141,28223,11754],{"class":151},[141,28225,28226],{"class":911}," \" timeout=\"",[141,28228,17837],{"class":151},[141,28230,28231],{"class":147}," timeoutMillis);\n",[141,28233,28234],{"class":143,"line":17909},[141,28235,244],{"class":147},[141,28237,28238],{"class":143,"line":17918},[141,28239,250],{"class":147},[18,28241,28242],{},"调用方式：",[95,28244,28246],{"className":135,"code":28245,"language":137,"meta":101,"style":101},"Singleton.INSTANCE.execute();\n\nString serviceName = Singleton.INSTANCE.getServiceName();\nint timeoutMillis = Singleton.INSTANCE.getTimeoutMillis();\n",[22,28247,28248,28257,28261,28275],{"__ignoreMap":101},[141,28249,28250,28253,28255],{"class":143,"line":144},[141,28251,28252],{"class":147},"Singleton.INSTANCE.",[141,28254,17526],{"class":158},[141,28256,162],{"class":147},[141,28258,28259],{"class":143,"line":165},[141,28260,207],{"emptyLinePlaceholder":206},[141,28262,28263,28266,28268,28271,28273],{"class":143,"line":210},[141,28264,28265],{"class":147},"String serviceName ",[141,28267,152],{"class":151},[141,28269,28270],{"class":147}," Singleton.INSTANCE.",[141,28272,28156],{"class":158},[141,28274,162],{"class":147},[141,28276,28277,28279,28282,28284,28286,28289],{"class":143,"line":219},[141,28278,25723],{"class":151},[141,28280,28281],{"class":147}," timeoutMillis ",[141,28283,152],{"class":151},[141,28285,28270],{"class":147},[141,28287,28288],{"class":158},"getTimeoutMillis",[141,28290,162],{"class":147},[18,28292,28293,28294,28296],{},"枚举常量可以拥有构造参数、成员属性和普通方法。上例中的属性使用 ",[22,28295,47],{}," 修饰，实例创建后不再改变，多个线程读取时不需要额外同步。如果枚举单例内部保存的是可变属性，并发访问时仍然需要锁或其他线程安全机制。",[18,28298,28299],{},"枚举单例具有以下特点：",[114,28301,28302,28305,28308,28311],{},[117,28303,28304],{},"JVM 保证枚举常量只初始化一次；",[117,28306,28307],{},"枚举构造器不能通过常规反射方式创建新实例；",[117,28309,28310],{},"Java 序列化机制能够保持枚举常量的唯一性；",[117,28312,28313],{},"代码简洁，不需要手动编写并发控制。",[18,28315,28316],{},"如果业务能够接受枚举形式，并且特别关注反射与反序列化对单例的破坏，枚举通常是更稳妥的选择。",[14,28318,28320],{"id":28319},"六同步方法实现","六、同步方法实现",[18,28322,28323],{},"最直接的懒加载写法是给整个获取方法加锁：",[95,28325,28327],{"className":135,"code":28326,"language":137,"meta":101,"style":101},"public final class Singleton {\n\n private static Singleton instance;\n\n private Singleton() {\n }\n\n public static synchronized Singleton getInstance() {\n if (instance == null) {\n instance = new Singleton();\n }\n return instance;\n }\n}\n",[22,28328,28329,28341,28345,28353,28357,28365,28369,28373,28388,28400,28413,28417,28423,28427],{"__ignoreMap":101},[141,28330,28331,28333,28335,28337,28339],{"class":143,"line":144},[141,28332,193],{"class":151},[141,28334,484],{"class":151},[141,28336,196],{"class":151},[141,28338,27396],{"class":158},[141,28340,201],{"class":147},[141,28342,28343],{"class":143,"line":165},[141,28344,207],{"emptyLinePlaceholder":206},[141,28346,28347,28349,28351],{"class":143,"line":210},[141,28348,481],{"class":151},[141,28350,728],{"class":151},[141,28352,27794],{"class":147},[141,28354,28355],{"class":143,"line":219},[141,28356,207],{"emptyLinePlaceholder":206},[141,28358,28359,28361,28363],{"class":143,"line":234},[141,28360,481],{"class":151},[141,28362,27396],{"class":158},[141,28364,231],{"class":147},[141,28366,28367],{"class":143,"line":241},[141,28368,244],{"class":147},[141,28370,28371],{"class":143,"line":247},[141,28372,207],{"emptyLinePlaceholder":206},[141,28374,28375,28377,28379,28382,28384,28386],{"class":143,"line":307},[141,28376,222],{"class":151},[141,28378,728],{"class":151},[141,28380,28381],{"class":151}," synchronized",[141,28383,27450],{"class":147},[141,28385,27453],{"class":158},[141,28387,231],{"class":147},[141,28389,28390,28392,28394,28396,28398],{"class":143,"line":379},[141,28391,19881],{"class":151},[141,28393,27833],{"class":147},[141,28395,23946],{"class":151},[141,28397,4705],{"class":428},[141,28399,507],{"class":147},[141,28401,28402,28405,28407,28409,28411],{"class":143,"line":391},[141,28403,28404],{"class":147}," instance ",[141,28406,152],{"class":151},[141,28408,155],{"class":151},[141,28410,27396],{"class":158},[141,28412,162],{"class":147},[141,28414,28415],{"class":143,"line":396},[141,28416,18114],{"class":147},[141,28418,28419,28421],{"class":143,"line":401},[141,28420,17912],{"class":151},[141,28422,27895],{"class":147},[141,28424,28425],{"class":143,"line":554},[141,28426,244],{"class":147},[141,28428,28429],{"class":143,"line":559},[141,28430,250],{"class":147},[18,28432,28433,28434,28436],{},"这种实现是线程安全的，但每次调用 ",[22,28435,27708],{}," 都要进入同步方法。现代 JVM 对无竞争锁已有较多优化，但在能够使用静态内部类的情况下，通常没有必要让每次读取都经过同步。",[18,28438,28439],{},"它的优点是逻辑直观，适合教学或对性能不敏感的简单场景。",[14,28441,28443],{"id":28442},"七两种错误实现","七、两种错误实现",[638,28445,28447],{"id":28446},"_1-没有同步的懒加载","1. 没有同步的懒加载",[95,28449,28451],{"className":135,"code":28450,"language":137,"meta":101,"style":101},"public static Singleton getInstance() {\n if (instance == null) {\n instance = new Singleton();\n }\n return instance;\n}\n",[22,28452,28453,28465,28477,28490,28494,28500],{"__ignoreMap":101},[141,28454,28455,28457,28459,28461,28463],{"class":143,"line":144},[141,28456,193],{"class":151},[141,28458,728],{"class":151},[141,28460,27450],{"class":147},[141,28462,27453],{"class":158},[141,28464,231],{"class":147},[141,28466,28467,28469,28471,28473,28475],{"class":143,"line":165},[141,28468,4696],{"class":151},[141,28470,27833],{"class":147},[141,28472,23946],{"class":151},[141,28474,4705],{"class":428},[141,28476,507],{"class":147},[141,28478,28479,28482,28484,28486,28488],{"class":143,"line":210},[141,28480,28481],{"class":147}," instance ",[141,28483,152],{"class":151},[141,28485,155],{"class":151},[141,28487,27396],{"class":158},[141,28489,162],{"class":147},[141,28491,28492],{"class":143,"line":219},[141,28493,244],{"class":147},[141,28495,28496,28498],{"class":143,"line":234},[141,28497,20087],{"class":151},[141,28499,27895],{"class":147},[141,28501,28502],{"class":143,"line":241},[141,28503,250],{"class":147},[18,28505,28506,28507,28510],{},"多个线程可能同时判断 ",[22,28508,28509],{},"instance == null","，随后分别创建对象，因此不能保证单例。",[638,28512,28514],{"id":28513},"_2-缺少第二次检查","2. 缺少第二次检查",[95,28516,28518],{"className":135,"code":28517,"language":137,"meta":101,"style":101},"public static Singleton getInstance() {\n if (instance == null) {\n synchronized (Singleton.class) {\n instance = new Singleton();\n }\n }\n return instance;\n}\n",[22,28519,28520,28532,28544,28551,28563,28567,28571,28577],{"__ignoreMap":101},[141,28521,28522,28524,28526,28528,28530],{"class":143,"line":144},[141,28523,193],{"class":151},[141,28525,728],{"class":151},[141,28527,27450],{"class":147},[141,28529,27453],{"class":158},[141,28531,231],{"class":147},[141,28533,28534,28536,28538,28540,28542],{"class":143,"line":165},[141,28535,4696],{"class":151},[141,28537,27833],{"class":147},[141,28539,23946],{"class":151},[141,28541,4705],{"class":428},[141,28543,507],{"class":147},[141,28545,28546,28549],{"class":143,"line":210},[141,28547,28548],{"class":151}," synchronized",[141,28550,27847],{"class":147},[141,28552,28553,28555,28557,28559,28561],{"class":143,"line":219},[141,28554,28404],{"class":147},[141,28556,152],{"class":151},[141,28558,155],{"class":151},[141,28560,27396],{"class":158},[141,28562,162],{"class":147},[141,28564,28565],{"class":143,"line":234},[141,28566,18114],{"class":147},[141,28568,28569],{"class":143,"line":241},[141,28570,244],{"class":147},[141,28572,28573,28575],{"class":143,"line":247},[141,28574,20087],{"class":151},[141,28576,27895],{"class":147},[141,28578,28579],{"class":143,"line":307},[141,28580,250],{"class":147},[18,28582,28583],{},"多个线程可能同时通过外层判断，然后依次进入同步块并各自创建对象。加锁只能保证它们不会同时创建，不能阻止后获得锁的线程再次创建，因此锁内必须重新判断。",[14,28585,28587],{"id":28586},"八单例可能被哪些方式破坏","八、单例可能被哪些方式破坏",[638,28589,28591],{"id":28590},"_1-反射","1. 反射",[18,28593,28594],{},"普通单例的私有构造器仍可能被反射调用：",[95,28596,28598],{"className":135,"code":28597,"language":137,"meta":101,"style":101},"Constructor\u003CSingleton> constructor =\n Singleton.class.getDeclaredConstructor();\nconstructor.setAccessible(true);\nSingleton another = constructor.newInstance();\n",[22,28599,28600,28612,28622,28636],{"__ignoreMap":101},[141,28601,28602,28605,28607,28610],{"class":143,"line":144},[141,28603,28604],{"class":147},"Constructor\u003C",[141,28606,27689],{"class":151},[141,28608,28609],{"class":147},"> constructor ",[141,28611,16185],{"class":151},[141,28613,28614,28617,28620],{"class":143,"line":165},[141,28615,28616],{"class":147}," Singleton.class.",[141,28618,28619],{"class":158},"getDeclaredConstructor",[141,28621,162],{"class":147},[141,28623,28624,28627,28630,28632,28634],{"class":143,"line":210},[141,28625,28626],{"class":147},"constructor.",[141,28628,28629],{"class":158},"setAccessible",[141,28631,908],{"class":147},[141,28633,4968],{"class":428},[141,28635,915],{"class":147},[141,28637,28638,28641,28643,28646,28649],{"class":143,"line":219},[141,28639,28640],{"class":147},"Singleton another ",[141,28642,152],{"class":151},[141,28644,28645],{"class":147}," constructor.",[141,28647,28648],{"class":158},"newInstance",[141,28650,162],{"class":147},[18,28652,28653],{},"可以在构造器中增加防御性检查，但这种方式需要谨慎处理初始化顺序，也不能替代可靠的访问控制。枚举单例能够从语言与 JVM 层面阻止这种常规反射创建。",[638,28655,28657],{"id":28656},"_2-反序列化","2. 反序列化",[18,28659,28660,28661,28664],{},"普通单例实现 ",[22,28662,28663],{},"Serializable"," 后，反序列化默认可能创建新对象。可以定义：",[95,28666,28668],{"className":135,"code":28667,"language":137,"meta":101,"style":101},"private Object readResolve() {\n return INSTANCE;\n}\n",[22,28669,28670,28681,28687],{"__ignoreMap":101},[141,28671,28672,28674,28676,28679],{"class":143,"line":144},[141,28673,43],{"class":151},[141,28675,19539],{"class":147},[141,28677,28678],{"class":158},"readResolve",[141,28680,231],{"class":147},[141,28682,28683,28685],{"class":143,"line":165},[141,28684,20087],{"class":151},[141,28686,27462],{"class":147},[141,28688,28689],{"class":143,"line":210},[141,28690,250],{"class":147},[18,28692,28693],{},"让反序列化结果返回已有实例。枚举单例由序列化机制直接保证唯一性。",[638,28695,28697],{"id":28696},"_3-克隆","3. 克隆",[18,28699,28700,28701,28704,28705,28708,28709,28711],{},"如果单例支持 ",[22,28702,28703],{},"Cloneable"," 并允许调用 ",[22,28706,28707],{},"clone()","，也可能产生新对象。单例类通常不应实现 ",[22,28710,28703],{},"，或者应拒绝克隆。",[638,28713,28715],{"id":28714},"_4-多个-classloader","4. 多个 ClassLoader",[18,28717,28718],{},"静态字段属于其对应的类，而类的身份由“类名 + 加载它的 ClassLoader”共同决定。同一个类被不同 ClassLoader 分别加载时，每个 ClassLoader 都可以拥有自己的单例实例。",[18,28720,28721],{},"因此 Java 单例通常保证的是：",[59,28723,28724],{},[18,28725,28726],{},"同一个 JVM、同一个 ClassLoader 范围内只有一个实例。",[18,28728,28729],{},"它不能保证多个 JVM、多个容器实例或分布式集群中只有一个对象。",[14,28731,28733],{"id":28732},"九不同实现如何选择","九、不同实现如何选择",[1309,28735,28736,28755],{},[1312,28737,28738],{},[1315,28739,28740,28743,28746,28749,28752],{},[1318,28741,28742],{},"实现方式",[1318,28744,28745],{"align":8227},"线程安全",[1318,28747,28748],{"align":8227},"懒加载",[1318,28750,28751],{},"主要特点",[1318,28753,28754],{},"推荐场景",[1328,28756,28757,28772,28787,28804,28820],{},[1315,28758,28759,28762,28764,28766,28769],{},[1333,28760,28761],{},"饿汉式",[1333,28763,15080],{"align":8227},[1333,28765,15143],{"align":8227},[1333,28767,28768],{},"简单，依靠类初始化",[1333,28770,28771],{},"创建成本低、启动时即可创建",[1315,28773,28774,28777,28779,28781,28784],{},[1333,28775,28776],{},"静态内部类",[1333,28778,15080],{"align":8227},[1333,28780,15080],{"align":8227},[1333,28782,28783],{},"无显式锁，读取开销低",[1333,28785,28786],{},"普通业务中的懒加载单例",[1315,28788,28789,28792,28794,28796,28801],{},[1333,28790,28791],{},"双重检查锁",[1333,28793,15080],{"align":8227},[1333,28795,15080],{"align":8227},[1333,28797,28798,28799],{},"必须正确使用 ",[22,28800,27320],{},[1333,28802,28803],{},"需要显式控制初始化过程",[1315,28805,28806,28809,28811,28814,28817],{},[1333,28807,28808],{},"枚举",[1333,28810,15080],{"align":8227},[1333,28812,28813],{"align":8227},"通常不作为延迟加载方案",[1333,28815,28816],{},"防常规反射和反序列化破坏",[1333,28818,28819],{},"强调实现简洁和唯一性",[1315,28821,28822,28825,28827,28829,28832],{},[1333,28823,28824],{},"同步方法",[1333,28826,15080],{"align":8227},[1333,28828,15080],{"align":8227},[1333,28830,28831],{},"简单但每次获取都同步",[1333,28833,28834],{},"教学或低频简单场景",[14,28836,28838],{"id":28837},"十单例不等于无条件线程安全","十、单例不等于无条件线程安全",[18,28840,28841],{},"单例模式只保证实例数量，不会自动保证实例内部状态的线程安全。",[95,28843,28845],{"className":135,"code":28844,"language":137,"meta":101,"style":101},"public final class CounterSingleton {\n\n private int count;\n\n public void increment() {\n count++;\n }\n}\n",[22,28846,28847,28860,28864,28873,28877,28888,28898,28902],{"__ignoreMap":101},[141,28848,28849,28851,28853,28855,28858],{"class":143,"line":144},[141,28850,193],{"class":151},[141,28852,484],{"class":151},[141,28854,196],{"class":151},[141,28856,28857],{"class":158}," CounterSingleton",[141,28859,201],{"class":147},[141,28861,28862],{"class":143,"line":165},[141,28863,207],{"emptyLinePlaceholder":206},[141,28865,28866,28868,28870],{"class":143,"line":210},[141,28867,481],{"class":151},[141,28869,25700],{"class":151},[141,28871,28872],{"class":147}," count;\n",[141,28874,28875],{"class":143,"line":219},[141,28876,207],{"emptyLinePlaceholder":206},[141,28878,28879,28881,28883,28886],{"class":143,"line":234},[141,28880,222],{"class":151},[141,28882,225],{"class":151},[141,28884,28885],{"class":158}," increment",[141,28887,231],{"class":147},[141,28889,28890,28893,28896],{"class":143,"line":241},[141,28891,28892],{"class":147}," count",[141,28894,28895],{"class":151},"++",[141,28897,8560],{"class":147},[141,28899,28900],{"class":143,"line":247},[141,28901,244],{"class":147},[141,28903,28904],{"class":143,"line":307},[141,28905,250],{"class":147},[18,28907,176,28908,28911,28912,28915],{},[22,28909,28910],{},"CounterSingleton"," 只有一个实例，多个线程并发执行 ",[22,28913,28914],{},"count++"," 仍然可能丢失更新。可变状态仍然需要使用锁、原子类、不可变对象或其他并发控制方式保护。",[18,28917,28918,28919,28921],{},"在 Spring 中，默认的单例 Bean 也只是表示一个 ",[22,28920,20466],{}," 中通常只有一个实例。Spring 不会自动保证这个 Bean 的可变字段线程安全。",[14,28923,28925],{"id":28924},"十一需要记住的边界","十一、需要记住的边界",[114,28927,28928,28931,28934,28939,28942,28945],{},[117,28929,28930],{},"单例保证实例数量，不保证内部状态线程安全；",[117,28932,28933],{},"Java 单例通常只在同一个 ClassLoader 范围内成立；",[117,28935,28936,28937,2159],{},"Spring Singleton 的作用域是一个 ",[22,28938,20466],{},[117,28940,28941],{},"多 JVM、多个服务实例之间的全局唯一，需要借助数据库唯一约束、分布式锁、协调服务或主节点选举等机制；",[117,28943,28944],{},"单例适合承载无状态逻辑，或者经过并发保护的共享状态；",[117,28946,28947],{},"不应把“当前用户”“本次请求参数”或普通可变集合等请求级数据保存在单例字段中。所有线程和测试用例会共享这些数据，容易造成请求间数据串扰、并发修改错误以及测试互相影响。",[1907,28949,28950],{},"html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .sJ8bj, html code.shiki .sJ8bj{--shiki-default:#6A737D;--shiki-dark:#6A737D}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}html pre.shiki code .s4XuR, html code.shiki .s4XuR{--shiki-default:#E36209;--shiki-dark:#FFAB70}",{"title":101,"searchDepth":165,"depth":165,"links":28952},[28953,28954,28955,28956,28957,28958,28959,28963,28964,28965,28969,28975,28976,28977],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":27349,"depth":165,"text":27350},{"id":27376,"depth":165,"text":27377},{"id":27571,"depth":165,"text":27572},{"id":27758,"depth":165,"text":27759,"children":28960},[28961,28962],{"id":27906,"depth":210,"text":27907},{"id":27986,"depth":210,"text":27987},{"id":28030,"depth":165,"text":28031},{"id":28319,"depth":165,"text":28320},{"id":28442,"depth":165,"text":28443,"children":28966},[28967,28968],{"id":28446,"depth":210,"text":28447},{"id":28513,"depth":210,"text":28514},{"id":28586,"depth":165,"text":28587,"children":28970},[28971,28972,28973,28974],{"id":28590,"depth":210,"text":28591},{"id":28656,"depth":210,"text":28657},{"id":28696,"depth":210,"text":28697},{"id":28714,"depth":210,"text":28715},{"id":28732,"depth":165,"text":28733},{"id":28837,"depth":165,"text":28838},{"id":28924,"depth":165,"text":28925},"wiki:java:how-to-implement-singleton-pattern","从饿汉式、静态内部类、双重检查锁和枚举四种实现出发，讲清 Java 单例模式的线程安全、懒加载、安全发布及常见误区。",{},84,"\u002Fjava\u002Fhow-to-implement-singleton-pattern",{"title":27304,"description":28979},"java\u002Fhow-to-implement-singleton-pattern","7stgbl5xJ-jqlkEvuYdhvc5JNhbN0piqO3YI_MJtApQ",{"id":4,"title":5,"body":28987,"commentId":1940,"description":1941,"difficulty":1942,"draft":1943,"extension":1944,"meta":30504,"navigation":206,"order":1946,"path":1947,"section":1948,"seo":30505,"stem":1950,"updated":1951,"__hash__":1952},{"type":7,"value":28988,"toc":30474},[28989,28991,28993,28999,29011,29013,29015,29021,29023,29030,29032,29034,29036,29041,29045,29047,29053,29055,29057,29059,29083,29089,29135,29137,29189,29191,29193,29195,29271,29279,29293,29297,29302,29304,29448,29454,29456,29458,29460,29484,29486,29488,29514,29518,29520,29546,29548,29550,29556,29560,29562,29566,29624,29626,29628,29630,29640,29642,29688,29692,29746,29748,29766,29774,29776,29778,29852,29854,29856,29892,29894,29918,29920,29922,29926,29988,29990,29994,29999,30001,30003,30005,30007,30071,30073,30113,30115,30117,30119,30121,30159,30161,30163,30175,30177,30179,30181,30193,30197,30199,30253,30255,30257,30261,30323,30325,30327,30329,30331,30341,30343,30345,30347,30352,30354,30356,30361,30363,30365,30367,30381,30383,30443,30445,30472],[10,28990,5],{"id":12},[14,28992,16],{"id":16},[18,28994,20,28995,25,28997,29],{},[22,28996,24],{},[22,28998,28],{},[18,29000,32,29001,36,29003,40,29005,44,29007,44,29009,51],{},[22,29002,35],{},[22,29004,39],{},[22,29006,43],{},[22,29008,47],{},[22,29010,50],{},[18,29012,54],{},[18,29014,57],{},[59,29016,29017],{},[18,29018,29019],{},[64,29020,66],{},[14,29022,69],{"id":69},[18,29024,29025],{},[73,29026,29028],{"href":75,"target":76,"rel":29027},[78,79],[81,29029],{"src":75,"alt":83},[14,29031,86],{"id":86},[14,29033,90],{"id":89},[18,29035,93],{},[95,29037,29039],{"className":29038,"code":99,"language":100,"meta":101},[98],[22,29040,99],{"__ignoreMap":101},[18,29042,106,29043,109],{},[22,29044,28],{},[18,29046,112],{},[114,29048,29049,29051],{},[117,29050,119],{},[117,29052,122],{},[18,29054,125],{},[14,29056,129],{"id":128},[18,29058,132],{},[95,29060,29061],{"className":135,"code":136,"language":137,"meta":101,"style":101},[22,29062,29063,29075],{"__ignoreMap":101},[141,29064,29065,29067,29069,29071,29073],{"class":143,"line":144},[141,29066,148],{"class":147},[141,29068,152],{"class":151},[141,29070,155],{"class":151},[141,29072,159],{"class":158},[141,29074,162],{"class":147},[141,29076,29077,29079,29081],{"class":143,"line":165},[141,29078,168],{"class":147},[141,29080,171],{"class":158},[141,29082,162],{"class":147},[18,29084,176,29085,180,29087,183],{},[22,29086,179],{},[22,29088,28],{},[95,29090,29091],{"className":135,"code":186,"language":137,"meta":101,"style":101},[22,29092,29093,29103,29107,29113,29123,29127,29131],{"__ignoreMap":101},[141,29094,29095,29097,29099,29101],{"class":143,"line":144},[141,29096,193],{"class":151},[141,29098,196],{"class":151},[141,29100,159],{"class":158},[141,29102,201],{"class":147},[141,29104,29105],{"class":143,"line":165},[141,29106,207],{"emptyLinePlaceholder":206},[141,29108,29109,29111],{"class":143,"line":210},[141,29110,213],{"class":147},[141,29112,216],{"class":151},[141,29114,29115,29117,29119,29121],{"class":143,"line":219},[141,29116,222],{"class":151},[141,29118,225],{"class":151},[141,29120,228],{"class":158},[141,29122,231],{"class":147},[141,29124,29125],{"class":143,"line":234},[141,29126,238],{"class":237},[141,29128,29129],{"class":143,"line":241},[141,29130,244],{"class":147},[141,29132,29133],{"class":143,"line":247},[141,29134,250],{"class":147},[18,29136,253],{},[95,29138,29139],{"className":135,"code":256,"language":137,"meta":101,"style":101},[22,29140,29141,29147,29157,29161,29167,29177,29181,29185],{"__ignoreMap":101},[141,29142,29143,29145],{"class":143,"line":144},[141,29144,263],{"class":147},[141,29146,266],{"class":151},[141,29148,29149,29151,29153,29155],{"class":143,"line":165},[141,29150,193],{"class":151},[141,29152,196],{"class":151},[141,29154,159],{"class":158},[141,29156,201],{"class":147},[141,29158,29159],{"class":143,"line":210},[141,29160,207],{"emptyLinePlaceholder":206},[141,29162,29163,29165],{"class":143,"line":219},[141,29164,213],{"class":147},[141,29166,216],{"class":151},[141,29168,29169,29171,29173,29175],{"class":143,"line":234},[141,29170,222],{"class":151},[141,29172,225],{"class":151},[141,29174,228],{"class":158},[141,29176,231],{"class":147},[141,29178,29179],{"class":143,"line":241},[141,29180,238],{"class":237},[141,29182,29183],{"class":143,"line":247},[141,29184,244],{"class":147},[141,29186,29187],{"class":143,"line":307},[141,29188,250],{"class":147},[18,29190,312],{},[14,29192,316],{"id":315},[18,29194,319],{},[95,29196,29197],{"className":135,"code":322,"language":137,"meta":101,"style":101},[22,29198,29199,29205,29215,29219,29229,29235,29239,29243,29249,29259,29263,29267],{"__ignoreMap":101},[141,29200,29201,29203],{"class":143,"line":144},[141,29202,263],{"class":147},[141,29204,266],{"class":151},[141,29206,29207,29209,29211,29213],{"class":143,"line":165},[141,29208,193],{"class":151},[141,29210,196],{"class":151},[141,29212,159],{"class":158},[141,29214,201],{"class":147},[141,29216,29217],{"class":143,"line":210},[141,29218,207],{"emptyLinePlaceholder":206},[141,29220,29221,29223,29225,29227],{"class":143,"line":219},[141,29222,222],{"class":151},[141,29224,225],{"class":151},[141,29226,353],{"class":158},[141,29228,231],{"class":147},[141,29230,29231,29233],{"class":143,"line":234},[141,29232,360],{"class":158},[141,29234,162],{"class":147},[141,29236,29237],{"class":143,"line":241},[141,29238,244],{"class":147},[141,29240,29241],{"class":143,"line":247},[141,29242,207],{"emptyLinePlaceholder":206},[141,29244,29245,29247],{"class":143,"line":307},[141,29246,213],{"class":147},[141,29248,216],{"class":151},[141,29250,29251,29253,29255,29257],{"class":143,"line":379},[141,29252,222],{"class":151},[141,29254,225],{"class":151},[141,29256,386],{"class":158},[141,29258,231],{"class":147},[141,29260,29261],{"class":143,"line":391},[141,29262,238],{"class":237},[141,29264,29265],{"class":143,"line":396},[141,29266,244],{"class":147},[141,29268,29269],{"class":143,"line":401},[141,29270,250],{"class":147},[18,29272,406,29273,410,29275,414,29277,418],{},[22,29274,409],{},[22,29276,413],{},[22,29278,417],{},[95,29280,29281],{"className":135,"code":421,"language":137,"meta":101,"style":101},[22,29282,29283],{"__ignoreMap":101},[141,29284,29285,29287,29289,29291],{"class":143,"line":144},[141,29286,35],{"class":428},[141,29288,431],{"class":147},[141,29290,434],{"class":158},[141,29292,162],{"class":147},[18,29294,439,29295,442],{},[22,29296,417],{},[95,29298,29300],{"className":29299,"code":446,"language":100,"meta":101},[98],[22,29301,446],{"__ignoreMap":101},[18,29303,451],{},[95,29305,29306],{"className":135,"code":454,"language":137,"meta":101,"style":101},[22,29307,29308,29314,29324,29328,29336,29340,29352,29362,29366,29370,29380,29388,29392,29396,29400,29406,29416,29420,29426,29436,29440,29444],{"__ignoreMap":101},[141,29309,29310,29312],{"class":143,"line":144},[141,29311,263],{"class":147},[141,29313,266],{"class":151},[141,29315,29316,29318,29320,29322],{"class":143,"line":165},[141,29317,193],{"class":151},[141,29319,196],{"class":151},[141,29321,159],{"class":158},[141,29323,201],{"class":147},[141,29325,29326],{"class":143,"line":210},[141,29327,207],{"emptyLinePlaceholder":206},[141,29329,29330,29332,29334],{"class":143,"line":219},[141,29331,481],{"class":151},[141,29333,484],{"class":151},[141,29335,487],{"class":147},[141,29337,29338],{"class":143,"line":234},[141,29339,207],{"emptyLinePlaceholder":206},[141,29341,29342,29344,29346,29348,29350],{"class":143,"line":241},[141,29343,222],{"class":151},[141,29345,159],{"class":158},[141,29347,500],{"class":147},[141,29349,504],{"class":503},[141,29351,507],{"class":147},[141,29353,29354,29356,29358,29360],{"class":143,"line":247},[141,29355,512],{"class":428},[141,29357,515],{"class":147},[141,29359,152],{"class":151},[141,29361,520],{"class":147},[141,29363,29364],{"class":143,"line":307},[141,29365,244],{"class":147},[141,29367,29368],{"class":143,"line":379},[141,29369,207],{"emptyLinePlaceholder":206},[141,29371,29372,29374,29376,29378],{"class":143,"line":391},[141,29373,222],{"class":151},[141,29375,225],{"class":151},[141,29377,353],{"class":158},[141,29379,231],{"class":147},[141,29381,29382,29384,29386],{"class":143,"line":396},[141,29383,543],{"class":147},[141,29385,434],{"class":158},[141,29387,162],{"class":147},[141,29389,29390],{"class":143,"line":401},[141,29391,244],{"class":147},[141,29393,29394],{"class":143,"line":554},[141,29395,250],{"class":147},[141,29397,29398],{"class":143,"line":559},[141,29399,207],{"emptyLinePlaceholder":206},[141,29401,29402,29404],{"class":143,"line":564},[141,29403,263],{"class":147},[141,29405,266],{"class":151},[141,29407,29408,29410,29412,29414],{"class":143,"line":571},[141,29409,193],{"class":151},[141,29411,196],{"class":151},[141,29413,578],{"class":158},[141,29415,201],{"class":147},[141,29417,29418],{"class":143,"line":583},[141,29419,207],{"emptyLinePlaceholder":206},[141,29421,29422,29424],{"class":143,"line":588},[141,29423,213],{"class":147},[141,29425,216],{"class":151},[141,29427,29428,29430,29432,29434],{"class":143,"line":595},[141,29429,222],{"class":151},[141,29431,225],{"class":151},[141,29433,386],{"class":158},[141,29435,231],{"class":147},[141,29437,29438],{"class":143,"line":606},[141,29439,238],{"class":237},[141,29441,29442],{"class":143,"line":611},[141,29443,244],{"class":147},[141,29445,29446],{"class":143,"line":616},[141,29447,250],{"class":147},[18,29449,621,29450,625,29452,629],{},[22,29451,624],{},[22,29453,628],{},[14,29455,633],{"id":632},[18,29457,636],{},[638,29459,641],{"id":640},[95,29461,29462],{"className":135,"code":644,"language":137,"meta":101,"style":101},[22,29463,29464,29470,29480],{"__ignoreMap":101},[141,29465,29466,29468],{"class":143,"line":144},[141,29467,263],{"class":147},[141,29469,216],{"class":151},[141,29471,29472,29474,29476,29478],{"class":143,"line":165},[141,29473,43],{"class":151},[141,29475,225],{"class":151},[141,29477,386],{"class":158},[141,29479,231],{"class":147},[141,29481,29482],{"class":143,"line":210},[141,29483,250],{"class":147},[18,29485,669],{},[638,29487,673],{"id":672},[95,29489,29490],{"className":135,"code":676,"language":137,"meta":101,"style":101},[22,29491,29492,29498,29510],{"__ignoreMap":101},[141,29493,29494,29496],{"class":143,"line":144},[141,29495,263],{"class":147},[141,29497,216],{"class":151},[141,29499,29500,29502,29504,29506,29508],{"class":143,"line":165},[141,29501,193],{"class":151},[141,29503,484],{"class":151},[141,29505,225],{"class":151},[141,29507,386],{"class":158},[141,29509,231],{"class":147},[141,29511,29512],{"class":143,"line":210},[141,29513,250],{"class":147},[18,29515,703,29516,706],{},[22,29517,47],{},[638,29519,710],{"id":709},[95,29521,29522],{"className":135,"code":713,"language":137,"meta":101,"style":101},[22,29523,29524,29530,29542],{"__ignoreMap":101},[141,29525,29526,29528],{"class":143,"line":144},[141,29527,263],{"class":147},[141,29529,216],{"class":151},[141,29531,29532,29534,29536,29538,29540],{"class":143,"line":165},[141,29533,193],{"class":151},[141,29535,728],{"class":151},[141,29537,225],{"class":151},[141,29539,386],{"class":158},[141,29541,231],{"class":147},[141,29543,29544],{"class":143,"line":210},[141,29545,250],{"class":147},[18,29547,741],{},[638,29549,745],{"id":744},[18,29551,748,29552,752,29554,755],{},[22,29553,751],{},[22,29555,193],{},[59,29557,29558],{},[18,29559,760],{},[14,29561,764],{"id":763},[18,29563,767,29564,770],{},[22,29565,39],{},[95,29567,29568],{"className":135,"code":773,"language":137,"meta":101,"style":101},[22,29569,29570,29576,29586,29592,29596,29600,29606,29616,29620],{"__ignoreMap":101},[141,29571,29572,29574],{"class":143,"line":144},[141,29573,263],{"class":147},[141,29575,782],{"class":151},[141,29577,29578,29580,29582,29584],{"class":143,"line":165},[141,29579,193],{"class":151},[141,29581,225],{"class":151},[141,29583,791],{"class":158},[141,29585,231],{"class":147},[141,29587,29588,29590],{"class":143,"line":210},[141,29589,798],{"class":158},[141,29591,162],{"class":147},[141,29593,29594],{"class":143,"line":219},[141,29595,250],{"class":147},[141,29597,29598],{"class":143,"line":234},[141,29599,207],{"emptyLinePlaceholder":206},[141,29601,29602,29604],{"class":143,"line":241},[141,29603,263],{"class":147},[141,29605,216],{"class":151},[141,29607,29608,29610,29612,29614],{"class":143,"line":247},[141,29609,193],{"class":151},[141,29611,225],{"class":151},[141,29613,823],{"class":158},[141,29615,231],{"class":147},[141,29617,29618],{"class":143,"line":307},[141,29619,830],{"class":237},[141,29621,29622],{"class":143,"line":379},[141,29623,250],{"class":147},[18,29625,837],{},[14,29627,841],{"id":840},[18,29629,844],{},[114,29631,29632,29636],{},[117,29633,29634,852],{},[22,29635,851],{},[117,29637,29638,858],{},[22,29639,857],{},[18,29641,861],{},[95,29643,29644],{"className":135,"code":864,"language":137,"meta":101,"style":101},[22,29645,29646,29652,29662,29670,29684],{"__ignoreMap":101},[141,29647,29648,29650],{"class":143,"line":144},[141,29649,263],{"class":147},[141,29651,216],{"class":151},[141,29653,29654,29656,29658,29660],{"class":143,"line":165},[141,29655,193],{"class":151},[141,29657,225],{"class":151},[141,29659,881],{"class":158},[141,29661,884],{"class":147},[141,29663,29664,29666,29668],{"class":143,"line":210},[141,29665,889],{"class":147},[141,29667,892],{"class":158},[141,29669,895],{"class":147},[141,29671,29672,29674,29676,29678,29680,29682],{"class":143,"line":219},[141,29673,900],{"class":151},[141,29675,155],{"class":151},[141,29677,905],{"class":158},[141,29679,908],{"class":147},[141,29681,912],{"class":911},[141,29683,915],{"class":147},[141,29685,29686],{"class":143,"line":234},[141,29687,250],{"class":147},[18,29689,922,29690,926],{},[22,29691,925],{},[95,29693,29694],{"className":135,"code":929,"language":137,"meta":101,"style":101},[22,29695,29696,29710,29720,29728,29742],{"__ignoreMap":101},[141,29697,29698,29700,29702,29704,29706,29708],{"class":143,"line":144},[141,29699,263],{"class":147},[141,29701,938],{"class":151},[141,29703,908],{"class":147},[141,29705,943],{"class":428},[141,29707,946],{"class":151},[141,29709,949],{"class":147},[141,29711,29712,29714,29716,29718],{"class":143,"line":165},[141,29713,193],{"class":151},[141,29715,225],{"class":151},[141,29717,881],{"class":158},[141,29719,884],{"class":147},[141,29721,29722,29724,29726],{"class":143,"line":210},[141,29723,889],{"class":147},[141,29725,892],{"class":158},[141,29727,895],{"class":147},[141,29729,29730,29732,29734,29736,29738,29740],{"class":143,"line":219},[141,29731,900],{"class":151},[141,29733,155],{"class":151},[141,29735,905],{"class":158},[141,29737,908],{"class":147},[141,29739,912],{"class":911},[141,29741,915],{"class":147},[141,29743,29744],{"class":143,"line":234},[141,29745,250],{"class":147},[18,29747,988],{},[95,29749,29750],{"className":135,"code":991,"language":137,"meta":101,"style":101},[22,29751,29752],{"__ignoreMap":101},[141,29753,29754,29756,29758,29760,29762,29764],{"class":143,"line":144},[141,29755,263],{"class":147},[141,29757,938],{"class":151},[141,29759,908],{"class":147},[141,29761,943],{"class":428},[141,29763,946],{"class":151},[141,29765,1008],{"class":147},[18,29767,29768,1014,29770,44,29772,1019],{},[22,29769,1013],{},[22,29771,943],{},[22,29773,1013],{},[14,29775,1023],{"id":1022},[18,29777,1026],{},[95,29779,29780],{"className":135,"code":1029,"language":137,"meta":101,"style":101},[22,29781,29782,29788,29798,29804,29812,29820,29832,29844,29848],{"__ignoreMap":101},[141,29783,29784,29786],{"class":143,"line":144},[141,29785,263],{"class":147},[141,29787,216],{"class":151},[141,29789,29790,29792,29794,29796],{"class":143,"line":165},[141,29791,193],{"class":151},[141,29793,225],{"class":151},[141,29795,228],{"class":158},[141,29797,231],{"class":147},[141,29799,29800,29802],{"class":143,"line":210},[141,29801,1052],{"class":151},[141,29803,201],{"class":147},[141,29805,29806,29808,29810],{"class":143,"line":219},[141,29807,1059],{"class":147},[141,29809,892],{"class":158},[141,29811,1064],{"class":147},[141,29813,29814,29816,29818],{"class":143,"line":234},[141,29815,1069],{"class":147},[141,29817,1072],{"class":158},[141,29819,1075],{"class":147},[141,29821,29822,29824,29826,29828,29830],{"class":143,"line":241},[141,29823,1080],{"class":147},[141,29825,1083],{"class":151},[141,29827,1086],{"class":147},[141,29829,1089],{"class":503},[141,29831,507],{"class":147},[141,29833,29834,29836,29838,29840,29842],{"class":143,"line":247},[141,29835,1096],{"class":147},[141,29837,1099],{"class":158},[141,29839,908],{"class":147},[141,29841,1104],{"class":911},[141,29843,1107],{"class":147},[141,29845,29846],{"class":143,"line":307},[141,29847,244],{"class":147},[141,29849,29850],{"class":143,"line":379},[141,29851,250],{"class":147},[18,29853,1118],{},[18,29855,1121],{},[95,29857,29858],{"className":135,"code":1124,"language":137,"meta":101,"style":101},[22,29859,29860,29870,29882,29888],{"__ignoreMap":101},[141,29861,29862,29864,29866,29868],{"class":143,"line":144},[141,29863,1083],{"class":151},[141,29865,1086],{"class":147},[141,29867,1089],{"class":503},[141,29869,507],{"class":147},[141,29871,29872,29874,29876,29878,29880],{"class":143,"line":165},[141,29873,1141],{"class":147},[141,29875,1099],{"class":158},[141,29877,908],{"class":147},[141,29879,1104],{"class":911},[141,29881,1107],{"class":147},[141,29883,29884,29886],{"class":143,"line":210},[141,29885,900],{"class":151},[141,29887,1156],{"class":147},[141,29889,29890],{"class":143,"line":219},[141,29891,250],{"class":147},[18,29893,1163],{},[95,29895,29896],{"className":135,"code":1166,"language":137,"meta":101,"style":101},[22,29897,29898,29902,29910],{"__ignoreMap":101},[141,29899,29900],{"class":143,"line":144},[141,29901,1173],{"class":147},[141,29903,29904,29906,29908],{"class":143,"line":165},[141,29905,1178],{"class":147},[141,29907,1181],{"class":158},[141,29909,1184],{"class":147},[141,29911,29912,29914,29916],{"class":143,"line":210},[141,29913,1178],{"class":147},[141,29915,1191],{"class":158},[141,29917,162],{"class":147},[18,29919,1196],{},[14,29921,1200],{"id":1199},[18,29923,1203,29924,1207],{},[22,29925,1206],{},[95,29927,29928],{"className":135,"code":1210,"language":137,"meta":101,"style":101},[22,29929,29930,29936,29946,29954,29958,29968,29976,29984],{"__ignoreMap":101},[141,29931,29932,29934],{"class":143,"line":144},[141,29933,263],{"class":147},[141,29935,216],{"class":151},[141,29937,29938,29940,29942,29944],{"class":143,"line":165},[141,29939,193],{"class":151},[141,29941,225],{"class":151},[141,29943,228],{"class":158},[141,29945,231],{"class":147},[141,29947,29948,29950,29952],{"class":143,"line":210},[141,29949,1233],{"class":147},[141,29951,892],{"class":158},[141,29953,1064],{"class":147},[141,29955,29956],{"class":143,"line":219},[141,29957,207],{"emptyLinePlaceholder":206},[141,29959,29960,29962,29964,29966],{"class":143,"line":234},[141,29961,1246],{"class":151},[141,29963,1249],{"class":158},[141,29965,1252],{"class":147},[141,29967,1255],{"class":151},[141,29969,29970,29972,29974],{"class":143,"line":241},[141,29971,1260],{"class":147},[141,29973,1072],{"class":158},[141,29975,1265],{"class":147},[141,29977,29978,29980,29982],{"class":143,"line":247},[141,29979,1270],{"class":147},[141,29981,1273],{"class":158},[141,29983,162],{"class":147},[141,29985,29986],{"class":143,"line":307},[141,29987,250],{"class":147},[18,29989,1282],{},[18,29991,29992,1288],{},[22,29993,1287],{},[95,29995,29997],{"className":29996,"code":1292,"language":100,"meta":101},[98],[22,29998,1292],{"__ignoreMap":101},[18,30000,1297],{},[14,30002,1301],{"id":1300},[18,30004,1304],{},[18,30006,1307],{},[1309,30008,30009,30019],{},[1312,30010,30011],{},[1315,30012,30013,30015,30017],{},[1318,30014,1320],{},[1318,30016,1323],{},[1318,30018,1326],{},[1328,30020,30021,30031,30041,30051,30061],{},[1315,30022,30023,30027,30029],{},[1333,30024,30025],{},[22,30026,1337],{},[1333,30028,1340],{},[1333,30030,1343],{},[1315,30032,30033,30037,30039],{},[1333,30034,30035],{},[22,30036,1350],{},[1333,30038,1353],{},[1333,30040,1356],{},[1315,30042,30043,30047,30049],{},[1333,30044,30045],{},[22,30046,1363],{},[1333,30048,1366],{},[1333,30050,1369],{},[1315,30052,30053,30057,30059],{},[1333,30054,30055],{},[22,30056,1376],{},[1333,30058,1379],{},[1333,30060,1382],{},[1315,30062,30063,30067,30069],{},[1333,30064,30065],{},[22,30066,1389],{},[1333,30068,1392],{},[1333,30070,1395],{},[18,30072,1398],{},[95,30074,30075],{"className":135,"code":1401,"language":137,"meta":101,"style":101},[22,30076,30077,30091,30101,30109],{"__ignoreMap":101},[141,30078,30079,30081,30083,30085,30087,30089],{"class":143,"line":144},[141,30080,263],{"class":147},[141,30082,938],{"class":151},[141,30084,908],{"class":147},[141,30086,1414],{"class":428},[141,30088,946],{"class":151},[141,30090,1419],{"class":147},[141,30092,30093,30095,30097,30099],{"class":143,"line":165},[141,30094,193],{"class":151},[141,30096,225],{"class":151},[141,30098,1428],{"class":158},[141,30100,231],{"class":147},[141,30102,30103,30105,30107],{"class":143,"line":210},[141,30104,1435],{"class":147},[141,30106,892],{"class":158},[141,30108,1440],{"class":147},[141,30110,30111],{"class":143,"line":219},[141,30112,250],{"class":147},[18,30114,1447],{},[18,30116,1450],{},[14,30118,1454],{"id":1453},[18,30120,1457],{},[95,30122,30123],{"className":135,"code":1460,"language":137,"meta":101,"style":101},[22,30124,30125,30141,30151,30155],{"__ignoreMap":101},[141,30126,30127,30129,30131,30133,30135,30137,30139],{"class":143,"line":144},[141,30128,263],{"class":147},[141,30130,938],{"class":151},[141,30132,908],{"class":147},[141,30134,1473],{"class":428},[141,30136,946],{"class":151},[141,30138,1478],{"class":911},[141,30140,1481],{"class":147},[141,30142,30143,30145,30147,30149],{"class":143,"line":165},[141,30144,193],{"class":151},[141,30146,225],{"class":151},[141,30148,228],{"class":158},[141,30150,231],{"class":147},[141,30152,30153],{"class":143,"line":210},[141,30154,1496],{"class":237},[141,30156,30157],{"class":143,"line":219},[141,30158,250],{"class":147},[18,30160,1503],{},[18,30162,1506],{},[114,30164,30165,30169,30171,30173],{},[117,30166,30167,1513],{},[22,30168,28],{},[117,30170,1516],{},[117,30172,1519],{},[117,30174,1522],{},[18,30176,1525],{},[14,30178,1529],{"id":1528},[18,30180,1532],{},[114,30182,30183,30185,30187,30189,30191],{},[117,30184,1537],{},[117,30186,1540],{},[117,30188,1543],{},[117,30190,1546],{},[117,30192,1549],{},[18,30194,1552,30195,1555],{},[22,30196,28],{},[18,30198,1558],{},[95,30200,30201],{"className":135,"code":1561,"language":137,"meta":101,"style":101},[22,30202,30203,30209,30219,30227,30235,30249],{"__ignoreMap":101},[141,30204,30205,30207],{"class":143,"line":144},[141,30206,263],{"class":147},[141,30208,216],{"class":151},[141,30210,30211,30213,30215,30217],{"class":143,"line":165},[141,30212,193],{"class":151},[141,30214,225],{"class":151},[141,30216,228],{"class":158},[141,30218,231],{"class":147},[141,30220,30221,30223,30225],{"class":143,"line":210},[141,30222,1233],{"class":147},[141,30224,892],{"class":158},[141,30226,1064],{"class":147},[141,30228,30229,30231,30233],{"class":143,"line":219},[141,30230,1592],{"class":147},[141,30232,1595],{"class":158},[141,30234,1064],{"class":147},[141,30236,30237,30239,30241,30243,30245,30247],{"class":143,"line":234},[141,30238,900],{"class":151},[141,30240,155],{"class":151},[141,30242,1606],{"class":158},[141,30244,908],{"class":147},[141,30246,1611],{"class":911},[141,30248,915],{"class":147},[141,30250,30251],{"class":143,"line":241},[141,30252,250],{"class":147},[18,30254,1620],{},[14,30256,1624],{"id":1623},[18,30258,1627,30259,1630],{},[22,30260,28],{},[95,30262,30263],{"className":135,"code":1633,"language":137,"meta":101,"style":101},[22,30264,30265,30271,30285,30289,30295,30301,30311,30315,30319],{"__ignoreMap":101},[141,30266,30267,30269],{"class":143,"line":144},[141,30268,263],{"class":147},[141,30270,266],{"class":151},[141,30272,30273,30275,30277,30279,30281,30283],{"class":143,"line":165},[141,30274,193],{"class":151},[141,30276,196],{"class":151},[141,30278,1650],{"class":158},[141,30280,1653],{"class":151},[141,30282,159],{"class":158},[141,30284,201],{"class":147},[141,30286,30287],{"class":143,"line":210},[141,30288,207],{"emptyLinePlaceholder":206},[141,30290,30291,30293],{"class":143,"line":219},[141,30292,213],{"class":147},[141,30294,1668],{"class":151},[141,30296,30297,30299],{"class":143,"line":234},[141,30298,213],{"class":147},[141,30300,216],{"class":151},[141,30302,30303,30305,30307,30309],{"class":143,"line":241},[141,30304,222],{"class":151},[141,30306,225],{"class":151},[141,30308,228],{"class":158},[141,30310,231],{"class":147},[141,30312,30313],{"class":143,"line":247},[141,30314,238],{"class":237},[141,30316,30317],{"class":143,"line":307},[141,30318,244],{"class":147},[141,30320,30321],{"class":143,"line":379},[141,30322,250],{"class":147},[18,30324,1699],{},[14,30326,1703],{"id":1702},[638,30328,1707],{"id":1706},[18,30330,1710],{},[114,30332,30333,30335,30337,30339],{},[117,30334,1715],{},[117,30336,1718],{},[117,30338,1721],{},[117,30340,1724],{},[18,30342,1727],{},[638,30344,1731],{"id":1730},[18,30346,1734],{},[95,30348,30350],{"className":30349,"code":1738,"language":100,"meta":101},[98],[22,30351,1738],{"__ignoreMap":101},[638,30353,1744],{"id":1743},[18,30355,1747],{},[95,30357,30359],{"className":30358,"code":1751,"language":100,"meta":101},[98],[22,30360,1751],{"__ignoreMap":101},[18,30362,1756],{},[638,30364,1760],{"id":1759},[18,30366,1763],{},[114,30368,30369,30371,30377,30379],{},[117,30370,1768],{},[117,30372,1771,30373,44,30375,1776],{},[22,30374,1350],{},[22,30376,1376],{},[117,30378,1779],{},[117,30380,1782],{},[14,30382,1786],{"id":1785},[1309,30384,30385,30393],{},[1312,30386,30387],{},[1315,30388,30389,30391],{},[1318,30390,1795],{},[1318,30392,1798],{},[1328,30394,30395,30401,30409,30415,30423,30431,30437],{},[1315,30396,30397,30399],{},[1333,30398,1805],{},[1333,30400,1808],{},[1315,30402,30403,30405],{},[1333,30404,1813],{},[1333,30406,1816,30407,1819],{},[22,30408,35],{},[1315,30410,30411,30413],{},[1333,30412,1824],{},[1333,30414,1827],{},[1315,30416,30417,30419],{},[1333,30418,1832],{},[1333,30420,1771,30421],{},[22,30422,1350],{},[1315,30424,30425,30427],{},[1333,30426,1841],{},[1333,30428,1844,30429,1847],{},[22,30430,1287],{},[1315,30432,30433,30435],{},[1333,30434,1852],{},[1333,30436,1855],{},[1315,30438,30439,30441],{},[1333,30440,1860],{},[1333,30442,1863],{},[14,30444,1867],{"id":1866},[114,30446,30447,30452,30457,30462,30467],{},[117,30448,30449],{},[73,30450,1877],{"href":1874,"rel":30451},[1876],[117,30453,30454],{},[73,30455,1884],{"href":1882,"rel":30456},[1876],[117,30458,30459],{},[73,30460,1891],{"href":1889,"rel":30461},[1876],[117,30463,30464],{},[73,30465,1898],{"href":1896,"rel":30466},[1876],[117,30468,30469],{},[73,30470,1905],{"href":1903,"rel":30471},[1876],[1907,30473,1909],{},{"title":101,"searchDepth":165,"depth":165,"links":30475},[30476,30477,30478,30479,30480,30481,30482,30488,30489,30490,30491,30492,30493,30494,30495,30496,30502,30503],{"id":16,"depth":165,"text":16},{"id":69,"depth":165,"text":69},{"id":86,"depth":165,"text":86},{"id":89,"depth":165,"text":90},{"id":128,"depth":165,"text":129},{"id":315,"depth":165,"text":316},{"id":632,"depth":165,"text":633,"children":30483},[30484,30485,30486,30487],{"id":640,"depth":210,"text":641},{"id":672,"depth":210,"text":673},{"id":709,"depth":210,"text":710},{"id":744,"depth":210,"text":745},{"id":763,"depth":165,"text":764},{"id":840,"depth":165,"text":841},{"id":1022,"depth":165,"text":1023},{"id":1199,"depth":165,"text":1200},{"id":1300,"depth":165,"text":1301},{"id":1453,"depth":165,"text":1454},{"id":1528,"depth":165,"text":1529},{"id":1623,"depth":165,"text":1624},{"id":1702,"depth":165,"text":1703,"children":30497},[30498,30499,30500,30501],{"id":1706,"depth":210,"text":1707},{"id":1730,"depth":210,"text":1731},{"id":1743,"depth":210,"text":1744},{"id":1759,"depth":210,"text":1760},{"id":1785,"depth":165,"text":1786},{"id":1866,"depth":165,"text":1867},{},{"title":5,"description":1941},1785662843071]