[不可变字符串]的搜索结果

...期结束后开始后的线程不可能读到已删除的元素。为此RCU机制提供了相应的API来实现这个功能。 void foo_read（void）{rcu_read_lock（）;foo fp = gbl_foo;if （ fp ！= NULL ）dosomething（fp-》a，fp-》b，fp-》c）;rcu_read_unlock（）;}void foo_update（ foo new_fp ）{spin_lock（&foo_mutex）;foo old_fp = gbl_foo;gbl_foo = new_fp;spin_unlock（&foo_mutex）;synchronize_rcu（）;kfee（old_fp）;} 其中foo_read中增加了rcu_read_lock和rcu_read_unlock，这两个函数用来标记一个RCU读过程的开始和结束。其实作用就是帮助检测宽限期是否结束。 foo_update增加了一个函数synchronize_rcu（），调用该函数意味着一个宽限期的开始，而直到宽限期结束，该函数才会返回。我们再对比着图看一看，线程1和2，在synchronize_rcu之前可能得到了旧的gbl_foo，也就是foo_update中的old_fp，如果不等它们运行结束，就调用kfee（old_fp），极有可能造成系统崩溃。而3，4，6在synchronize_rcu之后运行，此时它们已经不可能得到old_fp，此次的kfee将不对它们产生影响。 宽限期是RCU实现中最复杂的部分，原因是在提高读数据性能的同时，删除数据的性能也不能太差。 订阅——发布机制 当前使用的编译器大多会对代码做一定程度的优化，CPU也会对执行指令做一些优化调整，目的是提高代码的执行效率，但这样的优化，有时候会带来不期望的结果。如例： void foo_update（ foo new_fp ）{spin_lock（&foo_mutex）;foo old_fp = gbl_foo;new_fp-》a = 1;new_fp-》b = ‘b’;new_fp-》c = 100;gbl_foo = new_fp;spin_unlock（&foo_mutex）;synchronize_rcu（）;kfee（old_fp）;} 这段代码中，我们期望的是6，7，8行的代码在第10行代码之前执行。但优化后的代码并不会对执行顺序做出保证。在这种情形下，一个读线程很可能读到 new_fp，但new_fp的成员赋值还没执行完成。单独线程执行dosomething（fp-》a， fp-》b ， fp-》c ） 的 这个时候，就有不确定的参数传入到dosomething，极有可能造成不期望的结果，甚至程序崩溃。可以通过优化屏障来解决该问题，RCU机制对优化屏障做了包装，提供了专用的API来解决该问题。这时候，第十行不再是直接的指针赋值，而应该改为 ： rcu_assign_pointer（gbl_foo，new_fp）;rcu_assign_pointer的实现比较简单，如下：define rcu_assign_pointer（p， v） \__rcu_assign_pointer（（p）， （v）， __rcu）define __rcu_assign_pointer（p， v， space） \do { \smp_wmb（）; \（p） = （typeof（v） __force space ）（v）; \} while （0） 我们可以看到它的实现只是在赋值之前加了优化屏障 smp_wmb来确保代码的执行顺序。另外就是宏中用到的__rcu，只是作为编译过程的检测条件来使用的。 在DEC Alpha CPU机器上还有一种更强悍的优化，如下所示： void foo_read（void）{rcu_read_lock（）;foo fp = gbl_foo;if （ fp ！= NULL ）dosomething（fp-》a， fp-》b ，fp-》c）;rcu_read_unlock（）;} 第六行的 fp-》a，fp-》b，fp-》c会在第3行还没执行的时候就预先判断运行，当他和foo_update同时运行的时候，可能导致传入dosomething的一部分属于旧的gbl_foo，而另外的属于新的。这样会导致运行结果的错误。为了避免该类问题，RCU还是提供了宏来解决该问题： define rcu_dereference（p） rcu_dereference_check（p， 0）define rcu_dereference_check（p， c） \__rcu_dereference_check（（p）， rcu_read_lock_held（） || （c）， __rcu）define __rcu_dereference_check（p， c， space） \（{ \typeof（p） _________p1 = （typeof（p）__force ）ACCESS_ONCE（p）; \rcu_lockdep_assert（c， “suspicious rcu_dereference_check（）” \usage”）; \rcu_dereference_sparse（p， space）; \smp_read_barrier_depends（）; \（typeof（p） __force __kernel ）（_________p1））; \}）staTIc inline int rcu_read_lock_held（void）{if （！debug_lockdep_rcu_enabled（））return 1;if （rcu_is_cpu_idle（））return 0;if （！rcu_lockdep_current_cpu_online（））return 0;return lock_is_held（&rcu_lock_map）;} 这段代码中加入了调试信息，去除调试信息，可以是以下的形式（其实这也是旧版本中的代码）： define rcu_dereference（p） （{ \typeof（p） _________p1 = p; \smp_read_barrier_depends（）; \（_________p1）; \}） 在赋值后加入优化屏障smp_read_barrier_depends（）。我们之前的第四行代码改为 foo fp = rcu_dereference（gbl_foo）;，就可以防止上述问题。 数据读取的完整性 还是通过例子来说明这个问题： 如图我们在原list中加入一个节点new到A之前，所要做的第一步是将new的指针指向A节点，第二步才是将Head的指针指向new。这样做的目的是当插入操作完成第一步的时候，对于链表的读取并不产生影响，而执行完第二步的时候，读线程如果读到new节点，也可以继续遍历链表。如果把这个过程反过来，第一步head指向new，而这时一个线程读到new，由于new的指针指向的是Null，这样将导致读线程无法读取到A，B等后续节点。从以上过程中，可以看出RCU并不保证读线程读取到new节点。如果该节点对程序产生影响，那么就需要外部调用来做相应的调整。如在文件系统中，通过RCU定位后，如果查找不到相应节点，就会进行其它形式的查找，相关内容等分析到文件系统的时候再进行叙述。 我们再看一下删除一个节点的例子： 如图我们希望删除B，这时候要做的就是将A的指针指向C，保持B的指针，然后删除程序将进入宽限期检测。由于B的内容并没有变更，读到B的线程仍然可以继续读取B的后续节点。B不能立即销毁，它必须等待宽限期结束后，才能进行相应销毁操作。由于A的节点已经指向了C，当宽限期开始之后所有的后续读操作通过A找到的是C，而B已经隐藏了，后续的读线程都不会读到它。这样就确保宽限期过后，删除B并不对系统造成影响。 小结 RCU的原理并不复杂，应用也很简单。但代码的实现确并不是那么容易，难点都集中在了宽限期的检测上，后续分析源代码的时候，我们可以看到一些极富技巧的实现方式。 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_50662680/article/details/128449401。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...为软件开发和运维领域不可或缺的一部分。Docker作为这一领域的领头羊，其影响力不断扩大，尤其是在Node.js社区中，越来越多的开发者开始采用Docker来简化开发、测试和部署流程。近期，一项关于全球开发者技术趋势的调查显示，超过60%的受访者表示他们在过去一年中使用过Docker进行项目管理，其中Node.js开发者占比尤为突出。这种趋势表明，容器化技术正在深刻改变软件开发的方式。 与此同时，Docker公司最近宣布了一项新的开源计划，旨在推动容器技术的标准化和安全性。这一计划名为“Open Container Initiative”（OCI），旨在制定一套通用的标准，使得不同厂商的容器技术能够更好地协同工作。这对于Node.js开发者而言是一个重要的利好消息，因为这意味着未来的Docker镜像将更加兼容，开发者可以更轻松地在不同平台上迁移和共享他们的应用。 此外，随着Kubernetes的兴起，容器编排工具逐渐成为主流。Kubernetes不仅支持Docker容器，还提供了强大的自动化管理能力，使得大规模部署Node.js应用变得更加高效。例如，某知名电商公司在去年成功将其电商平台迁移到基于Kubernetes的Docker容器集群上，不仅提升了系统的稳定性和扩展性，还显著降低了运维成本。 从长远来看，容器化技术将继续推动DevOps文化的普及，促进开发人员和运维团队之间的协作。正如Linux之父Linus Torvalds所说：“开源的本质在于合作而非竞争。”通过拥抱开源技术和社区的力量，开发者可以更快地创新并解决实际问题。对于Node.js开发者而言，掌握Docker和Kubernetes等工具，不仅是技术上的提升，更是职业发展的必要条件。在未来几年，我们有理由相信，容器化技术将在更多领域展现出其独特的价值，为软件行业带来更多的可能性。

...程序员,这本书就非看不可。 三、Python编程从入门到实践 《Python编程从入门到实践》书如其名，本书简明清晰地讲解了入门Python所需学习的基本知识，同时在讲解过程中穿插实战演练，使读者对Python有更加深刻的理解，是一本入门Python的难得好书，推荐给大家学习。 我想说，Python是否值得学,已经不再是值得怀疑的问题了。但是，如何能高效学会Python,永远是个值得思考的重要问题。这个问题的答案，是绕不开本书的。 四、Java编程思想 《Java编程思想（第4版）》赢得了全球程序员的广泛赞誉，即使是最晦涩的概念，在Bruce Eckel的文字亲和力和小而直接的编程示例面前也会化解于无形。从Java的基础语法到最高级特性（深入的面向对象概念、多线程、自动项目构建、单元测试和调试等），《Java编程思想（第4版）》都能逐步指导你轻松掌握。从java编程思想这本书获得的各项大奖以及来自世界各地的读者评论中，不难看出这是一本经典之作。 五、算法导论 《算法导论》提供了对当代计算机算法研究的一个全面、综合性的介绍。全书共八部分，内容涵盖基础知识、排序和顺序统计量、数据结构、高级设计和分析技术、高级数据结构、图算法、算法问题选编，以及数学基础知识。书中深入浅出地介绍了大量的算法及相关的数据结构，以及用于解决一些复杂计算问题的高级策略（如动态规划、贪心算法、摊还分析等），重点在于算法的分析与设计。对于每一个专题，作者都试图提供目前最新的研究成果及样例解答，并通过清晰的图示来说明算法的执行过程。 六、深入理解计算机系统 《深入理解计算机系统》是将计算机软件和硬件理论结合讲述的经典教程，内容覆盖计算机导论、体系结构和处理器设计等多门课程。本书的大优点是为程序员描述计算机系统的实现细节，通过描述程序是如何映射到系统上，以及程序是如何执行的，使读者更好地理解程序的行为为什么是这样的，以及造成效率低下的原因。 七、鸟哥的Linux私房菜 《鸟哥的Linux私房菜基础学习篇》全面而详细地介绍了Linux操作系统。着重说明计算机的基础知识、Linux的学习方法，如何规划和安装Linux主机以及CentOS 7.x的安装、登录与求助方法；介绍Linux的文件系统、文件、目录与磁盘的管理；文字模式接口shell和管理系统的好帮手shell脚本，另外还介绍了文字编辑器vi和vim的使用方法；对于系统安全非常重要的Linux账号的管理、磁盘配额、高级文件系统管理、计划任务以及进程管理，系统管理员（root）的管理事项。 本书内容丰富全面，基本概念的讲解非常细致，深入浅出。各种功能和命令的介绍，都配以大量的实例操作和详尽的解析。本书是初学者学习Linux不可多得的一本入门好书。 八、计算机网络自顶向下方法 《计算机网络自顶向下方法》是经典的计算机网络教材，采用作者独创的自顶向下方法来讲授计算机网络的原理及其协议，自第1版出版以来已经被数百所大学和学院选作教材，被译为14种语言。 新版保持了以前版本的特色，继续关注因特网和计算机网络的现代处理方式，注重原理和实践，为计算机网络教学提供一种新颖和与时俱进的方法。同时，第7版进行了相当多的修订和更新，首次改变了各章的组织结构，将网络层分成两章（第4章关注网络层的数据平面，第5章关注网络层的控制平面） 九、MySQL是怎样运行的 《MySQL是怎样运行的》采用诙谐幽默、通俗易懂的写作风格，针对上面这些问题给出了相应的解答方案。尽管本书的表达方式与司空见惯的学术派、理论派IT图书有显著区别，但本书的确是相当正经的专业技术图书，内容涵盖了使用MySQL的同学在求职面试和工作中常见的一些核心概念。无论是身居MySQL专家身份的技术人员，还是技术有待进一步提升的DBA，甚至是刚投身于数据库行业的“萌新”人员，本书都是他们彻底了解MySQL运行原理的优秀图书。 十、编程珠玑 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_65485112/article/details/122007938。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...为我国经济社会发展中不可或缺的力量，其市民化过程不仅关乎个人命运变迁，更影响着新型城镇化乃至整个国家的发展走向。社会各界应密切关注这一群体的需求变化，提供更加全面的支持和服务，共同助力新生代农民工顺利融入城市，共享社会发展成果。

...nals》系列书籍是不可多得的权威资料，它不仅详细解析了Windows操作系统的内部工作原理，还包含许多关于如何有效利用Sysinternals工具进行问题排查的实际案例。 综上所述， Sysinternals作为Windows系统管理员和开发者的重要武器库，其价值和影响力随着技术进步和安全挑战的升级而不断提升。关注Sysinternals工具集的最新进展和应用实践，将有助于提升个人技能，更好地应对复杂的信息技术挑战。

...力之外，组织文化也是不可忽视的一环。管理层需要认识到安全不仅仅是IT部门的责任，而是整个公司的共同使命。通过开展定期培训和模拟演练，增强员工的安全意识，从而构建起一道坚固的心理防线。 最后，参考国际标准如ISO/IEC 27001信息安全管理体系，可以帮助企业在设计和实施安全措施时遵循统一规范。通过不断学习最新的安全趋势和技术动态，企业能够更好地保护自己的资产免受威胁。总之，面对日益复杂的网络环境，唯有保持警惕并积极行动，才能真正实现Elasticsearch乃至整个IT基础设施的安全稳定运行。

...提到了嗓子眼儿。 “不可能啊，之前都好好的，怎么今天就出问题了呢？”我心里嘀咕着。于是我赶紧翻看日志，发现报了一个错：“Config file not found in Nacos”。这下脑子更乱了，心里直嘀咕：“完啦，Nacos服务器该不会是罢工了吧？” 一想到这儿，赶紧三步并作两步跑去查看Nacos的状态，结果一看，嘿，人家还挺精神地在那里工作呢！ “不对劲啊，难道是我自己的代码出了问题？”我开始怀疑自己是不是哪里写错了。为了验证这个假设，我先尝试重启服务，但还是不行。然后我又跑到Nacos的配置管理页面瞅了一眼，嘿，发现配置文件确实已经上传成功了，路径啥的一点问题都没有，挺顺利的！这让我更加困惑了。 “真是奇怪，到底是哪里出问题了呢？”我决定一步步排查这个问题。 --- 二、初步排查 配置路径和权限 首先，我想到的第一个可能性就是配置路径的问题。其实 Nacos 是靠路径来找配置文件的，要是路径搞错了，那它就压根找不到文件，更别提读出来了。 我打开代码，仔细检查了Nacos客户端的初始化部分： java NacosConfigService configService = NacosFactory.createConfigService("http://localhost:8848"); 这段代码看起来没问题啊，路径明明指向的是本地的Nacos服务器。而且我之前测试的时候也是这么写的，一直都没问题。 “会不会是配置路径格式变了？”我又重新检查了一遍Nacos的配置管理页面，确认路径确实正确无误。然后我又检查了权限设置，确保服务有权限访问这些配置。 “权限应该没问题吧，毕竟之前都好好的。”我自言自语道。不过嘛，我总觉得不放心，就随手叫上咱们的运维小伙伴帮我看了一下Nacos服务端的配置权限。没想到一看还真发现了点小问题，仔细一排查才发现权限其实没啥大事儿，一切正常！ “看来不是路径和权限的问题，那问题到底出在哪呢？”我有点沮丧，但还是不死心，继续往下查。 --- 三、深入排查 网络连接与超时设置 接下来，我开始怀疑是不是网络连接出了问题。毕竟Nacos是基于网络通信的，如果网络不通畅，那自然会导致读取失败。 我先检查了Nacos服务端的日志，发现并没有什么异常。再瞧瞧服务端的那个监听端口，嘿，8848端口不仅开着呢，而且服务还稳稳地在跑着，一点问题没有！ “难道是客户端的网络问题？”我心中一动，赶紧查看了服务端的防火墙规则，确认没有阻断任何请求。接着我又尝试ping了一下Nacos服务端的IP地址，结果发现网络连通性很好。 “网络应该没问题啊，那会不会是超时时间设置得太短了？”我灵机一动，想到之前在其他项目中遇到过类似的问题，可能是客户端等待响应的时间太短，导致请求超时。 于是我修改了Nacos客户端的配置，增加了超时时间： java Properties properties = new Properties(); properties.put(PropertyKeyConst.SERVER_ADDR, "localhost:8848"); properties.put(PropertyKeyConst.CONNECT_TIMEOUT_MS, "5000"); // 增加到5秒 NacosConfigService configService = NacosFactory.createConfigService(properties); 重新启动服务后，问题依然存在。看来超时时间也不是主要原因。 “真是搞不懂啊，难道是Nacos本身的问题？”我有些泄气，但还是决定继续深挖下去。 --- 四、终极排查 代码逻辑与异常处理 最后，我决定从代码逻辑入手，看看是不是程序内部的某些逻辑出了问题。于是我打开了Nacos客户端的源码，开始逐行分析。 在Nacos客户端的实现中，有一个方法是用来获取配置的： java String content = configService.getConfig(dataId, group, timeoutMs); 我仔细检查了这个方法的调用点，发现它是在服务启动时被调用的。你瞧，服务一启动呢，就会加载一堆东西，像数据库连接池啦，缓存配置啦，各种各样的“装备”都得准备好，这样它才能顺利开工干活呀！ “会不会是某个配置项的加载顺序影响了Nacos的读取？”我突然想到这一点。我琢磨着这事儿，干脆把所有的配置加载顺序仔仔细细捋了一遍，就为了确保Nacos的配置能在服务刚启动的时候就给安排上，别拖到后面出了幺蛾子。 同时，我还加强了异常处理逻辑，给Nacos的读取操作加上了try-catch块，以便捕获具体的异常信息： java try { String content = configService.getConfig(dataId, group, timeoutMs); System.out.println("Config loaded successfully: " + content); } catch (NacosException e) { System.err.println("Failed to load config: " + e.getMessage()); } 经过一番调整后，我再次启动服务，终于看到了一条令人振奋的消息：“Config loaded successfully”。 “太好了！”我长舒一口气，“原来问题就出在这里啊。” --- 五、总结与感悟 经过这次折腾，我对Nacos有了更深的理解。Nacos这东西确实挺牛的，是个超棒的配置管理工具，但用着用着你会发现，它也不是完美无缺的，各种小问题啊、坑啊，时不时就冒出来折腾你一下。其实吧，这些问题真不一定是Nacos自己惹的祸，八成是咱们的代码写得有点问题，或者是环境配错了，带偏了Nacos。 “其实啊，调试的过程就像侦探破案一样，需要耐心和细心。我坐在电脑前忍不住感慨：“哎，有时候觉得这问题看起来平平无奇的，可谁知道背后可能藏着啥惊天大秘密呢！”” 总之，这次经历让我明白了一个道理：遇到问题不要慌，要冷静分析，逐步排查。只有这样，才能找到问题的根本原因，解决问题。希望我的经验能对大家有所帮助，如果有类似的问题，不妨按照这个思路试试看！

...搜索引擎架构中发挥着不可或缺的作用。面对未来的挑战，它不仅需要持续优化现有功能，还需不断创新，以适应不断变化的市场需求和技术发展趋势。通过融合前沿技术，Apache Lucene有望在未来的信息检索领域中继续引领创新，为用户提供更高效、更智能、更安全的搜索体验。 --- 这篇“延伸阅读”旨在讨论Apache Lucene在当前及未来可能面临的技术挑战与发展方向，强调其在现代搜索引擎架构中的核心地位，并提出可能的解决方案和展望。通过深入分析当前应用优势、面临的挑战及未来发展趋势，为读者提供了一个全面而前瞻性的视角。

...仍然是许多企业和组织不可或缺的选择。未来，Hadoop可能会与其他新兴技术深度融合，共同推动大数据产业的进步。

...精度时间同步协议都是不可或缺的一环。

...在正常的业务逻辑中是不可避免的，而解决循环引用的方法最有效就是改用weak_ptr，具体可见下一章。 class A {public:shared_ptr<B> b;};class B {public:shared_ptr<A> a;};int main(int argc, const char argv[]) {shared_ptr<A> spa = make_shared<A>();shared_ptr<B> spb = make_shared<B>();spa->b = spb;spb->a = spa;return 0;} //main函数退出后，spa和spb强引用计数依然为1，无法释放 刚柔并济：weak_ptr 正如上一章提到，使用shared_ptr过程中有可能会出现循环引用，关键原因是使用shared_ptr引用一个指针时会导致强引用计数+1，从此该指针的生命周期就会取决于该shared_ptr的生命周期，然而，有些情况我们一个类A里面只是想引用一下另外一个类B的对象，类B对象的创建不在类A，因此类A也无需管理类B对象的释放，这个时候weak_ptr就应运而生了，使用shared_ptr赋值给一个weak_ptr不会增加强引用计数（strong_count），取而代之的是增加一个弱引用计数（weak_count），而弱引用计数不会影响到指针的生命周期，这就解开了循环引用，上一章最后的代码使用weak_ptr可改造为如下代码。 class A {public:shared_ptr<B> b;};class B {public:weak_ptr<A> a;};int main(int argc, const char argv[]) {shared_ptr<A> spa = make_shared<A>();shared_ptr<B> spb = make_shared<B>();spa->b = spb; //spb强引用计数为2，弱引用计数为1spb->a = spa; //spa强引用计数为1，弱引用计数为2return 0;} //main函数退出后，spa先释放，spb再释放，循环解开了使用weak_ptr也有需要注意的点，因为既然weak_ptr不负责裸指针的生命周期，那么weak_ptr也无法直接操作裸指针，我们需要先转化为shared_ptr，这就和OC的Strong-Weak Dance有点像了，具体操作如下：shared_ptr<int> spa = make_shared<int>(10);weak_ptr<int> spb = spa; //weak_ptr无法直接使用裸指针创建if (!spb.expired()) { //weak_ptr最好判断是否过期，使用expired或use_count方法，前者更快spb.lock() += 10; //调用weak_ptr转化为shared_ptr后再操作裸指针}cout << spa << endl; //20 智能指针原理 看到这里，智能指针的用法基本介绍完了，后面笔者来粗浅地分析一下为什么智能指针可以有效帮我们管理裸指针的生命周期。 使用栈对象管理堆对象 在C++中，内存会分为三部分，堆、栈和静态存储区，静态存储区会存放全局变量和静态变量，在程序加载时就初始化，而堆是由程序员自行分配，自行释放的，例如我们使用裸指针分配的内存；而最后栈是系统帮我们分配的，所以也会帮我们自动回收。因此，智能指针就是利用这一性质，通过一个栈上的对象（shared_ptr或unique_ptr）来管理一个堆上的对象（裸指针），在shared_ptr或unique_ptr的析构函数中判断当前裸指针的引用计数情况来决定是否释放裸指针。 shared_ptr引用计数的原理 一开始笔者以为引用计数是放在shared_ptr这个模板类中，但是细想了一下，如果这样将shared_ptr赋值给另一个shared_ptr时，是怎么做到两个shared_ptr的引用计数同时加1呢，让等号两边的shared_ptr中的引用计数同时加1？不对，如果还有第二个shared_ptr再赋值给第三个shared_ptr那怎么办呢？或许通过下面的类图便清楚个中奥秘。 [ boost中shared_ptr与weak_ptr类图 ] 我们重点关注shared_ptr<T>的类图，它就是我们可以直接操作的类，这里面包含裸指针T，还有一个shared_count的对象，而shared_count对象还不是最终的引用计数，它只是包含了一个指向sp_counted_base的指针，这应该就是真正存放引用计数的地方，包括强应用计数和弱引用计数，而且shared_count中包含的是sp_counted_base的指针，不是对象，这也就意味着假如shared_ptr<T> a = b，那么a和b底层pi_指针指向的是同一个sp_counted_base对象，这就很容易做到多个shared_ptr的引用计数永远保持一致了。 多线程安全 本章所说的线程安全有两种情况： 多个线程操作多个不同的shared_ptr对象 C++11中声明了shared_ptr的计数操作具有原子性，不管是赋值导致计数增加还是释放导致计数减少，都是原子性的，这个可以参考sp_counted_base的源码，因此，基于这个特性，假如有多个shared_ptr共同管理一个裸指针，那么多个线程分别通过不同的shared_ptr进行操作是线程安全的。 多个线程操作同一个shared_ptr对象 同样的道理，既然C++11只负责sp_counted_base的原子性，那么shared_ptr本身就没有保证线程安全了，加入两个线程同时访问同一个shared_ptr对象，一个进行释放（reset），另一个读取裸指针的值，那么最后的结果就不确定了，很有可能发生野指针访问crash。 作者：腾讯技术工程 https://mp.weixin.qq.com/s?__biz=MjM5ODYwMjI2MA==&mid=2649743462&idx=1&sn=c9d94ddc25449c6a0052dc48392a33c2&utm_source=tuicool&utm_medium=referralmp.weixin.qq.com 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_31467557/article/details/113049179。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...盘I/O瓶颈，都不是不可克服的障碍。其实吧，只要咱们肯花点心思去琢磨、去试试，肯定能找出个适合自己情况的办法。 最后，我想说的是，作为一名技术人员，我们应该始终保持好奇心和探索精神。不要害怕失败，也不要急于求成，因为每一次挫折都是一次成长的机会。希望这篇文章能给大家带来启发，让我们一起努力，让Hadoop变得更加高效可靠吧！ --- 以上就是我对“HDFS读取速度慢”的全部看法和建议。如果你还有其他想法或者遇到类似的问题，请随时留言交流。咱们共同进步，一起探索大数据世界的奥秘！

...数据的大小和频率往往不可控。要是每次传来的数据都一点点的，那老是去处理这些小碎数据，就会多花不少功夫啦。Netty通过内置的缓冲区（Buffer）解决了这个问题。 例如，我们可以使用ByteBuf来存储和处理接收到的数据。ByteBuf就像是内存管理界的“万金油”，不仅能够灵活地伸缩大小，还能轻松应对各种编码需求，简直是程序员手里的瑞士军刀！ java // 创建一个ByteBuf实例 ByteBuf buffer = Unpooled.buffer(1024); buffer.writeBytes(data); // 处理数据 while (buffer.readableBytes() > 0) { byte b = buffer.readByte(); process(b); } 在这段代码中，我们首先创建了一个容量为1024字节的缓冲区，然后将接收到的数据写入其中。接着，我们通过循环逐个读取并处理缓冲区中的数据。这种方式不仅可以提高处理效率，还能更好地应对突发流量。 --- 四、总结与展望 好了，朋友们，今天的分享就到这里啦！通过上面的内容，相信大家对Netty的故障恢复机制有了更深的理解。不管是应对各种意外情况的异常处理，还是能让数据传输更高效的零拷贝技术，又或者是能重复利用长连接和设置数据缓冲这些招数，Netty可真是个实力派选手啊！ 不过，技术的世界永远没有尽头。Netty虽然已经足够优秀，但在某些特殊场景下仍可能存在局限性。未来的日子啊，我超级期待能看到更多的小伙伴，在Netty的基础上大展身手，把自己的系统捯饬得既聪明又靠谱，简直就像给它装了个“智慧大脑”一样！ 最后，我想说的是，技术的学习是一个不断探索的过程。希望大家能在实践中积累经验，在挑战中成长进步。如果你有任何疑问或者想法，欢迎随时留言交流哦！ 祝大家都能写出又快又稳的代码，一起迈向技术巅峰吧！😎

...ch会自动将其标记为不可用。 - 配置错误：比如分配给节点的资源不够，导致其无法启动。 对于我来说，问题出在第二个点上——磁盘空间不足。我当时为了省钱，给服务器分配的空间少得可怜，结果没多久就发现磁盘直接爆满，把自己都吓了一跳！于是ElasticSearch很生气，直接把该节点踢出了集群。 --- 3. 解决方案一 扩容磁盘空间 既然问题找到了，那就动手解决吧！首先，我决定先扩展磁盘容量。这一步其实很简单，只要登录服务器，增加磁盘大小就行。具体步骤如下： bash 查看当前磁盘状态 df -h 扩展磁盘（假设你已经购买了额外的存储） sudo growpart /dev/xvda 1 sudo resize2fs /dev/xvda1 完成后记得重启ElasticSearch服务： bash sudo systemctl restart elasticsearch 重启之后，神奇的事情发生了——我的节点重新上线了！不过这里有个小技巧分享给大家：如果你不确定扩容是否成功，可以通过以下命令检查磁盘使用情况： bash df -h 看到磁盘空间变大了，心里顿时舒坦了不少。 --- 4. 解决方案二 调整ElasticSearch配置 当然啦，仅仅扩容还不够，还需要优化ElasticSearch的配置文件。特别是那些容易导致内存不足或磁盘占用过高的参数，比如indices.memory.index_buffer_size和indices.store.throttle.max_bytes_per_sec。修改后的配置文件大概长这样： yaml cluster.routing.allocation.disk.threshold_enabled: true cluster.routing.allocation.disk.watermark.low: 85% cluster.routing.allocation.disk.watermark.high: 90% cluster.routing.allocation.disk.watermark.flood_stage: 95% cluster.info.update.interval: 30s 这些设置的意思是告诉ElasticSearch，当磁盘使用率达到85%时开始警告，达到90%时限制写入，超过95%时完全停止操作。这样可以有效避免再次出现类似的问题。 --- 5. 实战演练 代码中的应对策略 除了调整配置，我们还可以通过编写脚本来监控和处理NodeNotActiveException。比如，下面这段Java代码展示了如何捕获异常并记录日志： java import org.elasticsearch.client.RestHighLevelClient; import org.elasticsearch.client.RestClient; import org.elasticsearch.client.indices.CreateIndexRequest; import org.elasticsearch.client.indices.CreateIndexResponse; public class ElasticSearchExample { public static void main(String[] args) { RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("localhost", 9200, "http"))); try { CreateIndexRequest request = new CreateIndexRequest("test_index"); CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT); System.out.println("Index created: " + response.isAcknowledged()); } catch (Exception e) { if (e instanceof ClusterBlockException) { System.err.println("Cluster block detected: " + e.getMessage()); } else { System.err.println("Unexpected error: " + e.getMessage()); } } finally { try { client.close(); } catch (IOException ex) { System.err.println("Failed to close client: " + ex.getMessage()); } } } } 这段代码的作用是在创建索引时捕获可能发生的异常，并根据异常类型采取不同的处理方式。如果遇到ClusterBlockException，我们可以选择延迟重试或者其他补偿措施。 --- 6. 总结与反思 成长路上的一课 通过这次经历，我深刻体会到，作为一名开发者，不仅要掌握技术细节，还要学会从实际问题出发，找到最优解。NodeNotActiveException这个错误看着不起眼，但其实背后有不少门道呢！比如说，你的服务器硬件是不是有点吃不消了？集群那边有没有啥小毛病没及时发现？还有啊，咱们平时运维的时候是不是也有点松懈了？这些都是得好好琢磨的地方！ 最后，我想说的是，技术学习的过程就像爬山一样，有时候会遇到陡峭的山坡，但只要坚持下去，总能看到美丽的风景。希望这篇文章能给大家带来一些启发和帮助！如果还有其他疑问，欢迎随时交流哦~

...3.登录数据库，查看字符编码mysql -uroot -p输入 \s 查看编码 7. mysql常用命 desc 查看表结构create database 数据库名create table 表名查看如何创建db的show create database 库名 查看如何创建table结构的show create table 表名; 修改mysql的密码set password = PASSWORD('redhat'); 创建mysql的普通用户，默认权限非常低create user zhang@'%' identified by '123456'; 查询mysql数据库中的用户信息use mysql;select host,user,password from user; 7. 给用户添加权限命令 对所有库和所有表授权所有权限grant all privileges on . to 账户@主机名 给zhang用户授予所有权限grant all privileges on . to zhang@'%'; 刷新授权表flush privileges; 8. 给用户添加权限命令 给zhangsan用户授予所有权限grant all privileges on . to zhangsan@'%'; 给与root权限授予远程登录的命令 'centos这是密码随意设置grant all privileges on . to root@'%' identified by '123456'; 此时可以在windows登录linux的数据库 连接服务器的mysqlmysql -uyining -p -h 服务器的地址 9. 数据备份与恢复 导出当前数据库的所有db,到一个文件中1.mysqldump -u root -p --all-databases > /data/AllMysql.dump2.登录mysql 导入数据mysql -u root -p> source /data/AllMysql.dump3.通过命令导入数据 在登录时候，导入数据文件，一样可以写入数据mysql -uroot -p < /data/AllMysql.dump 10. 修改Mariadb存储路径 10.1 首先确定MariaDB数据库能正常运行，确定正常后关闭服务 systemctl stop mariadb 10.2 建立要更改数据存放的目录，如：我这单独分了一个区/data存放MariaDB的数据 mkdir /data/mysql_data chown -R mysql:mysql /data/mysql_data 10.3 复制默认数据存放文件夹到/data/mysql_data cp -a /var/lib/mysql /data/mysql_data 10.4 修改/etc/my.cnf.d/server.cnf vim /etc/my.cnf.d/server.cnf 在[mysqld]标签下添加如下内容 datadir=/data/mysql_data/mysqlsocket=/var/lib/mysql/mysql.sockdefault-character-set=utf8character_set_server=utf8slow_query_log=onslow_query_log_file=/data/mysql_data/slow_query_log.loglong_query_time=2 10.5 配置MariaDB慢查询 touch /data/mysql_data/slow_query_log.logchown mysql:mysql /data/mysql_data/slow_query_log.log 10.6 重启数据库 systemctl start mariadb 10.7 注意： 1、配置文件my.cnf存在，但是修改的并不是my.cnf，而是/etc/my.cnf.d/server.cnf； 2、并没有更改mysql.sock的路径配置； 3、没有修改/etc/init.d/mysql中的内容； 4、没有修改mysql_safe中的内容； 5、增加了数据库的慢查询配置。 11. Mariadb主从复制 11.1 主从库初始化 这条命令可以初始化mysql，删除匿名用户，设置root密码等等....mysql_secure_installation1.输入当前密码，初次安装后是没有密码的，直接回车2.询问是否使用 'unix_socket' 进行身份验证: n3.为 root 设置密码：y4.输入 root 的新密码: root5.确认输入 root 的新密码: root6.是否移除匿名用户，这个随意，建议删除： y7.拒绝用户远程登录，这个建议开启：n8.删除 test 库，可以保留：n9.重新加载权限表：y 11.2 修改主库配置 [root@mster mysql] grep -Ev "^$|^" /etc/my.cnf.d/server.cnf[server][mysqld]character-set-server=utf8collation-server=utf8_general_ciserver_id = 13 一组主从组里的每个id必须是唯一值。推荐用ip位数log-bin= mysql-bin 二进制日志，后面指定存放位置。如果只是指定名字，默认存放在/var/lib/mysql下lower_case_table_names=1 不区分大小写binlog-format=ROW 二进制日志文件格式log-slave-updates=True slave更新是否记入日志sync-master-info=1 值为1确保信息不会丢失slave-parallel-threads=3 同时启动多少个复制线程，最多与要复制的数据库数量相等即可binlog-checksum=CRC32 效验码master-verify-checksum=1 启动主服务器效验slave-sql-verify-checksum=1 启动从服务器效验[galera][embedded][mariadb][mariadb-10.6][root@mster-k8s mysql] 11.2 修改从库配置 [mysqld]character-set-server=utf8collation-server=utf8_general_ciserver_id=14log-bin= mysql-bin log-bin是二进制文件relay_log = relay-bin 中继日志, 后面指定存放位置。如果只是指定名字，默认存放在/var/lib/mysql下lower_case_table_names=1 11.3 重启主库和从库服务 systemctl restart mariad 11.4 master节点配置 MariaDB [huawei]> grant replication slave, replication client on . to 'liu'@'%' identified by '123456';Query OK, 0 rows affected (0.001 sec)MariaDB [huawei]> show master status;+------------------+----------+--------------+------------------+| File | Position | Binlog_Do_DB | Binlog_Ignore_DB |+------------------+----------+--------------+------------------+| mysql-bin.000001 | 4990 | | |+------------------+----------+--------------+------------------+1 row in set (0.000 sec)MariaDB [huawei]> select binlog_gtid_pos('mysql-bin.000001', 4990 );+-------------------------------------------+| binlog_gtid_pos('mysql-bin.000001', 4990) |+-------------------------------------------+| 0-13-80 |+-------------------------------------------+1 row in set (0.000 sec)MariaDB [huawei]> flush privileges; 11.5 slave节点配置 MariaDB [(none)]> set global gtid_slave_pos='0-13-80';Query OK, 0 rows affected (0.004 sec)MariaDB [(none)]> change master to master_host='101.34.141.216',master_user='liu',master_password='123456',master_use_gtid=slave_pos;Query OK, 0 rows affected (0.008 sec)MariaDB [(none)]> start slave;Query OK, 0 rows affected (0.005 sec)MariaDB [(none)]> 11.6 验证salve状态 MariaDB [(none)]> show slave status\G 1. row Slave_IO_State: Waiting for master to send eventMaster_Host: 101.34.141.216Master_User: liuMaster_Port: 3306Connect_Retry: 60Master_Log_File: mysql-bin.000001Read_Master_Log_Pos: 13260Relay_Log_File: relay-bin.000002Relay_Log_Pos: 10246Relay_Master_Log_File: mysql-bin.000001Slave_IO_Running: YesSlave_SQL_Running: YesReplicate_Do_DB: Replicate_Ignore_DB: Replicate_Do_Table: Replicate_Ignore_Table: Replicate_Wild_Do_Table: Replicate_Wild_Ignore_Table: Last_Errno: 0Last_Error: Skip_Counter: 0Exec_Master_Log_Pos: 13260Relay_Log_Space: 10549Until_Condition: NoneUntil_Log_File: Until_Log_Pos: 0Master_SSL_Allowed: NoMaster_SSL_CA_File: 本篇文章为转载内容。原文链接：https://blog.csdn.net/l363130002/article/details/126121255。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...有对应的响应式函数 不可能在全局维护一大堆的数组来保存这些响应函数 所以要设计一个类，这个类用于管理某一个对象的某一个属性的所有响应式函数： 相当于替代了原来的简单 reactiveFns 的数组； class Depend {constructor() {this.reactiveFns = []}addDepend(reactiveFn) {this.reactiveFns.push(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }const depend = new Depend()function watchFn(fn) {depend.addDepend(fn)}// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}watchFn(function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)})watchFn(function demo() {console.log(obj.name, 'demo function ---------')})function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe'depend.notify() 4.4 监听对象的变化 那么接下来就可以通过之前的方式来监听对象的变化： 方式一：通过 Object.defineProperty 的方式（vue2采用的方式）； 方式二：通过 new Proxy 的方式（vue3采用的方式）； 我们这里先以Proxy的方式来监听 class Depend {constructor() {this.reactiveFns = []}addDepend(reactiveFn) {this.reactiveFns.push(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }const depend = new Depend()function watchFn(fn) {depend.addDepend(fn)}// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)depend.notify()} })watchFn(function foo() {const newName = objProxy.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(objProxy.name)})watchFn(function demo() {console.log(objProxy.name, 'demo function ---------')})objProxy.name = 'kobe'objProxy.name = 'james'/ 你好啊，李银河Hello Worldkobekobe demo function ---------你好啊，李银河Hello Worldjamesjames demo function ---------/ 4.5 对象的依赖管理 目前是创建了一个 Depend 对象，用来管理对于 name 变化需要监听的响应函数： 但是实际开发中我们会有不同的对象，另外会有不同的属性需要管理； 如何可以使用一种数据结构来管理不同对象的不同依赖关系呢？ 在前面我们刚刚学习过 WeakMap，并且在学习 WeakMap 的时候我讲到了后面通过 WeakMap 如何管理这种响应式的数据依赖： 实现 可以写一个 getDepend 函数专门来管理这种依赖关系 / 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取mapconst map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象const depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} }) 正确的依赖收集 我们之前收集依赖的地方是在 watchFn 中： 但是这种收集依赖的方式我们根本不知道是哪一个 key 的哪一个 depend 需要收集依赖； 只能针对一个单独的 depend 对象来添加你的依赖对象； 那么正确的应该是在哪里收集呢？应该在我们调用了 Proxy 的 get 捕获器时 因为如果一个函数中使用了某个对象的 key，那么它应该被收集依赖 / 封装一个响应式函数 /let activeReactviceFn = nullfunction watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数activeReactviceFn && depend.addDepend(activeReactviceFn)return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} }) 4.6 对 Depend 重构 两个问题： 问题一：如果函数中有用到两次 key，比如 name，那么这个函数会被收集两次 问题二：我们并不希望将添加 reactiveFn 放到 get 中，因为它是属于 Depend 的行为 所以我们需要对 Depend 类进行重构： 解决问题一的方法：不使用数组，而是使用 Set 解决问题二的方法：添加一个新的方法，用于收集依赖 // 保存当前需要收集的响应式函数let activeReactviceFn = nullclass Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数depend.depend()return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} })watchFn(function () {console.log(objProxy.name, '--------------')console.log(objProxy.name, '++++++++++++++')})objProxy.name = 'kobe'/ why --------------why ++++++++++++++kobe --------------kobe ++++++++++++++/ 4.7 创建响应式对象 目前的响应式是针对于obj一个对象的，我们可以创建出来一个函数，针对所有的对象都可以变成响应式对象 / 保存当前需要收集的响应式函数 /let activeReactviceFn = null/ 依赖收集类 /class Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}/ 创建响应式对象函数 /function reactive(obj) {// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)return new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数depend.depend()return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} })}const info = reactive({address: '广州市',height: 1.88})watchFn(() => {console.log(info.address, '---')})info.address = '北京市' 4.8 Vue2 响应式原理 前面所实现的响应式的代码，其实就是 Vue3 中的响应式原理： Vue3 主要是通过 Proxy 来监听数据的变化以及收集相关的依赖的 Vue2 中通过 Object.defineProerty的方式来实现对象属性的监听 可以将 reactive 函数进行如下的重构： 在传入对象时，我们可以遍历所有的 key，并且通过属性存储描述符来监听属性的获取和修改 在 setter 和 getter 方法中的逻辑和前面的 Proxy 是一致的 / 保存当前需要收集的响应式函数 /let activeReactviceFn = null/ 依赖收集类 /class Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}/ 创建响应式对象函数 /function reactive(obj) {Object.keys(obj).forEach((key) => {let value = obj[key]Object.defineProperty(obj, key, {get: function () {const dep = getDepend(obj, key)dep.depend()return value},set: function (newValue) {value = newValueconst dep = getDepend(obj, key)dep.notify()} })})return obj}const info = reactive({address: '广州市',height: 1.88})watchFn(() => {console.log(info.address, '---')})info.address = '北京市' 本篇文章为转载内容。原文链接：https://blog.csdn.net/wanghuan1020/article/details/126774033。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...器），事情就开始变得不可控了。Ruby 的线程可不是完全分开的，这就有点像几个人共用一个记事本，大家都能随便写东西上去。结果就是，这本子可能一会儿被这个写点，一会儿被那个划掉，最后你都不知道上面到底写了啥，数据就乱套了。 代码示例： ruby 错误的代码 counter = 0 threads = [] 5.times do |i| threads << Thread.new do 100_000.times { counter += 1 } end end threads.each(&:join) puts "Counter: {counter}" 分析： 这段代码看起来没什么问题，每个线程都只是简单地增加计数器。但实际情况却是，输出的结果经常不是期望的500_000，而是各种奇怪的数字。这就好比说，counter += 1 其实不是一步到位的简单操作，它得先“读一下当前的值”，再“给这个值加1”，最后再“把新的值存回去”。问题是，在这中间的每一个小动作，都可能被别的线程突然插队过来捣乱！ 解决方案： 为了避免这种混乱，我们需要使用线程安全的操作，比如Mutex（互斥锁）。Mutex可以确保每次只有一个线程能够修改某个变量。 修正后的代码： ruby 正确的代码 require 'thread' counter = 0 mutex = Mutex.new threads = [] 5.times do |i| threads << Thread.new do 100_000.times do mutex.synchronize { counter += 1 } end end end threads.each(&:join) puts "Counter: {counter}" 总结： 这一段代码告诉我们，共享状态是一个雷区。如果你非要用共享变量，记得给它加上锁，不然后果不堪设想。 --- 4. 示例二 死锁的诅咒 场景描述： 有时候，我们会遇到更复杂的情况，比如两个线程互相等待对方释放资源。哎呀，这种情况就叫“死锁”，简直就像两只小猫抢一个玩具，谁都不肯让步，结果大家都卡在那里动弹不得，程序也就这样傻乎乎地停在原地，啥也干不了啦！ 问题出现： 想象一下，你有两个线程，A线程需要获取锁X，B线程需要获取锁Y。想象一下，A和B两个人都想打开两把锁——A拿到了锁X，B拿到了锁Y。然后呢，A心想：“我得等B先把他的锁Y打开，我才能继续。”而B也在想：“等A先把她的锁X打开，我才能接着弄。”结果俩人就这么干等着，谁也不肯先放手，最后就成了“死锁”——就像两个人在拔河，谁都不松手，僵在那里啥也干不成。 代码示例： ruby 死锁的代码 lock_a = Mutex.new lock_b = Mutex.new thread_a = Thread.new do lock_a.synchronize do puts "Thread A acquired lock A" sleep(1) lock_b.synchronize do puts "Thread A acquired lock B" end end end thread_b = Thread.new do lock_b.synchronize do puts "Thread B acquired lock B" sleep(1) lock_a.synchronize do puts "Thread B acquired lock A" end end end thread_a.join thread_b.join 分析： 在这段代码中，两个线程都在尝试获取两个不同的锁，但由于它们的顺序不同，最终导致了死锁。运行这段代码时，你会发现程序卡住了，没有任何输出。 解决方案： 为了避免死锁，我们需要遵循“总是按照相同的顺序获取锁”的原则。比如，在上面的例子中，我们可以强制让所有线程都先获取锁A，再获取锁B。 修正后的代码： ruby 避免死锁的代码 lock_a = Mutex.new lock_b = Mutex.new thread_a = Thread.new do [lock_a, lock_b].each do |lock| lock.synchronize do puts "Thread A acquired lock {lock.object_id}" end end end thread_b = Thread.new do [lock_a, lock_b].each do |lock| lock.synchronize do puts "Thread B acquired lock {lock.object_id}" end end end thread_a.join thread_b.join 总结： 死锁就像一只隐形的手，随时可能掐住你的喉咙。记住，保持一致的锁顺序是关键！ --- 5. 示例三 不恰当的线程池 场景描述： 线程池是一种管理线程的方式，它可以复用线程，减少频繁创建和销毁线程的开销。但在实际使用中，很多人会因为配置不当而导致性能下降甚至崩溃。 问题出现： 假设你创建了一个线程池，但线程池的大小设置得不合理。哎呀，这就好比做饭时锅不够大，菜都堆在那儿煮不熟，菜要是放太多呢，锅又会冒烟、潽得到处都是，最后饭也没做好。线程池也一样，太小了任务堆成山，程序半天没反应；太大了吧，电脑资源直接被榨干，啥事也干不成，还得收拾烂摊子！ 代码示例： ruby 线程池的错误用法 require 'thread' pool = Concurrent::FixedThreadPool.new(2) 20.times do |i| pool.post do sleep(1) puts "Task {i} completed" end end pool.shutdown pool.wait_for_termination 分析： 在这个例子中，线程池的大小被设置为2，但有20个任务需要执行。哎呀，这就好比你请了个帮手，但他一次只能干两件事，其他事儿就得排队等着，得等前面那两件事儿干完了，才能轮到下一件呢！这种情况下，整个程序的执行时间会显著延长。 解决方案： 为了优化线程池的性能，我们需要根据系统的负载情况动态调整线程池的大小。可以使用Concurrent::CachedThreadPool，它会根据当前的任务数量自动调整线程的数量。 修正后的代码： ruby 使用缓存线程池 require 'concurrent' pool = Concurrent::CachedThreadPool.new 20.times do |i| pool.post do sleep(1) puts "Task {i} completed" end end sleep(10) 给线程池足够的时间完成任务 pool.shutdown pool.wait_for_termination 总结： 线程池就像一把双刃剑，用得好可以提升效率，用不好则会成为负担。记住，线程池的大小要根据实际情况灵活调整。 --- 6. 示例四 忽略异常的代价 场景描述： 并发编程的一个常见问题是，线程中的异常不容易被察觉。如果你没有妥善处理这些异常，程序可能会因为一个小错误而崩溃。 问题出现： 假设你有一个线程在执行某个操作时抛出了异常，但你没有捕获它，那么整个线程池可能会因此停止工作。 代码示例： ruby 忽略异常的代码 threads = [] 5.times do |i| threads << Thread.new do raise "Error in thread {i}" if i == 2 puts "Thread {i} completed" end end threads.each(&:join) 分析： 在这个例子中，当i == 2时，线程会抛出一个异常。哎呀糟糕！因为我们没抓住这个异常，程序直接就挂掉了，别的线程啥的也别想再跑了。 解决方案： 为了防止这种情况发生，我们应该在每个线程中添加异常捕获机制。比如，可以用begin-rescue-end结构来捕获异常并进行处理。 修正后的代码： ruby 捕获异常的代码 threads = [] 5.times do |i| threads << Thread.new do begin raise "Error in thread {i}" if i == 2 puts "Thread {i} completed" rescue => e puts "Thread {i} encountered an error: {e.message}" end end end threads.each(&:join) 总结： 异常就像隐藏在暗处的敌人，稍不注意就会让你措手不及。学会捕获和处理异常，是成为一个优秀的并发编程者的关键。 --- 7. 结语 好了，今天的分享就到这里啦！并发编程确实是一项强大的技能，但也需要谨慎对待。大家看看今天这个例子，是不是觉得有点隐患啊？希望能引起大家的注意，也学着怎么避开这些坑，别踩雷了！ 最后，我想说的是，编程是一门艺术，也是一场冒险。每次遇到新挑战，我都觉得像打开一个神秘的盲盒，既兴奋又紧张。不过呢，光有好奇心还不够，还得有点儿耐心，就像种花一样，得一点点浇水施肥，不能急着看结果。相信只要我们不断学习、不断反思，就一定能写出更加优雅、高效的代码！ 祝大家编码愉快！

...渐成为自主导航系统中不可或缺的核心组件。在未来，我们期待看到更多创新性的研究成果和技术突破，进一步提升VIO在复杂环境下的适用性和可靠性。

...单明了，避免使用特殊字符或者空格。哎呀，这就好比你给文件夹起个特别绕口的名字，结果自己都记不住路径了，Kafka也是一样！它会根据主题的名字创建对应的文件夹结构，但要是主题名太复杂，搞不好就会在找东西的时候迷路，路径解析起来就容易出岔子啦。而且啊，主题的名字最好起得通俗易懂一点，让大伙儿一眼扫过去就明白这是干啥用的。 2.2 分区（Partition）：主题的分身术 接着说分区（Partition）。每个主题都可以被划分为多个分区，每个分区就是一个日志文件。分区的作用是什么呢？它可以提高并发性和扩展性。比如说，你有个主题叫orders（订单），你可以把它分成5个区（分区）。这样一来，不同的小伙伴就能一起开工，各自处理这些区里的数据啦！ java // 查看主题的分区信息 kafka-topics.sh --describe --zookeeper localhost:2181 --topic orders 分区的数量决定了并发的上限。所以，在设计主题时，你需要仔细权衡分区数量。太多的话，管理起来麻烦；太少的话，可能无法充分利用资源。我一般会根据预计的消息量来决定分区的数量。比如说，如果一秒能收到几千条消息，那分区设成10到20个就挺合适的。毕竟分区太多太少了都不好，得根据实际情况来调，不然可能会卡壳或者资源浪费啊！ 2.3 消费者组（Consumer Group）：团队协作的秘密武器 最后，我们来说消费者组（Consumer Group）。消费者组是一组消费者的集合，它们共同消费同一个主题的消息。每个消费者组都有一个唯一的名称，这个名字同样非常重要。 java // 创建一个消费者组 kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic user_events --group my_consumer_group 消费者组的设计理念是为了实现负载均衡和故障恢复。比如说，如果有两个小伙伴在一个小组里，系统就会帮他们自动分配任务（也就是主题的分区），这样大家就不会抢来抢去，重复干同样的活儿啦！而且呢，要是有个消费者挂掉了或者出问题了，其他的消费者就会顶上来，接手它负责的那些分区，接着干活儿，完全不受影响。 --- 3. 组织结构 Kafka的大脑与四肢 3.1 集群（Cluster）：Kafka的心脏 Kafka集群是由多个Broker组成的，Broker是Kafka的核心组件，负责存储和转发消息。一个Broker就是一个节点，多个Broker协同工作，形成一个分布式的系统。 java // 启动Kafka Broker nohup kafka-server-start.sh config/server.properties & Broker的数量决定了系统的容错能力和性能。其实啊，通常咱们都会建议弄三个Broker，为啥呢？就怕万一有个家伙“罢工”了，比如突然挂掉或者出问题，别的还能顶上，整个系统就不耽误干活啦！不过，Broker的数量也不能太多，否则会增加管理和维护的成本。 3.2 Zookeeper：Kafka的大脑 Zookeeper是Kafka的协调器，它负责管理集群的状态和配置。没有Zookeeper，Kafka就无法正常运作。比如说啊，新添了个Broker（也就是那个消息中转站），Zookeeper就会赶紧告诉其他Broker：“嘿，快看看这位新伙伴，更新一下你们的状态吧！”还有呢，要是某个分区的老大换了（Leader切换了），Zookeeper也会在一旁默默记好这笔账，生怕漏掉啥重要信息似的。 java // 启动Zookeeper nohup zookeeper-server-start.sh config/zookeeper.properties & 虽然Zookeeper很重要，但它也有一定的局限性。比如，它可能会成为单点故障，影响整个系统的稳定性。因此，近年来Kafka也在尝试去掉对Zookeeper的依赖，开发了自己的内部协调机制。 3.3 日志（Log）：Kafka的四肢 日志是Kafka存储消息的地方，每个分区对应一个日志文件。嘿，这个日志设计可太聪明了！它用的是顺序写入的方法，就像一条直线往前跑，根本不用左顾右盼，写起来那叫一个快，效率直接拉满！ java // 查看日志路径 cat config/server.properties | grep log.dirs 日志的大小可以通过参数log.segment.bytes来控制。默认值是1GB，你可以根据实际情况调整。要是日志文件太大了，查个东西就像在大海捞针一样慢吞吞的；但要是弄得太小吧，又老得换新的日志文件，麻烦得很，还费劲。 --- 4. 实战演练 从零搭建一个Kafka环境 说了这么多理论，咱们来实际操作一下吧！假设我们要搭建一个简单的Kafka环境，用来收集用户的登录日志。 4.1 安装Kafka和Zookeeper 首先，我们需要安装Kafka和Zookeeper。可以从官网下载最新的二进制包，解压后按照文档配置即可。 bash 下载Kafka wget https://downloads.apache.org/kafka/3.4.0/kafka_2.13-3.4.0.tgz 解压 tar -xzf kafka_2.13-3.4.0.tgz 4.2 创建主题和消费者 接下来，我们创建一个名为login_logs的主题，并启动一个消费者来监听消息。 bash 创建主题 bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 3 --topic login_logs 启动消费者 bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic login_logs --from-beginning 4.3 生产消息 最后，我们可以编写一个简单的Java程序来生产消息。 java import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; import java.util.Properties; public class KafkaProducerExample { public static void main(String[] args) { Properties props = new Properties(); props.put("bootstrap.servers", "localhost:9092"); props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); KafkaProducer producer = new KafkaProducer<>(props); for (int i = 0; i < 10; i++) { producer.send(new ProducerRecord<>("login_logs", "key" + i, "value" + i)); } producer.close(); } } 这段代码会向login_logs主题发送10条消息，每条消息都有一个唯一的键和值。 --- 5. 总结 Kafka的魅力在于细节 好了，到这里咱们的Kafka之旅就告一段落了。通过这篇文章，我希望大家能更好地理解Kafka的命名规范和组织结构。Kafka为啥这么牛？因为它在设计的时候真是把每个小细节都琢磨得特别透。就像给主题起名字吧，分个区啦，还有消费者组怎么配合干活儿，这些地方都能看出人家确实是下了一番功夫的，真不是随便凑合出来的！ 当然，Kafka的学习之路还有很多内容需要探索，比如监控、调优、安全等等。其实我觉得啊，只要你把命名的规矩弄明白了，东西该怎么放也心里有数了，那你就算是走上正轨啦，成功嘛，它就已经在向你招手啦！加油吧，朋友们！ --- 希望这篇文章对你有所帮助，如果有任何疑问，欢迎随时交流哦！

...这个数字，而且这个值不可以配置，不能修改，但是有理由相信512字节的区域是为了节约内存额外开销。按照这个值，1MB的内存只需要2KB的额外空间就能描述引用关系。这又带来另一个问题，就是512字节里面的内存可能被引用多次，所以这是一个粗略的关系描述，那么在使用的时候需要遍历这512字节。 再举一个例子，假设有两个对象B、C都在这512字节的区域内。为了方便处理，记录对象引用关系的时候，都使用对象的起始位置，然后用这个地址和512对齐，因此B和C对象的卡表指针都指向这一个卡表的位置。那么对于引用处理也有可有两种处理方法：·处理的时候会以堆分区为处理单位，遍历整个堆分区，在遍历的时候，每次都会以对象大小为步长，结合卡表，如果该卡表中对应的位置被设置，则说明对象和其他分区的对象发生了引用。具体内容在后文中介绍Refine的时候还会详细介绍。·处理的时候借助于额外的数据结构，找到真正对象的位置，而不需要从头开始遍历。在后文的并发标记处理时就使用了这种方法，用于找到第一个对象的起始位置。在G1除了512字节粒度的卡表之外，还有bitMap，例如使用bitMap可以描述一个分区对另外一个分区的引用情况。在JVM中bitMap使用非常多，例如还可以描述内存的分配情况。 在G1除了512字节粒度的卡表之外，还有bitMap，例如使用bitMap可以描述一个分区对另外一个分区的引用情况。在JVM中bitMap使用非常多，例如还可以描述内存的分配情况。G1在混合收集算法中用到了并发标记。在并发标记的时候使用了bitMap来描述对象的分配情况。例如1MB的分区可以用16KB（16KB×ObjectAlignmentInBytes×8=1MB）来描述，即16KB额外的空间。其中ObjectAlignmentInBytes是8字节，指的是对象对齐，第二个8是指一个字节有8位。即每一个位可以描述64位。例如一个对象长度对齐之后为24字节，理论上它占用3个位来描述这个24字节已被使用了，实际上并不需要，在标记的时候只需要标记这3个位中的第一个位，再结合堆分区对象的大小信息就能准确找出。其最主要的目的是为了效率，标记一个位和标记3个位相比能节约不少时间，如果对象很大，则更划算。这些都是源码的实现细节，大家在阅读源码时需要细细斟酌。 本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_16500963/article/details/132133125。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

... 允许值 允许的特殊字符 秒 0-59 , - / 分 0-59 , - / 小时 0-23 , - / 日期 1-31 , - ? / L W C 月份 1-12 或者 JAN-DEC , - / 星期 1-7 或者 SUN-SAT , - ? / L C 年（可选） 留空, 1970-2099 , - / - 区间 通配符 ? 你不想设置那个字段 下面只例出几个式子 CRON表达式 含义 "0 0 12 ?" 每天中午十二点触发 "0 15 10 ? " 每天早上10：15触发 "0 15 10 ?" 每天早上10：15触发 "0 15 10 ? " 每天早上10：15触发 "0 15 10 ? 2005" 2005年的每天早上10：15触发 "0 14 ?" 每天从下午2点开始到2点59分每分钟一次触发 "0 0/5 14 ?" 每天从下午2点开始到2：55分结束每5分钟一次触发 "0 0/5 14,18 ?" 每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发 "0 0-5 14 ?" 每天14:00至14:05每分钟一次触发 "0 10,44 14 ? 3 WED" 三月的每周三的14：10和14：44触发 "0 15 10 ? MON-FRI" 每个周一、周二、周三、周四、周五的10：15触发 Cron 表达式包括以下 7 个字段： 秒 分 小时 月内日期 月 周内日期 年（可选字段） 特殊字符 Cron 触发器利用一系列特殊字符，如下所示： 反斜线（/）字符表示增量值。例如，在秒字段中“5/15”代表从第 5 秒开始，每 15 秒一次。 问号（?）字符和字母 L 字符只有在月内日期和周内日期字段中可用。问号表示这个字段不包含具体值。所以，如果指定月内日期，可以在周内日期字段中插入“?”，表示周内日期值无关紧要。字母 L 字符是 last 的缩写。放在月内日期字段中，表示安排在当月最后一天执行。在周内日期字段中，如果“L”单独存在，就等于“7”，否则代表当月内周内日期的最后一个实例。所以“0L”表示安排在当月的最后一个星期日执行。 在月内日期字段中的字母（W）字符把执行安排在最靠近指定值的工作日。把“1W”放在月内日期字段中，表示把执行安排在当月的第一个工作日内。 井号（）字符为给定月份指定具体的工作日实例。把“MON2”放在周内日期字段中，表示把任务安排在当月的第二个星期一。 星号（）字符是通配字符，表示该字段可以接受任何可能的值。 字段 允许值 允许的特殊字符 秒 0-59 , - / 分 0-59 , - / 小时 0-23 , - / 日期 1-31 , - ? / L W C 月份 1-12 或者 JAN-DEC , - / 星期 1-7 或者 SUN-SAT , - ? / L C 年（可选） 留空, 1970-2099 , - / 表达式意义 "0 0 12 ?" 每天中午12点触发 "0 15 10 ? " 每天上午10:15触发 "0 15 10 ?" 每天上午10:15触发 "0 15 10 ? " 每天上午10:15触发 "0 15 10 ? 2005" 2005年的每天上午10:15触发 "0 14 ?" 在每天下午2点到下午2:59期间的每1分钟触发 "0 0/5 14 ?" 在每天下午2点到下午2:55期间的每5分钟触发 "0 0/5 14,18 ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发 "0 0-5 14 ?" 在每天下午2点到下午2:05期间的每1分钟触发 "0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发 "0 15 10 ? MON-FRI" 周一至周五的上午10:15触发 "0 15 10 15 ?" 每月15日上午10:15触发 "0 15 10 L ?" 每月最后一日的上午10:15触发 "0 15 10 ? 6L" 每月的最后一个星期五上午10:15触发 "0 15 10 ? 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发 "0 15 10 ? 63" 每月的第三个星期五上午10:15触发 每天早上6点 0 6 每两个小时 0 /2 晚上11点到早上8点之间每两个小时，早上八点 0 23-7/2，8 每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点 0 11 4 1-3 1月1日早上4点 0 4 1 1 本篇文章为转载内容。原文链接：https://zhanghaiyang.blog.csdn.net/article/details/51397459。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...ing框架等领域有着不可或缺的地位。例如，Spring通过注解驱动的编程模型（Annotation-based programming model），开发者可以便捷地实现依赖注入、事务管理等功能。 近期，随着JDK17的发布，Java社区对注解的关注度进一步提升。在新版本中，尽管注解的基本使用方式没有变化，但对模块化系统（JPMS）的支持使得注解在模块间的交互和权限控制上有了新的应用场景。同时，社区也在探索更高效的注解处理机制，以减少反射带来的性能开销，例如Project Lombok项目就尝试通过注解处理器自动生成代码，从而避免运行时反射。 此外，Google在今年初宣布了Jetpack Compose的稳定版，这是一种声明式UI构建工具，同样大量运用了注解技术来简化界面组件的创建与维护。这意味着注解在Android领域的应用将进一步深化，帮助开发者提高生产力并优化代码结构。 综上所述，无论是在传统的Java SE领域还是在新兴的Android开发中，注解的重要性都在不断提升，并且随着技术的发展，注解的应用场景将会更加丰富多元，成为现代编程语言不可忽视的关键特性之一。对于开发者来说，持续关注注解相关的最新研究进展和技术实践，将有助于提高自身编码效率和程序设计质量。