[MongoDB命令行工具进行性能测试 ]的搜索结果

...我们，我们将第一时间进行核实并删除相应内容。 Java的特点：1、面向对象；它对对象中的类、对象、继承、封装、多态、接口、包等均有很好支持。2、平台无关性；在引入虚拟机之后，Java语言在不同的平台上运行不需要重新编译。3、简单性。4、解释执行；程序在Java平台运行时会被编译成字节码文件，然后可以在有Java环境的操作系统上运行。5、支持多线程，并提供多线程之间的同步机制；6、分布式；7、健壮性；8、高性能；9、安全性。 什么是Java语言 简单地说，Java 是由 Sun Microsystems 公司于 1995 年推出的一门面向对象程序设计语言。2010 年 Oracle 公司收购 Sun Microsystems，之后由 Oracle 公司负责 Java 的维护和版本升级。 其实，Java 还是一个平台。Java 平台由 Java 虚拟机（Java Virtual Machine，JVM）和 Java 应用编程接口（Application Programming Interface，API）构成。Java 应用编程接口为此提供了一个独立于操作系统的标准接口，可分为基本部分和扩展部分。在硬件或操作系统平台上安装一个 Java 平台之后，Java 应用程序就可运行。 Java 平台已经嵌入了几乎所有的操作系统。这样 Java 程序只编译一次，就可以在各种系统中运行。Java 应用编程接口已经从 1.1x 版本发展到 1.2 版本。 Java语言的特点 Java 语言的风格很像 C 语言和 C++ 语言，是一种纯粹的面向对象语言，它继承了 C++ 语言面向对象的技术核心，但是拋弃了 C++ 的一些缺点，比如说容易引起错误的指针以及多继承等，同时也增加了垃圾回收机制，释放掉不被使用的内存空间，解决了管理内存空间的烦恼。 Java 语言是一种分布式的面向对象语言，具有面向对象、平台无关性、简单性、解释执行、多线程、安全性等很多特点，下面针对这些特点进行逐一介绍。 1. 面向对象 Java 是一种面向对象的语言，它对对象中的类、对象、继承、封装、多态、接口、包等均有很好的支持。为了简单起见，Java 只支持类之间的单继承，但是可以使用接口来实现多继承。使用 Java 语言开发程序，需要采用面向对象的思想设计程序和编写代码。 2. 平台无关性 平台无关性的具体表现在于，Java 是“一次编写，到处运行（Write Once，Run any Where）”的语言，因此采用 Java 语言编写的程序具有很好的可移植性，而保证这一点的正是 Java 的虚拟机机制。在引入虚拟机之后，Java 语言在不同的平台上运行不需要重新编译。 Java 语言使用 Java 虚拟机机制屏蔽了具体平台的相关信息，使得 Java 语言编译的程序只需生成虚拟机上的目标代码，就可以在多种平台上不加修改地运行。 3. 简单性 Java 语言的语法与 C 语言和 C++ 语言很相近，使得很多程序员学起来很容易。对 Java 来说，它舍弃了很多 C++ 中难以理解的特性，如操作符的重载和多继承等，而且 Java 语言不使用指针，加入了垃圾回收机制，解决了程序员需要管理内存的问题，使编程变得更加简单。 4. 解释执行 Java 程序在 Java 平台运行时会被编译成字节码文件，然后可以在有 Java 环境的操作系统上运行。在运行文件时，Java 的解释器对这些字节码进行解释执行，执行过程中需要加入的类在连接阶段被载入到运行环境中。 5. 多线程 Java 语言是多线程的，这也是 Java 语言的一大特性，它必须由 Thread 类和它的子类来创建。Java 支持多个线程同时执行，并提供多线程之间的同步机制。任何一个线程都有自己的 run() 方法，要执行的方法就写在 run() 方法体内。 6. 分布式 Java 语言支持 Internet 应用的开发，在 Java 的基本应用编程接口中就有一个网络应用编程接口，它提供了网络应用编程的类库，包括 URL、URLConnection、Socket 等。Java 的 RIM 机制也是开发分布式应用的重要手段。 7. 健壮性 Java 的强类型机制、异常处理、垃圾回收机制等都是 Java 健壮性的重要保证。对指针的丢弃是 Java 的一大进步。另外，Java 的异常机制也是健壮性的一大体现。 8. 高性能 Java 的高性能主要是相对其他高级脚本语言来说的，随着 JIT（Just in Time）的发展，Java 的运行速度也越来越高。 9. 安全性 Java 通常被用在网络环境中，为此，Java 提供了一个安全机制以防止恶意代码的攻击。除了 Java 语言具有许多的安全特性以外，Java 还对通过网络下载的类增加一个安全防范机制，分配不同的名字空间以防替代本地的同名类，并包含安全管理机制。 Java 语言的众多特性使其在众多的编程语言中占有较大的市场份额，Java 语言对对象的支持和强大的 API 使得编程工作变得更加容易和快捷，大大降低了程序的开发成本。Java 的“一次编写，到处执行”正是它吸引众多商家和编程人员的一大优势。 扩展知识： 按应用范围，Java 可分为 3 个体系，即 Java SE、Java EE 和 Java ME。下面简单介绍这 3 个体系。 1. Java SE Java SE（Java Platform Standard Edition，Java 平台标准版）以前称为 J2SE，它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE 包含了支持 Java Web 服务开发的类，并为 Java EE 提供基础，如 Java 语言基础、JDBC 操作、I/O 操作、网络通信以及多线程等技术。图 1 所示为 Java SE 的体系结构。 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_73892801/article/details/129181633。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...我们，我们将第一时间进行核实并删除相应内容。 All the charts, single package It’s easy with amCharts 5 – all chart types come in a single, easy to understand package! No need to figure out product line up – just get amCharts 5 for everything. And since it was designed to work with modern web dev toolkits like React, Angular, Vue it will just fall into place, right out of the box. X/Y Line & Smoothed line Area Column & Bar Scatter & Bubble Candlestick & OHLC Step (incl. w/ no-riser) Floating & Gantt Waterfall Error Stacked (regular or 100%) Heatmap … and any combination of the above Percent Pie & Donut Nested donut Funnel Pyramid Pictorial Geo maps Map chart Geo heat map Map combined with charts Maps is an add-on and requires separate license. Other Sankey diagram Chord, Chord directed, and Chord non-ribbon diagrams Pack Treemap Tree Sunburst Partition Force-directed tree Radar & Polar Word cloud Venn diagram Efficiency built-in Canvas rendering amCharts 5 uses browser’s Canvas API which in most cases is way faster than SVG. Less moving parts in the DOM tree, faster rendering. Layering Common element groups are isolated into separate independent canvases, so that heavily updated sections do not trigger expensive repaints in places that do not change. Fast data processing Data processing in amCharts 5 is designed to be as efficient as possible. Incremental updates, lack of repetitive aggregations, and lightweight data object use makes data processing fast and very memory-efficient. Faster dashboards amCharts 5 is capable of running scores of charts on the same page, without crippling the browser, due to its lightweight approach to data parsing and rendering. Tiny binaries We made amCharts 5 really small – the core functionality compiles to a file of only around 400KB. Each niche functionality is separated into files, so you load only what you really need. Users will surely appreciate faster load times. Better tree-shaking We also designed amCharts 5 to be extremely tree-shakable. If you are using Webpack or similar packager, only code that is really needed will be included into your final application. The most advanced chart package Classics with some new twists XY charts are now so powerful and flexible, you can plot any data on them. Number, date, duration, or category axes are supported, in all directions. Pie charts are now fully nestable, with support for custom start and end angles, to create half circles. New geo maps Our maps use GeoJSON format. Being open and widely accepted standard it opens up a lot of possibilities and sources for ready-made and custom maps. Furthermore, maps are now very flexible, with multi-series support, configurable down to the nut and bolt. (Maps is and add-on to amCharts 5: Charts which requires separate license) More about amCharts 5: Maps Pictorials Create multi-layer, multi-series pictorial charts. Any SVG path can be used as a shape for your chart. Sankey Diagrams Stunning flow diagrams, in horizontal and vertical. With draggable, fully configurable nodes. Enhanced radar charts With stacked column, bands, axes, and other dramatic enhancements, radar charts are now way more useful. Treemaps Completely zoomable, multi-level, highly configurable. Heatmaps Automatically build heat-maps, with custom axes, color ranges, and awesome new interactive Heat Legend. Create heatmaps using colors, or point size or both. Universal and flexible heat rules allow attaching any value in data to any property or properties on any element. Chord diagrams Visualize your 2-way relational data in a neat circular Chord diagrams. We do have different variations of the classic diagram: Chord, Chord directed, and Chord non-ribbon. True funnel charts amCharts 5 offers true Funnel charts the way they were meant to be. Slice’s area size represents the value, so each step’s influence on overall volume reduction is more prominent than with basic funnels. Trapezoid form can also be configured to further emphasize reduction. Complete it with other visual elements, like fully configurable slice lines, multiple series support, togglable legends, and many many more options. Customizable beauty built-in Powerful theme engine amCharts 5 comes with a bunch of beautiful themes as well as a super flexible theme engine, which you can use. We devised a CSS-like rule-based theme targeting system in themes. Using, creating, customizing themes or standalone rules has never been so easy. The new system allows applying defaults to elements based on their type, features, or position in a virtual element tree. Fresh new look Default looks designed to look fresh, like something out of tomorrow. Carefully selected color schemes and default settings were specifically chosen to make the charts stand out. Silk-smooth animations Every setting – colors, positions, sizes, opacity, and many more – is animatable to ensure smooth transitions. No choppy, stepped animations – everything is fluid, including zoom and toggling of series and other items. Flexibility Element templates Most elements are created using templates: a collection of default settings, events, and adapters. Changing template automatically propagates changes to actual elements, making it easy to do batch updates. Everything’s configurable Numerous configuration options allow inventive uses, bordering on new chart types. Angles, colors, positions, radii, a-n-y-t-h-i-n-g can be set to bend classic and new chart types exactly the way you need them. Element states Easily change how an element looks like under different circumstances, e.g. on some interaction, hover, click, or related to data (eg. column look if a value is down). The engine will automatically apply the required properties as needed, animating between old and new values smoothly. Create and apply custom states via the API. Multi-type multi-axis support Add any number of axes of any type. Create overlaid comparison of different time scales. Use any mix of dimensional values: numbers, dates, categories, or duration. Adapters “Adapters” functionality allows plugging in custom code to dynamically override just about any setting or data value. Text formatting All text labels – tooltips, axis labels, titles, etc. – now support rich text formatting options, like changing colors, font weight, or applying just about any styling option from the CSS arsenal. In addition to formatting support, labels can now contain in-line placeholders for real data, with the ability to apply custom formatting to values. Accessibility & Interactivity Accessibility Accessibility was riding shotgun when amCharts 5 was being developed. All interactive elements are TAB-selectable, with customizable roles, order, and screen-reader texts. Everything that can be moved by touch or mouse, can be moved by keyboard. Everything that can be clicked or toggled, can be interacted with with keyboard, too. Touch support Charts have been designed to work with touch devices out-of-the-box. They will work not only on phones or tablets, but also touch capable computers. Under the hood Built with TypeScript Supports strong type and error checking in TypeScript applications. Enjoy code completion, error checking and dynamic help popups in major IDEs. Full support for TypeScript and ES6 modules. 100% for JavaScript Can be fully used in any vanilla JavaScript application. amCharts 5 does not use or rely on globals, external frameworks or 3rd party libraries. Universal rendering engine Can be used to build dynamic, interactive Canvas-based interfaces and applications. Add various elements to the screen, make them interactive, with a few lines of code. Make them clickable, draggable, hoverable, using built-in interactivity functionality. Our universal layout engine will place, size and arrange elements according to set rules. 本篇文章为转载内容。原文链接：https://blog.csdn.net/john_dwh/article/details/127460821。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...技术，对HTML标签进行抽象封装，以提高应用性能并简化编程模型。这些框架自带的组件库也提供了丰富的预设标签，比如Vue中的用于声明式导航，极大地扩展了HTML标签的功能边界。 为了紧跟行业发展，前端开发者需要持续关注HTML最新特性的发展动态，如最近被提出讨论的标签，旨在提供原生的模态对话框支持；而对的安全性和性能优化也是业界热议的话题。只有不断跟进新技术，才能更好地运用HTML标签服务于用户需求，并在实践中提升自己的技术水平。

...我们，我们将第一时间进行核实并删除相应内容。 概述 分布式文件系统 适合：一次写入，多次读出，且不支持修改 文件块大小 128M HDFS的shell操作（重点） 基本语法 hadoop fs 具体命令或者hdfs dfs 具体命名 命令大全 Usage: hadoop fs [generic options][-appendToFile <localsrc> ... <dst>] 追加[-cat [-ignoreCrc] <src> ...] 查看[-checksum <src> ...][-chgrp [-R] GROUP PATH...] 改组[-chmod [-R] <MODE[,MODE]... | OCTALMODE> PATH...] 改权限[-chown [-R] [OWNER][:[GROUP]] PATH...] 改所有者[-copyFromLocal [-f] [-p] [-l] [-d] [-t <thread count>] <localsrc> ... <dst>] 上传[-copyToLocal [-f] [-p] [-ignoreCrc] [-crc] <src> ... <localdst>] 下载[-count [-q] [-h] [-v] [-t [<storage type>]] [-u] [-x] [-e] <path> ...][-cp [-f] [-p | -p[topax]] [-d] <src> ... <dst>] 复制[-createSnapshot <snapshotDir> [<snapshotName>]][-deleteSnapshot <snapshotDir> <snapshotName>][-df [-h] [<path> ...]][-du [-s] [-h] [-v] [-x] <path> ...] 统计磁盘文件大小[-expunge][-find <path> ... <expression> ...][-get [-f] [-p] [-ignoreCrc] [-crc] <src> ... <localdst>] 下载[-getfacl [-R] <path>][-getfattr [-R] {-n name | -d} [-e en] <path>][-getmerge [-nl] [-skip-empty-file] <src> <localdst>][-head <file>][-help [cmd ...]][-ls [-C] [-d] [-h] [-q] [-R] [-t] [-S] [-r] [-u] [-e] [<path> ...]] 查看列表[-mkdir [-p] <path> ...] 创建[-moveFromLocal <localsrc> ... <dst>] 剪切到hdfs[-moveToLocal <src> <localdst>] 剪切到本地[-mv <src> ... <dst>] 移动[-put [-f] [-p] [-l] [-d] <localsrc> ... <dst>] 上传[-renameSnapshot <snapshotDir> <oldName> <newName>][-rm [-f] [-r|-R] [-skipTrash] [-safely] <src> ...] 删除[-rmdir [--ignore-fail-on-non-empty] <dir> ...][-setfacl [-R] [{-b|-k} {-m|-x <acl_spec>} <path>]|[--set <acl_spec> <path>]][-setfattr {-n name [-v value] | -x name} <path>][-setrep [-R] [-w] <rep> <path> ...] 设置副本数[-stat [format] <path> ...][-tail [-f] <file>][-test -[defsz] <path>][-text [-ignoreCrc] <src> ...][-touch [-a] [-m] [-t TIMESTAMP ] [-c] <path> ...][-touchz <path> ...][-truncate [-w] <length> <path> ...][-usage [cmd ...]]Generic options supported are:-conf <configuration file> specify an application configuration file-D <property=value> define a value for a given property-fs <file:///|hdfs://namenode:port> specify default filesystem URL to use, overrides 'fs.defaultFS' property from configurations.-jt <local|resourcemanager:port> specify a ResourceManager-files <file1,...> specify a comma-separated list of files to be copied to the map reduce cluster-libjars <jar1,...> specify a comma-separated list of jar files to be included in the classpath-archives <archive1,...> specify a comma-separated list of archives to be unarchived on the compute machinesThe general command line syntax is:command [genericOptions] [commandOptions] 查看详细命令 hadoop fs -help 命令（如cat） 更改hdfs的权限 vi core-site.xml <property><name>hadoop.http.staticuser.user</name><value>root</value></property> HDFS客户端API操作 Windows环境配置 将Windows依赖放到文件夹， 配置环境变量，添加HADOOP_HOME ，编辑Path添加%HADOOP_HOME%/bin 拷贝hadoop.dll和winutils.exe到C:\Windows\System32 创建java项目 配置 编辑pom.xml <dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-slf4j-impl</artifactId><version>2.12.0</version></dependency><dependency><groupId>org.apache.hadoop</groupId><artifactId>hadoop-client</artifactId><version>3.1.3</version></dependency></dependencies> 在src/main/resources中建立log4j2.xml 打印日志到控制台 <?xml version="1.0" encoding="UTF-8"?><Configuration status="WARN"><Appenders><Console name="Console" target="SYSTEM_OUT"><PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/></Console></Appenders><Loggers><Root level="error"><AppenderRef ref="Console"/></Root></Loggers></Configuration> 编写代码 在/src/main/java/cn.zcx.hdfs创建TestHDFS类 public class TestHDFS {// 创建全局变量private FileSystem fs;private Configuration conf;private URI uri;private String user;// 从本地上传文件@Testpublic void testUpload() throws IOException {fs.copyFromLocalFile(false,true,new Path("F:\\Download\\使用前说明.txt"),new Path("/testhdfs"));}/ @Before 方法在@Test方法执行之前执行 /@Beforepublic void init() throws IOException, InterruptedException {uri = URI.create("hdfs://master:8020");conf = new Configuration();user = "root";fs = FileSystem.get(uri,conf,user);}/ @After方法在@Test方法结束后执行 /@Afterpublic void close() throws IOException {fs.close();}@Testpublic void testHDFS() throws IOException, InterruptedException {//1. 创建文件系统对象/URI uri = URI.create("hdfs://master:8020");Configuration conf = new Configuration();String user = "root";FileSystem fs = FileSystem.get(uri,conf,user);System.out.println("fs: " + fs);/// 2. 创建一个目录boolean b = fs.mkdirs(new Path("/testhdfs"));System.out.println(b);// 3. 关闭fs.close();} } 参数优先级 xxx-default.xml < xxx-site.xml < IDEA中resource中创建xxx-site.xml < 在代码中通过更改Configuration 参数 文件下载 @Testpublic void testDownload() throws IOException {fs.copyToLocalFile(false,new Path("/testhdfs/使用前说明.txt"),new Path("F:\\Download\\"),true);} 文件更改移动 //改名or移动（路径改变就可以）@Testpublic void testRename() throws IOException {boolean b = fs.rename(new Path("/testhdfs/使用前说明.txt"),new Path("/testhdfs/zcx.txt"));System.out.println(b);} 查看文件详细信息 // 查看文件详情@Testpublic void testListFiles() throws IOException {RemoteIterator<LocatedFileStatus> listFiles = fs.listFiles(new Path("/"), true);//迭代操作while (listFiles.hasNext()){LocatedFileStatus fileStatus = listFiles.next();//获取文件详情System.out.println("文件路径："+fileStatus.getPath());System.out.println("文件权限："+fileStatus.getPermission());System.out.println("文件主人："+fileStatus.getOwner());System.out.println("文件组："+fileStatus.getGroup());System.out.println("文件大小："+fileStatus.getLen());System.out.println("文件副本数："+fileStatus.getReplication());System.out.println("文件块位置："+ Arrays.toString(fileStatus.getBlockLocations()));System.out.println("===============================");} } 文件删除 第二参数，true递归删除 //文件删除@Testpublic void testDelete() throws IOException {boolean b = fs.delete(new Path("/testhdfs/"), true);System.out.println(b);} NN与2NN工作原理 本篇文章为转载内容。原文链接：https://blog.csdn.net/Python1One/article/details/108546050。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...的神奇世界 在构建高性能的Web应用时，缓存是不可或缺的一部分。它能够显著提升系统响应速度，减轻数据库负担，从而提高整体性能。MemCache作为一款流行的分布式内存对象缓存系统，以其高效性和灵活性赢得了广大开发者的青睐。哎呀，用着用着，咱们可能会碰到一些意料之外的小麻烦，比如说MutexException。这事儿可不简单，它通常说明在咱们同时操作好几个线程的时候，遇到了锁的冲突，或者是怎么也拿不到那个关键的锁。就像是在厨房里，好几个人都想同时用同一把刀切菜，结果就乱了套，谁都得等着。这可得小心点，不然程序就可能卡住不动了。这篇文章将带你深入理解MemCache的工作原理，并探讨如何解决此类问题。 2. MemCache基础概念 MemCache通过在内存中存储数据来提供快速访问。哎呀，这个家伙可真能玩转各种数据类型啊！不管是那些字母串、一长串的数字清单，还是乱七八糟的集合，它都能轻松驾驭。而且，它还提供了一套超简单的操作工具，就像给小孩子们准备的玩具一样，简单易懂，轻轻松松就能搞定这些数据，真是太贴心了！MemCache这种玩意儿啊，就像是你跟朋友玩游戏，你负责喊口号出招，朋友负责听你的指挥去打怪兽或者抢金币。这游戏里头，MemCache的服务器就是那个强大的后盾，它负责把所有东西都记下来，还有找你要的东西。所以，简单来说，你就是客户端，是操作者；MemCache服务器呢，就是那个后台，负责处理一切数据的事情。这样子，你们俩配合起来，游戏玩得又快又好！ 3. MutexException问题剖析 当多个线程同时尝试访问或修改同一数据时，MutexException的出现往往是因为互斥锁管理不当。哎呀，互斥锁就像是共享空间的门神，它负责在任何时候只让一个小伙伴进入这个共享区域，比如图书馆或者厨房，这样大家就不会抢着用同一本书或者同一把锅啦。这样就能避免发生混乱和冲突，保证大家都能平平安安地享受公共资源。在MemCache中，这种冲突可能发生在读取、写入或删除数据的操作上。 4. 实战案例 MemCache使用示例 为了更好地理解MemCache的工作流程及其可能出现的问题，我们通过一个简单的示例来展示其基本用法： python from pymemcache.client import base 创建MemCache客户端连接 client = base.Client(('localhost', 11211)) 缓存一个值 client.set('key', 'value') 从缓存中获取值 print(client.get('key')) 删除缓存中的值 client.delete('key') 5. 避免MutexException的策略 解决MutexException的关键在于正确管理互斥锁。以下是一些实用的策略： a. 使用原子操作 MemCache提供了原子操作，如add、replace、increment等，可以安全地执行更新操作而无需额外的锁保护。 b. 线程安全编程 确保所有涉及到共享资源的操作都是线程安全的。这意味着避免在多线程环境中直接访问全局变量或共享资源，而是使用线程本地存储或其他线程安全的替代方案。 c. 锁优化 合理使用锁。哎呀，你懂的，有时候网站或者应用里头有些东西经常被大家看，但是实际上内容变动不多。这时候，为了不让系统在处理这些信息的时候卡壳太久，我们可以用个叫做“读锁”的小技巧。简单来说，读锁就像是图书馆里的书，大家都想翻阅，但是不打算乱动它，所以不需要特别紧锁起来，这样能提高大家看书的效率，也避免了不必要的等待。此外，考虑使用更高效的锁实现，比如使用更细粒度的锁或非阻塞算法。 d. 锁超时 在获取锁时设置超时时间，避免无限等待。哎呀，如果咱们在规定的时间内没拿到钥匙（这里的“锁”就是需要获得的权限或资源），那咱们就得想点别的办法了。比如说，咱们可以先把手头的事情放一放，退一步海阔天空嘛，回头再试试；或者干脆来个“再来一次”，看看运气是不是转了一把。别急，总有办法解决问题的！ 6. 结语 MemCache的未来与挑战 随着技术的发展，MemCache面临着更多的挑战，包括更高的并发处理能力、更好的跨数据中心一致性以及对新兴数据类型的支持。然而，通过持续优化互斥锁管理策略，我们可以有效地避免MutexException等并发相关问题，让MemCache在高性能缓存系统中发挥更大的作用。嘿，小伙伴们！在咱们的编程路上，要记得跟紧时代步伐，多看看那些最棒的做法和新出炉的技术。这样，咱们就能打造出既稳固又高效的超级应用了！别忘了，技术这玩意儿，就像个不停奔跑的小兔子，咱们得时刻准备着，跟上它的节奏，不然可就要被甩在后面啦！所以，多学习，多实践，咱们的编程技能才能芝麻开花节节高！

...我们，我们将第一时间进行核实并删除相应内容。 很久都没写 Flask 代码相关了，想想也真是惭愧，然并卵，这次还是不写 Flask 相关，不服你来打我啊(就这么贱，有本事咬我啊 这次我来写一下 Python 一个很重要的东西，即 Descriptor (描述符) 初识描述符 老规矩， Talk is cheap,Show me the code. 我们先来看看一段代码classPerson(object): """""" ---------------------------------------------------------------------- def__init__(self, first_name, last_name): """Constructor""" self.first_name = first_name self.last_name = last_name ---------------------------------------------------------------------- @property deffull_name(self): """ Return the full name """ return"%s %s"% (self.first_name, self.last_name) if__name__=="__main__": person = Person("Mike","Driscoll") print(person.full_name) 'Mike Driscoll' print(person.first_name) 'Mike' 这段代大家肯定很熟悉，恩， property 嘛，谁不知道呢，但是 property 的实现机制大家清楚么？什么不清楚？那还学个毛的 Python 啊。。。开个玩笑，我们看下面一段代码classProperty(object): "Emulate PyProperty_Type() in Objects/descrobject.c" def__init__(self, fget=None, fset=None, fdel=None, doc=None): self.fget = fget self.fset = fset self.fdel = fdel ifdocisNoneandfgetisnotNone: doc = fget.__doc__ self.__doc__ = doc def__get__(self, obj, objtype=None): ifobjisNone: returnself ifself.fgetisNone: raiseAttributeError("unreadable attribute") returnself.fget(obj) def__set__(self, obj, value): ifself.fsetisNone: raiseAttributeError("can't set attribute") self.fset(obj, value) def__delete__(self, obj): ifself.fdelisNone: raiseAttributeError("can't delete attribute") self.fdel(obj) defgetter(self, fget): returntype(self)(fget, self.fset, self.fdel, self.__doc__) defsetter(self, fset): returntype(self)(self.fget, fset, self.fdel, self.__doc__) defdeleter(self, fdel): returntype(self)(self.fget, self.fset, fdel, self.__doc__) 看起来是不是很复杂，没事，我们来一步步的看。不过这里我们首先给出一个结论： Descriptors 是一种特殊 的对象，这种对象实现了 __get__ ， __set__ ， __delete__ 这三个特殊方法。 详解描述符 说说 Property 在上文，我们给出了 Propery 实现代码，现在让我们来详细说说这个classPerson(object): """""" ---------------------------------------------------------------------- def__init__(self, first_name, last_name): """Constructor""" self.first_name = first_name self.last_name = last_name ---------------------------------------------------------------------- @Property deffull_name(self): """ Return the full name """ return"%s %s"% (self.first_name, self.last_name) if__name__=="__main__": person = Person("Mike","Driscoll") print(person.full_name) 'Mike Driscoll' print(person.first_name) 'Mike' 首先，如果你对装饰器不了解的话，你可能要去看看这篇文章，简而言之，在我们正式运行代码之前，我们的解释器就会对我们的代码进行一次扫描，对涉及装饰器的部分进行替换。类装饰器同理。在上文中，这段代码@Property deffull_name(self): """ Return the full name """ return"%s %s"% (self.first_name, self.last_name) 会触发这样一个过程，即 full_name=Property(full_name) 。然后在我们后面所实例化对象之后我们调用 person.full_name 这样一个过程其实等价于 person.full_name.__get__(person) 然后进而触发 __get__() 方法里所写的 return self.fget(obj) 即原本上我们所编写的 def full_name 内的执行代码。 这个时候，同志们可以去思考下 getter() , setter() ,以及 deleter() 的具体运行机制了=。=如果还是有问题，欢迎在评论里进行讨论。 关于描述符 还记得之前我们所提到的一个定义么： Descriptors 是一种特殊的对象，这种对象实现了 __get__ ， __set__ ， __delete__ 这三个特殊方法 。然后在 Python 官方文档的说明中，为了体现描述符的重要性，有这样一段话：“They are the mechanism behind properties, methods, static methods, class methods, and super(). They are used throughout Python itself to implement the new style classes introduced in version 2.2. ” 简而言之就是 先有描述符后有天，秒天秒地秒空气 。恩，在新式类中，属性，方法调用，静态方法，类方法等都是基于描述符的特定使用。 OK，你可能想问，为什么描述符是这么重要呢？别急，我们接着看 使用描述符 首先请看下一段代码 classA(object):注：在 Python 3.x 版本中，对于 new class 的使用不需要显式的指定从 object 类进行继承，如果在 Python 2.X(x>2)的版本中则需要defa(self): pass if__name__=="__main__": a=A() a.a() 大家都注意到了我们存在着这样一个语句 a.a() ，好的，现在请大家思考下，我们在调用这个方法的时候发生了什么？ OK？想出来了么？没有？好的我们继续 首先我们调用一个属性的时候，不管是成员还是方法，我们都会触发这样一个方法用于调用属性 __getattribute__() ,在我们的 __getattribute__() 方法中，如果我们尝试调用的属性实现了我们的描述符协议，那么会产生这样一个调用过程 type(a).__dict__['a'].__get__(b,type(b)) 。好的这里我们又要给出一个结论了：“在这样一个调用过程中，有这样一个优先级顺序，如果我们所尝试调用属性是一个 data descriptors ，那么不管这个属性是否存在我们的实例的 __dict__ 字典中，优先调用我们描述符里的 __get__ 方法，如果我们所尝试调用属性是一个 non data descriptors ，那么我们优先调用我们实例里的 __dict__ 里的存在的属性，如果不存在，则依照相应原则往上查找我们类，父类中的 __dict__ 中所包含的属性，一旦属性存在，则调用 __get__ 方法，如果不存在则调用 __getattr__() 方法”。理解起来有点抽象？没事，我们马上会讲，不过在这里，我们先要解释下 data descriptors 与 non data descriptors ，再来看一个例子。什么是 data descriptors 与 non data descriptors 呢？其实很简单，在描述符中同时实现了 __get__ 与 __set__ 协议的描述符是 data descriptors ，如果只实现了 __get__ 协议的则是 non data descriptors 。好了我们现在来看个例子：importmath classlazyproperty: def__init__(self, func): self.func = func def__get__(self, instance, owner): ifinstanceisNone: returnself else: value = self.func(instance) setattr(instance, self.func.__name__, value) returnvalue classCircle: def__init__(self, radius): self.radius = radius pass @lazyproperty defarea(self): print("Com") returnmath.pi self.radius 2 deftest(self): pass if__name__=='__main__': c=Circle(4) print(c.area) 好的，让我们仔细来看看这段代码，首先类描述符 @lazyproperty 的替换过程，前面已经说了，我们不在重复。接着，在我们第一次调用 c.area 的时候，我们首先查询实例 c 的 __dict__ 中是否存在着 area 描述符，然后发现在 c 中既不存在描述符，也不存在这样一个属性，接着我们向上查询 Circle 中的 __dict__ ，然后查找到名为 area 的属性，同时这是一个 non data descriptors ，由于我们的实例字典内并不存在 area 属性，那么我们便调用类字典中的 area 的 __get__ 方法，并在 __get__ 方法中通过调用 setattr 方法为实例字典注册属性 area 。紧接着，我们在后续调用 c.area 的时候，我们能在实例字典中找到 area 属性的存在，且类字典中的 area 是一个 non data descriptors ，于是我们不会触发代码里所实现的 __get__ 方法，而是直接从实例的字典中直接获取属性值。 描述符的使用 描述符的使用面很广，不过其主要的目的在于让我们的调用过程变得可控。因此我们在一些需要对我们调用过程实行精细控制的时候，使用描述符，比如我们之前提到的这个例子classlazyproperty: def__init__(self, func): self.func = func def__get__(self, instance, owner): ifinstanceisNone: returnself else: value = self.func(instance) setattr(instance, self.func.__name__, value) returnvalue def__set__(self, instance, value=0): pass importmath classCircle: def__init__(self, radius): self.radius = radius pass @lazyproperty defarea(self, value=0): print("Com") ifvalue ==0andself.radius ==0: raiseTypeError("Something went wring") returnmath.pi value 2ifvalue !=0elsemath.pi self.radius 2 deftest(self): pass 利用描述符的特性实现懒加载，再比如，我们可以控制属性赋值的值classProperty(object): "Emulate PyProperty_Type() in Objects/descrobject.c" def__init__(self, fget=None, fset=None, fdel=None, doc=None): self.fget = fget self.fset = fset self.fdel = fdel ifdocisNoneandfgetisnotNone: doc = fget.__doc__ self.__doc__ = doc def__get__(self, obj, objtype=None): ifobjisNone: returnself ifself.fgetisNone: raiseAttributeError("unreadable attribute") returnself.fget(obj) def__set__(self, obj, value=None): ifvalueisNone: raiseTypeError("You cant to set value as None") ifself.fsetisNone: raiseAttributeError("can't set attribute") self.fset(obj, value) def__delete__(self, obj): ifself.fdelisNone: raiseAttributeError("can't delete attribute") self.fdel(obj) defgetter(self, fget): returntype(self)(fget, self.fset, self.fdel, self.__doc__) defsetter(self, fset): returntype(self)(self.fget, fset, self.fdel, self.__doc__) defdeleter(self, fdel): returntype(self)(self.fget, self.fset, fdel, self.__doc__) classtest(): def__init__(self, value): self.value = value @Property defValue(self): returnself.value @Value.setter deftest(self, x): self.value = x 如上面的例子所描述的一样，我们可以判断所传入的值是否有效等等。 以上就是Python 描述符(Descriptor)入门，更多相关文章请关注PHP中文网(www.gxlcms.com)！ 本条技术文章来源于互联网，如果无意侵犯您的权益请点击此处反馈版权投诉 本文系统来源：php中文网 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_39736934/article/details/112888600。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...Kafka作为一款高性能分布式流处理平台，已成为企业架构中的关键组件。然而，尽管Kafka在消息可靠性方面表现出色，但在实际应用中仍面临诸多挑战。例如，今年初某大型电商公司在促销活动期间遭遇了Kafka集群的性能瓶颈，导致订单处理延迟增加，最终影响了用户体验。这一事件引发了业界对Kafka在高并发场景下优化策略的关注。 针对此类问题，专家建议企业应更加注重Kafka的调优与监控。一方面，可以通过调整batch.size和linger.ms参数，优化批量发送效率，从而降低网络开销；另一方面，借助Prometheus和Grafana等工具实时监控集群状态，及时发现潜在风险。此外，随着云原生技术的普及，越来越多的企业开始将Kafka部署在容器化环境中。这种趋势不仅提升了资源利用率，还简化了运维流程。例如，阿里云推出的Kafka on ACK服务，就为企业提供了一站式解决方案，帮助企业快速构建稳定可靠的流处理系统。 与此同时，Kafka社区也在不断迭代更新，最新版本引入了多项新特性，如异步压缩算法和动态分区扩展等，进一步增强了系统的灵活性和扩展性。这些改进为企业应对复杂业务场景提供了更多可能性。不过，技术的进步也带来了新的学习曲线，开发者需要持续关注官方文档和最佳实践，以确保自身技能跟上行业发展的步伐。 总而言之，Kafka的广泛应用离不开对其特性的深刻理解以及合理配置。未来，随着5G、物联网等新兴技术的兴起，Kafka将在实时数据处理领域发挥更大的作用。企业和开发者唯有不断提升技术水平，才能在激烈的市场竞争中占据有利位置。

...我们，我们将第一时间进行核实并删除相应内容。 今天，正运动小助手给大家分享一下运动控制器之ZMC420SCAN控制器如何操作进行双振镜运动。 一ZMC420SCAN硬件介绍 1.功能介绍 ZMC420SCAN总线控制器支持ECAT/RTEX总线连接，支持最多达20轴运动控制，支持直线插补、任意圆弧插补、空间圆弧、螺旋插补、电子凸轮、电子齿轮、同步跟随、虚拟轴设置等；采用优化的网络通讯协议可以实现实时的运动控制。ZMC420SCAN总线控制器支持脉冲轴/总线轴/振镜轴混合插补。 ZMC420SCAN系列运动控制器支持以太网，RS232通讯接口和电脑相连，接收电脑的指令运行，可以通过CAN总线去连接各个扩展模块，从而扩展输入输出点数或运动轴。 ZMC420SCAN系列运动控制卡的应用程序可以使用VC,VB，VS，C++，C等软件来开发，程序运行时需要动态库zmotion.dll。调试时可以把ZDevelop软件同时连接到控制器，从而方便调试、方便观察。 2.硬件接口 3.振镜控制过程 激光振镜是一种专门用于激光加工领域的特殊的运动器件，激光振镜头内包含的主要元件是激光发生器，两个电机和两个振镜片，它靠两个电机分别控制两个振镜片X和Y反射激光，形成XY平面的运动，这两个电机使用控制器上的振镜轴接口控制。 激光振镜不同于一般的电机，激光振镜具有非常小的惯量，且在运动的过程中负载非常小，只需要带动反射镜片，系统的响应非常快。 ZMC420SCAN支持XY2-100振镜协议，支持运动控制与振镜联合插补运动。 上位机通过网口与控制器相连，通过XY2-100振镜协议进行控制振镜轴的运动，通过总线协议或者脉冲模式控制伺服轴运动。 使用ZMC420SCAN控制器的振镜轴接口连接激光振镜头，每个振镜轴接口内包含两路振镜通道信号，分别控制振镜片X、Y的偏转，从而控制了激光打到工件的位置。 4. 控制器PWM模拟量介绍 ZMC420SCAN的外部通用输出口0-11都具有PWM输出功能，PWM 输出受正常输出功能的控制，只有输出口状态ON的时候PWM才能实际输出，这样可以用来控制激光能量。 ZMC420SCAN控制器存在两路模拟量输入输出，可进行控制激光器能量输出，模拟量精度为12位。（DA采用了内部电源） 5.控制器基本信息 轴0-3为普通脉冲轴，振镜0为轴4、轴5控制振镜XY，振镜1为轴6、轴7控制XY。 二C++ 进行振镜+运动控制开发 1. 新建MFC项目并添加函数库 (1)在VS2015菜单“文件”→“新建”→ “项目”，启动创建项目向导。 (2)选择开发语言为“Visual C++”和程序类型“MFC应用程序”。 (3)点击下一步即可。 (4)选择类型为“基于对话框”，下一步或者完成。 (5)找到厂家提供的光盘资料，路径如下(64位库为例)。 A.进入厂商提供的光盘资料找到“8.PC函数”文件夹，并点击进入。 B.选择“函数库2.1”文件夹。 C.选择“Windows平台”文件夹。 D.根据需要选择对应的函数库这里选择64位库。 E.解压C++的压缩包,里面有C++对应的函数库。 F.函数库具体路径如下。 （6）将厂商提供的C++的库文件和相关头文件复制到新建的项目里面。 (7)在项目中添加静态库和相关头文件。 A.先右击项目文件，接着依次选择:“添加”→“现有项”。 B.在弹出的窗口中依次添加静态库和相关头文件。 (8)声明用到的头文件和定义控制器连接句柄。 至此项目新建完成，可进行MFC项目开发。 2.查看PC函数手册，熟悉相关函数接口 (1)PC函数手册也在光盘资料里面，具体路径如下：“光盘资料\8.PC函数\函数库2.1\ZMotion函数库编程手册 V2.1.pdf” (2)链接控制器，获取链接句柄。 ZAux_OpenEth()接口说明： (3)振镜运动接口。 为振镜运动单独封装了一个运动接口，使用movescanabs指令进行运动，采用FORCE_SPEED参数设置运动过程中的速度，运动过程中基本不存在加减速过程，支持us级别的时间控制。 3. MFC开发控制器双振镜运动例程 （1）例程界面如下。 （2） 链接按钮的事件处理函数中调用链接控制器的接口函数ZAux_OpenEth（），与控制器进行链接,链接成功后启动定时器1监控控制器状态。 //网口链接控制器void CSingle_move_Dlg::OnOpen(){char buffer[256]; int32 iresult;//如果已经链接，则先断开链接if(NULL != g_handle){ZAux_Close(g_handle);g_handle = NULL;}//从IP下拉框中选择获取IP地址GetDlgItemText(IDC_IPLIST,buffer,255);buffer[255] = '\0';//开始链接控制器iresult = ZAux_OpenEth(buffer, &g_handle);if(ERR_SUCCESS != iresult){g_handle = NULL;MessageBox(_T("链接失败"));SetWindowText("未链接");return;}//链接成功开启定时器1SetWindowText("已链接");SetTimer( 1, 100, NULL ); } （3）通过定时器监控控制器状态 。 void CSingle_move_Dlg::OnTimer(UINT_PTR nIDEvent) {// TODO: Add your message handler code here and/or call defaultif(NULL == g_handle){MessageBox(_T("链接断开"));return ;}if(1 == nIDEvent){CString string;float position = 0;ZAux_Direct_GetDpos( g_handle,m_nAxis,&position); //获取当前轴位置string.Format("振镜X1轴位置：%.2f", position );GetDlgItem( IDC_CURPOS )->SetWindowText( string );float NowSp = 0;ZAux_Direct_GetVpSpeed( g_handle,m_nAxis,&NowSp); //获取当前轴速度string.Format("振镜X1轴速度：%.2f", NowSp );GetDlgItem( IDC_CURSPEED)->SetWindowText( string );ZAux_Direct_GetDpos(g_handle, m_nAxis+1, &position); //获取当前轴位置string.Format("振镜Y1轴位置：%.2f", position);GetDlgItem(IDC_CURPOS2)->SetWindowText(string);ZAux_Direct_GetVpSpeed(g_handle, m_nAxis+1, &NowSp); //获取当前轴速度string.Format("振镜Y1轴速度：%.2f", NowSp);GetDlgItem(IDC_CURSPEED2)->SetWindowText(string);ZAux_Direct_GetDpos(g_handle, m_nAxis + 2, &position); //获取当前轴位置string.Format("振镜X2轴位置：%.2f", position);GetDlgItem(IDC_CURPOS3)->SetWindowText(string);NowSp = 0;ZAux_Direct_GetVpSpeed(g_handle, m_nAxis + 2, &NowSp); //获取当前轴速度string.Format("振镜X2轴速度：%.2f", NowSp);GetDlgItem(IDC_CURSPEED3)->SetWindowText(string);ZAux_Direct_GetDpos(g_handle, m_nAxis + 3, &position); //获取当前轴位置string.Format("振镜Y2轴位置：%.2f", position);GetDlgItem(IDC_CURPOS4)->SetWindowText(string);ZAux_Direct_GetVpSpeed(g_handle, m_nAxis + 3, &NowSp); //获取当前轴速度string.Format("振镜Y2轴速度：%.2f", NowSp);GetDlgItem(IDC_CURSPEED4)->SetWindowText(string);int status = 0; ZAux_Direct_GetIfIdle(g_handle, m_nAxis,&status); //判断当前轴状态if (status == -1){GetDlgItem( IDC_CURSTATE )->SetWindowText( "当前状态：停 止" );}else{GetDlgItem( IDC_CURSTATE )->SetWindowText( "当前状态：运动中" );} }CDialog::OnTimer(nIDEvent);} （4）通过启动按钮的事件处理函数获取编辑框的移动轨迹，并设置振镜轴参数操作振镜轴运动。 void CSingle_move_Dlg::OnStart() //启动运动{if(NULL == g_handle){MessageBox(_T("链接断开状态"));return ;}UpdateData(true);//刷新参数int status = 0; ZAux_Direct_GetIfIdle(g_handle, m_nAxis,&status); //判断当前轴状态 if (status == 0) //已经在运动中{ return;} //设定轴类型 1-脉冲轴类型 for (int i = 4; i < 8; i++){ZAux_Direct_SetAtype(g_handle, i, m_Atype);ZAux_Direct_SetMerge(g_handle,i,1);//设置脉冲当量ZAux_Direct_SetUnits(g_handle, i, m_units);//设定速度，加减速ZAux_Direct_SetLspeed(g_handle, i, m_lspeed);ZAux_Direct_SetSpeed(g_handle, i, m_speed);ZAux_Direct_SetForceSpeed(g_handle, i, m_speed);ZAux_Direct_SetAccel(g_handle, i, m_acc);ZAux_Direct_SetDecel(g_handle, i, m_dec);//设定S曲线时间 设置为0表示梯形加减速 ZAux_Direct_SetSramp(g_handle, i, m_sramp);}//使用MOVESCANABS运动int axislist[2] = { 4,5 };float dposlist[2] = { 0,0 };ZAux_MoveScanAbs(2, axislist, dposlist);CString str;GetDlgItem(IDC_EDIT_POSX1)->GetWindowText(str);float dbx = atof(str);GetDlgItem(IDC_EDIT_POSY1)->GetWindowText(str);float dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX2)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY2)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX3)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY3)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX4)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY4)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);//第二个振镜运动//使用MOVESCANABS运动axislist[0] = 6;axislist[1] = 7;dposlist[0] = 0;dposlist[1] = 0;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX5)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY5)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX6)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY6)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX7)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY7)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX8)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY8)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);UpdateData(false); } (5) 通过断开按钮的事件处理函数来断开与控制卡的连接。 void CSingle_move_Dlg::OnClose() //断开链接{// TODO: Add your control notification handler code hereif(NULL != g_handle){KillTimer(1); //关定时器KillTimer(2);ZAux_Close(g_handle);g_handle = NULL;SetWindowText("未链接");} } （6）通过坐标清零按钮的事件处理函数移动振镜轴回零到中心零点位置，不直接使用dpos=0，修改振镜轴坐标。 void CSingle_move_Dlg::OnZero() //清零坐标{if(NULL == g_handle){MessageBox(_T("链接断开状态"));return ;}// TODO: Add your control notification handler code hereint axislist[2] = { 4,5 };float dposlist[2] = { 0 };ZAux_Direct_MoveAbs(g_handle,2,axislist,dposlist); //设置运动回零点} 三调试与监控 编译运行例程，同时通过ZDevelop软件连接控制器对控制器状态进行监控 。 ZDevelop软件连接控制器监控控制器的状态，查看振镜轴对应参数，并可搭配示波器检测双振镜轨迹。 设置振镜轴运动，首先需要将轴类型配置成21振镜轴类型，并对应配置振镜轴的速度加减速等参数才可操作振镜进行运动。 通过ZDevelop软件的示波器监控双振镜运动运行轨迹。 视频演示。 开放式激光振镜+运动控制器(六)-双振镜运动 本次，正运动技术开放式激光振镜+运动控制器(六)：双振镜运动，就分享到这里。 更多精彩内容请关注“正运动小助手”公众号，需要相关开发环境与例程代码，请咨询正运动技术销售工程师：400-089-8936。 本文由正运动技术原创，欢迎大家转载，共同学习，一起提高中国智能制造水平。文章版权归正运动技术所有，如有转载请注明文章来源。 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_57350300/article/details/123402200。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...就会变得特别卡，整体性能直线下降，简直像路上突然挤满了慢吞吞的小汽车，堵得不行！要解决这个问题嘛，咱们可以先把文件用GZIP压缩一下，弄个小“压缩包”，然后再把它丢进Hive里头去。 下面是一段示例代码，展示了如何创建一个支持GZIP格式的外部表： sql -- 创建数据库 CREATE DATABASE IF NOT EXISTS log_db; -- 切换到数据库 USE log_db; -- 创建外部表并指定GZIP格式 CREATE EXTERNAL TABLE IF NOT EXISTS logs ( id STRING, timestamp STRING, message STRING ) ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' STORED AS TEXTFILE -- 注意这里使用TEXTFILE而不是默认的SEQUENCEFILE LOCATION '/path/to/gzipped/files'; 看到这里，你可能会问：“为什么这里要用TEXTFILE而不是SEQUENCEFILE？”这是因为Hive默认不支持直接读取GZIP格式的数据，所以我们需要手动调整存储格式。此外，还需要确保你的Hadoop集群已经启用了GZIP解压功能。 3.2 BZIP2的高阶玩法 接下来轮到BZIP2登场了。相比于GZIP，BZIP2的压缩比更高，但它也有一个明显的缺点：解压速度较慢。因此，BZIP2更适合用于那些访问频率较低的大规模静态数据集。 下面这段代码展示了如何创建一个支持BZIP2格式的分区表： sql -- 创建数据库 CREATE DATABASE IF NOT EXISTS archive_db; -- 切换到数据库 USE archive_db; -- 创建分区表并指定BZIP2格式 CREATE TABLE IF NOT EXISTS archives ( file_name STRING, content STRING ) PARTITIONED BY (year INT, month INT) STORED AS RCFILE -- RCFILE支持BZIP2压缩 TBLPROPERTIES ("orc.compress"="BZIP2"); 需要注意的是，在这种情况下，你需要确保Hive的配置文件中启用了BZIP2支持，并且相关的JAR包已经正确安装。 --- 四、实战经验分享 踩过的坑与学到的东西 在这个过程中，我遇到了不少挫折。比如说吧，有次我正打算把一个GZIP文件塞进Hive里，结果系统直接给我整了个报错，说啥解码器找不着。折腾了半天才发现，哎呀，原来是服务器上那个GZIP工具的老版本太不给劲了，跟最新的Hadoop配不上，闹起了脾气！于是，我赶紧联系运维团队升级了相关依赖，这才顺利解决问题。 还有一个教训是关于文件命名规范的。一开始啊，我老是忘了在压缩完的文件后面加“.gz”或者“.bz2”这种后缀名，搞得 Hive 一脸懵逼，根本分不清文件是啥类型的，直接就报错不认账了。后来我才明白，那些后缀名可不只是个摆设啊，它们其实是给文件贴标签的，告诉你这个文件是啥玩意儿，是图片、音乐，还是什么乱七八糟的东西。 --- 五、总结与展望 总的来说，虽然Hive对GZIP和BZIP2的支持有限，但这并不意味着我们不能利用它们的优势。相反，只要掌握了正确的技巧，我们完全可以在这两者之间找到平衡点，满足不同的业务需求。 最后，我想说的是，作为一名数据工程师，我们不应该被工具的限制束缚住手脚。相反，我们应该敢于尝试新事物，勇于突破常规。毕竟，正是这种探索精神，推动着整个行业不断向前发展！ 好了，今天的分享就到这里啦。如果你也有类似的经历或者想法，欢迎随时跟我交流哦~再见啦！

...SS或AWS S3）进行分布式文件存储与管理，极大地提高了系统的稳定性和可扩展性。 同时，针对安全性问题，Spring Security框架提供了更严格的CSRF保护和JWT token验证等机制，确保用户在执行敏感操作（如文件上传与下载）时的身份合法性。此外，OAuth 2.0授权协议在企业级应用中的普及，使得跨系统、跨平台的用户身份验证与授权更为便捷且安全。 另外，随着前端技术的发展，诸如React、Vue.js等现代前端框架也实现了对文件上传组件的高度封装，配合后端API能够提供无缝的用户体验。例如，通过axios库在前端发起multipart/form-data类型的POST请求，配合后端的RESTful API完成文件上传过程，而后再通过响应式编程实现文件上传状态的实时反馈。 综上所述，随着技术的演进，无论是后端框架还是前端技术，都在不断提升文件上传下载功能的安全性、易用性和性能表现。在实际项目开发中，除了掌握基础的文件处理方法外，还需关注行业前沿趋势，灵活运用新技术手段以满足不断变化的业务需求。

...我们，我们将第一时间进行核实并删除相应内容。 header header元素是一种具有引导和导航作用的辅助元素。通常，header元素可以包含一个区块的标题(如h1至h6，或者hgroup元素标签)，但也可以包含其他内容，例如数据表格、搜索表单或相关的logo图片。 我们可以使用该元素来写整个页面的标题部分： The most important heading on this page 同一个页面中，每一个内容区块都可以有自己的元素，例如： The most important heading on this page 在HTML5中，我们可以不使用div，而用更加语义化的footer来写： copyright sitemap contact to top 在同一个页面中可以使用多个元素，即可以用作页面整体的页脚，也可以作为一个内容区块的结尾，例如，我们可以将直接写在或是中： Section content appears here. Footer information for section. Article content appears here. Footer information for article. nav -- 作用 -- 导航栏 nav nav元素是一个可以用来作为页面导航的链接组；其中的导航元素链接到其他页面或当前页面的其他部分。并不是所有的链接组都要被放进元素；例如，在页脚中通常会有一组链接，包括服务条款、首页、版权声明等；这时使用元素是最恰当的，而不需要元素。 一直以来，我们都习惯用如下这种方式来定义导航条： Home About Blog 下面是W3C给出的一个代码示例： The Wiki Center Of Exampland Home Current Events ...more... Demos in Exampland Written by A. N. Other. Public demonstrations Demolitions ...more... Public demonstrations ...more... Demolitions ...more... ...more... Edit | Delete | Rename © copyright 1998 Exampland Emperor 关键自li，em，dl，ul,ol,footer,header,nav,aside,article section 版块 用于划分页面上的不同区域,或者划分文章里不同的节 header 页面头部或者版块(section)头部 footer 页面底部或者(section)底部 nav 导航 (包含链接 ... html5新特性-header,nav,footer,aside,article,section等各元素的详解 Html5新增了27个元素,废弃了16个元素,根据现有的标准规范,把HTML5的元素按优先级定义为结构性属性.级块性元素.行内语义性元素和交互性元素四大类. 下面是对各标签的详解,section.he ... h5中的结构元素header、nav、article、aside、section、footer介绍 结构元素不具有任何样式,只是使页面元素的的语义更加明确. header元素 header元素是一种具有引导和导航作用的的结构元素,该元素可以包含所有通常放在页面头部的内容.header元素通常用来放置 ... html5，html5教程 html5,html5教程 1.向后兼容 HTML5是这样被定义的:能向后兼容目前UA处理内容的方式.为了让语言更简单,一些老的元素和Attribute被舍弃.比如一些纯粹用于展现的元素(译注:即非语 ... 一步HTML5教程学会体系 HTML5是HTML最新的版本,万维网联盟. HTML5是下一代的HTML标准,HTML5是为了在移动设备上支持多媒体. 新特性: 绘画的canvas元素,用于媒介回放的video和audio元素,对 ... IT兄弟连 HTML5教程 了解HTML5的主流应用1 在很多人眼里,HTML5与互联网营销密切相关,但其实从开发者的角度而言,它是一种网页标准,定义了浏览器语言的编写规范.伴随HTML5标准尘埃落定,浏览器对HTML5特性的逐步支持,再加上国内对HTML ... 【转帖】39个让你受益的HTML5教程 39个让你受益的HTML5教程 闲话少说,本文作者为大家收集了网上学习HTML5的资源,期望它们可以帮助大家更好地学习HTML5. 好人啊! 不过,作者原来说的4 ... 【特别推荐】Web 开发人员必备的经典 HTML5 教程 对于我来说,Web 前端开发是最酷的职业之一,因为你可以用新的技术发挥,创造出一些惊人的东西.唯一的问题是,你需要跟上这个领域的发展脚步,因此,你必须不断的学习,不断的前进.本文将分享能够帮助您快速掌 ... HTML5教程之本地存储SessionStorage SessionStorage: 将数据保存在session对象中,所谓session是指用户在浏览某个网站时,从进入网站到浏览器关闭所经过的这段时间会话,也就是用户浏览这个网站所花费的时间就是sess ... 随机推荐 【转】MySQL索引背后的数据结构及算法原理 摘要 本文以MySQL数据库为研究对象,讨论与数据库索引相关的一些话题.特别需要说明的是,MySQL支持诸多存储引擎,而各种存储引擎对索引的支持也各不相同,因此MySQL数据库支持多种索引类型,如BT ... IIS7 / IIS7.5 URL 重写 HTTP 重定向到 HTTPS(转) 转自: http://www.cnblogs.com/yipu/p/3880518.html 1.购买SSL证书,参考:http://www.cnblogs.com/yipu/p/3722135. ... OpenGL的glViewPort窗口设置函数实现分屏 之前实现过全景图片查看(OpenGL的几何变换3之内观察全景图),那么我们需要进行分屏该如何实现呢?如下图: 没错就是以前提过的glViewPort函数,废话不多说了,我直接上代码: //从这里开始进 ... hdu 4764 Stone (巴什博弈，披着狼皮的羊，小样，以为换了身皮就不认识啦) 今天(2013/9/28)长春站,最后一场网络赛! 3~5分钟后有队伍率先发现伪装了的签到题(博弈) 思路: 与取石头的巴什博弈对比 题目要求第一个人取数字在[1,k]间的某数x,后手取x加[1,k] ... android报表图形引擎(AChartEngine)demo解析与源码 AchartEngine支持多种图表样式,本文介绍两种:线状表和柱状表. AchartEngine有两种启动的方式:一种是通过ChartFactory.getView()方式来直接获取到view ... CSS长度单位及区别 em ex px pt in 1. css相对长度单位 Ø em 元素的字体高度 Ø ex 字体x的高度 Ø px ... es6的箭头函数 1.使用语法 : 参数 => 函数语句; 分为以下几种形式 : (1) ()＝>语句 ( )＝> statement 这是一种简写方法省略了花括号和return 相当于 ()＝&g ... pdfplumber库解析pdf格式 参考地址:https://github.com/jsvine/pdfplumber 简单的pdf转换文本: import pdfplumber with pdfplumber.open(path) a ... KMP替代算法——字符串Hash 很久以前写的... 今天来谈谈一种用来替代KMP算法的奇葩算法--字符串Hash 例题:给你两个字符串p和s,求出p在s中出现的次数.(字符串长度小于等于1000000) 字符串的Hash 根据字面意 ... SSM_CRUD新手练习(5)测试mapper 上一篇我们使用逆向工程生成了所需要的bean.dao和对应的mapper.xml文件,并且修改好了我们需要的数据库查询方法. 现在我们来测试一下DAO层,在test包下新建一个MapperTest.j ... 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_35666639/article/details/118169985。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...+20对三种智能指针进行了增强，例如shared_ptr现在支持定制删除器和分配器，并且允许通过std::atomic_shared_ptr进行原子操作，增强了其在多线程环境下的安全性。 同时，对于智能指针在容器中的应用也有了更深入的研究和发展。STL容器如vector、list等支持存储智能指针类型元素，使得资源管理更为便捷和可靠。而C++20引入的std::jthread线程类以及相关库函数，则鼓励开发者使用std::shared_ptr来传递线程间共享资源，以防止因资源生命周期管理不当引发的各类问题。 另外，关于智能指针在实际项目开发中的最佳实践，业界持续涌现出大量的实战案例和经验总结。例如，在大型游戏引擎Unreal Engine 4和Unity3D中，智能指针被广泛用于内存管理和对象生命周期控制，这些成功案例为C++开发者提供了宝贵的参考和借鉴。 值得注意的是，尽管智能指针极大程度上简化了内存管理，但过度依赖或错误使用也可能带来额外开销甚至隐藏bug。因此，对于特定场景下是否应采用智能指针，以及选用何种类型的智能指针，开发者需要根据具体需求进行权衡和决策，同时结合现代编译器和运行时优化技术，确保程序性能和安全性的最优化。

...我们，我们将第一时间进行核实并删除相应内容。 ifndef _NIDS_NIDS_H define _NIDS_NIDS_H define NIDS_MAJOR 1 / 主版本号 / define NIDS_MINOR 20 / 次版本号 / include <sys/types.h> enum { NIDS_WARN_IP = 1, / 表示 IP 数据包异常 / NIDS_WARN_TCP, / 表示 TCP 数据包异常 / NIDS_WARN_UDP, / 表示 UDP 数据包异常 / NIDS_WARN_SCAN / 表示有扫描攻击发生 / }; enum { NIDS_WARN_UNDEFINED = 0, / 表示未定义 / NIDS_WARN_IP_OVERSIZED, / 表示 IP 数据包超长 / NIDS_WARN_IP_INVLIST, / 表示无效的碎片队列 / NIDS_WARN_IP_OVERLAP, / 表示发生重叠 / NIDS_WARN_IP_HDR, / 表示无效 IP首部 ,IP 数据包发生异常 / NIDS_WARN_IP_SRR, / 表示源路由 IP数据包 / NIDS_WARN_TCP_TOOMUCH, / 表示 TCP 数据个数太多 , 因为在Libnids 中在同一时刻捕获的TCP 个数最大值为 TCP 连接参数的哈西表长度的 3/4/ NIDS_WARN_TCP_HDR, / 表示无效 TCP首部 ,TCP 数据包发生异常 / NIDS_WARN_TCP_BIGQUEUE, / 表示 TCP 接受的队列数据过多 / NIDS_WARN_TCP_BADFLAGS / 表示错误标记 / }; /Libnids 状态描述的是连接的逻辑状态, 真正的 TCP 连接状态有 11种 . TCP_ESTABLISHED TCP 连接建立 , 开始传输数据 TCP_SYN_SEND 主动打开 TCP_SYN_RECV 接受 SYN TCP_FIN_WAIT1 TCP_FIN_WAIT2 TCP_TIME_WAIT TCP_CLOSE TCP_CLOSE_WAIT TCP_LAST_ACK TCP_LISTEN TCP_CLOSING / define NIDS_JUST_EST 1 / 表示 TCP 连接建立 , 在此状态下就可以决定是否对此TCP 连接进行数据分析 , 可以决定是否捕获 TCP客户端接收的数据 ,TCP 服务端接收的数据 ,TCP 客户端接收的紧急数据或者TCP 客户端接收的紧急数据 / define NIDS_DATA 2 / 表示接收数据的状态 ,在这个状态可以判断是否有新的数据到达 ,如果有就可以把数据存储起来 , 可以在这个状态之中来分析 TCP 传输的数据 , 此数据就存储在half_stream 数据接口的缓存之中/ define NIDS_CLOSE 3 / 表示 TCP 连接正常关闭 / define NIDS_RESET 4 / 表是 TCP 连接被重置关闭 / define NIDS_TIMED_OUT 5 / 表示由于超时 TCP连接被关闭 / define NIDS_EXITING 6 / 表示 Libnids正在退出 , 在这个状态下可以最后一次使用存储在 half_stream 数据结构中的缓存数据 / / 校验和 / define NIDS_DO_CHKSUM 0 / 表示告诉 Libnids要计算校验和 / define NIDS_DONT_CHKSUM 1 / 表示告诉 Libnids不要计算校验和 / struct tuple4 / 描述一个地址端口对 , 它表示发送发IP 和端口以及接收方 IP 和端口 , 适用 TCP,UDP/ { u_short source; / 源 IP 地址的端口号/ u_short dest; / 目的 IP 地址的端口号/ u_int saddr; / 源 IP 地址 / u_int daddr; / 目的 IP 地址 / }; struct half_stream / 描述在 TCP 连接中一端的所有信息, 可以是客户端 , 也可以是服务端 / { char state; / 表示套接字的状态 , 也就是TCP 的状态 / char collect; / 可以表示有数据到达 , 此数据存放在data 成员中 , 也可以表示不存储此数据到 data中 , 此数据忽略 . 如果大于0 就存储 , 否则就忽略 / char collect_urg; / 可以表示有紧急数据到达 , 此数据就存放在urgdata 中 , 也可以表示不存储此数据到 urgdata中 , 此速数据忽略 . 如果大于0 就存储 , 否则就忽略 / char data; / 用户存储正常接受到的数据 / int offset; / 表示存储在 data 中数据的第一个字节的偏移量/ int count; / 表示从 TCP 连接开始已经存储到data 中的数据的字节数 / int count_new; / 有多少新的数据存储到 data 中, 如果为 0, 则表示没有新的数据到达 / int bufsize; int rmem_alloc; int urg_count; / 用来存储紧急数据 / u_int acked; u_int seq; u_int ack_seq; u_int first_data_seq; u_char urgdata; //存储紧急数据 u_char count_new_urg; / 表示有新的紧急数据到达 , 如果为0 表示没有新的紧急数据 / u_char urg_seen; //新的urg数据，不是以前重复的数据 u_int urg_ptr;/指向urg在流中的位置/ u_short window; u_char ts_on; u_char wscale_on; u_int curr_ts; u_int wscale; struct skbuff list; struct skbuff listtail; }; struct tcp_stream / 描述一个 TCP 连接的所有信息/ { struct tuple4 addr; char nids_state; struct lurker_node listeners; struct half_stream client; / 表示客户端信息 / struct half_stream server; / 表示服务端信息 / struct tcp_stream next_node; struct tcp_stream prev_node; int hash_index; struct tcp_stream next_time; struct tcp_stream prev_time; int read; struct tcp_stream next_free; }; struct nids_prm / 描述了 Libnids 的一些全局参数信息/ { int n_tcp_streams; / 表示哈西表大小 , 此哈西表用来存放tcp_stream 数据结构 , 默认值 1040.在同一时刻 Libnids 捕获的 TCP 数据包的最大个数必须是此参数值的3/4/ int n_hosts; / 表示哈西表的大小 , 此哈西表用来存储IP 碎片信息的 , 默认值为 256/ char device; / 表示网络接口 ,Libnids 将在此网络接口上捕获数据, 默认值为 NULL. 这样 Libnids将使用 pcap_lookupdev来查找可以用的网络接口 . 如果其值为 all, 表示捕获所有网络接口的数据/ char filename; / 表示用来存储网络数据的捕获文件 , 此文件的类型必须与 Libpcap 类型一致 , 如果设置了文件, 与此同时就应该设置 device 为 NULL,默认值为 NULL/ int sk_buff_size; / 表示的是数据接口 sk_buff 的大小 .sk_buff 是Linux 内核中一个重要的数据结构, 是用来进行数据包排队操作的 , 默认值为 168/ int dev_addon; / 表示在数据结构 sk_buff 中用于网络接口上信息的字节数. 如果是 -1( 默认值 ),那么 Libnids 会根据不同的网络接口进行修正 / void (syslog) (); / 是一个函数指针 , 默认值为nids_syslog() 函数 . 在 syslog函数中可以检测入侵攻击 , 如网络扫描攻击 , 也可以检测一些异常情况, 如无效 TCP 标记 / int syslog_level; / 表示日志等级 , 默认值是LOG_ALERT/ int scan_num_hosts; / 表示一个哈西表的大小 ,( 此哈西表用来存储端口扫描信息) 表示 Libnids 将要检测的同时扫描的端口数据 . 如果其值为 0,Libnids将不提供端口扫描功能 . 默认值 256/ int scan_delay; / 表示在扫描检测中 , 俩端口扫描的间隔时间, 以毫秒来计算 , 缺省值为 3000/ int scan_num_ports; / 表示相同源地址必须扫描的 TCP 端口数目 , 默认值为10/ void (no_mem) (char ); / 是一个函数指针 , 当Libnids 发生内存溢出时被调用/ int (ip_filter) (); / 是一个函数指针 , 此函数可以用来分析IP 数据包 , 当有 IP 数据包到达时 , 此函数就被调用. 如果此函数返回非零值 , 此数据包就被处理 ;如果返回零 , 此 IP 数据包就被丢弃. 默认值为 nids_ip_filter 函数 , 总是返回 1./ char pcap_filter; / 表示过滤规则 , 即Libpcap 的过滤规则 , 默认值为 NULL,表示捕获所有数据包 . 可以在此设置过滤规则 , 只捕获感兴趣的开发包/ int promisc; / 表示网卡模式 , 如果是非零, 就把此网卡设置为混杂模式 ; 否则 , 设为非混杂模式 . 默认值为1/ int one_loop_less; / 初始值为 0/ int pcap_timeout; / 表示捕获数据返回的时间 , 以毫秒计算. 实际上它表示的就是 Libpcap 函数中的 pcap_open_live函数的 timeout 参数 , 默认值 1024/ }; / 返回值 : 调用成功返回 1,失败返回 0 参 数 : 无 功 能 : 对 Libnids 初始化, 这是所有设计基于 Libnids 的程序最开始调用的函数 . 它的主要内容包括打开网络接口 , 打开文件 , 编译过滤规则 , 判断网络链路层类型, 进行必要的初始化工作 / int nids_init (void); / 返回值 : 无 参 数 : 回调函数名字 功 能 : 注册一个能够检测所有 IP 数据包的回调函数, 包括 IP 碎片 .e.g nids_register_ip_frag(ip_frag_function); void ip_frag_function(struct ip a_packet,int len) a_packet 表示接收的IP 数据包 len 表示接收的数据包长度 此回调函数可以检测所有的IP 数据包 , 包括 IP 碎片 / void nids_register_ip_frag (void ()); // / 返回值 : 无 参 数 : 回调函数名字 功 能 : 注册一个回调函数 , 此回调函数可以接收正常的IP 数据包 .e.g nids_register_ip_frag(ip_frag_function); void ip_frag_function(struct ip a_packet) a_packet 表示接收的IP 数据包 此回调函数可以接收正常的IP 数据包 , 并在此函数中对捕获数到的 IP数据包进行分析 . / void nids_register_ip (void ()); // / 返回值 : 无 参 数 : 回调函数 功 能 : 注册一个 TCP 连接的回调函数. 回调函数的类型定义如下 : void tcp_callback(struct tcp_stream ns,void param) ns 表示一个TCP 连接的所有信息 , param 表示要传递的参数信息 , 可以指向一个 TCP连接的私有数据 此回调函数接收的TCP 数据存放在 half_stream 的缓存中 , 应该马上取出来 ,一旦此回调函数返回 , 此数据缓存中存储的数据就不存在 了 .half_stream 成员 offset描述了被丢弃的数据字节数 . 如果不想马上取出来 , 而是等到存储一定数量的数据之后再取出来, 那么可 以使用函数nids_discard(struct tcp_stream ns, int num_bytes)来处理 . 这样回调函数返回时 ,Libnids 将丢弃缓存数据之前 的 num_bytes 字节的数据 .如果不调用 nids_discard()函数 , 那么缓存数据的字节应该为 count_new 字节 . 一般情况下, 缓存中的数据 应该是count-offset 字节 / void nids_register_tcp (void ()); / 返回值 : 无 参 数 : 回调函数 功 能 : 注册一个分析 UDP 协议的回调函数, 回调函数的类型定义如下 : void udp_callback(struct tuple4 addr,char buf,int len,struct ip iph) addr 表示地址端口信息buf 表示 UDP 协议负载的数据内容 len表是 UDP 负载数据的长度 iph 表示一个IP 数据包 , 包括 IP 首部 ,UDP 首部以及UDP 负载内容 / void nids_register_udp (void ()); / 返回值 : 无 参 数 : 表示一个 TCP 连接 功 能 : 终止 TCP 连接 . 它实际上是调用 Libnet的函数进行构造数据包 , 然后发送出去 / void nids_killtcp (struct tcp_stream ); / 返回值 : 无 参 数 : 参数 1 一个 TCP 连接 参数 2 个数 功 能 : 丢弃参数 2 字节 TCP 数据 , 用于存储更多的数据 / void nids_discard (struct tcp_stream , int); / 返回值 : 无 参 数 : 无 功 能 : 运行 Libnids, 进入循环捕获数据包状态. 它实际上是调用 Libpcap 函数 pcap_loop()来循环捕获数据包 / void nids_run (void); / 返回值 : 调用成功返回文件描述符 ,失败返回 -1 参 数 : 无 功 能 : 获得文件描述符号 / int nids_getfd (void); / 返回值 : 调用成功返回个数 ,失败返回负数 参 数 : 表示捕获数据包的个数 功 能 : 调用 Libpcap 中的捕获数据包函数pcap_dispatch() / int nids_dispatch (int); / 返回值 : 调用成功返回 1,失败返回 0 参 数 : 无 功 能 : 调用 Libpcap 中的捕获数据包函数pcap_next() / int nids_next (void); extern struct nids_prm nids_params; /libnids.c定以了一个全部变量 , 其定义和初始值在 nids_params/ extern char nids_warnings[]; extern char nids_errbuf[]; extern struct pcap_pkthdr nids_last_pcap_header; struct nids_chksum_ctl { / 描述的是计算校验和 , 用于决定是否计算校验和/ u_int netaddr; / 表示地址 / u_int mask; / 表示掩码 / u_int action; / 表示动作 , 如果是NIDS_DO_CHKSUM, 表示计算校验和; 如果是 NIDS_DONT_CHKSUM, 表示不计算校验和 / u_int reserved; / 保留未用 / }; / 返回值 : 无 参 数 : 参数 1 表示 nids_chksum_ctl 列表 参数 2 表示列表中的个数 功 能 : 决定是否计算校验和 . 它是根据数据结构nids_chksum_ctl 中的action 进行决定的 , 如果所要计算的对象不在列表中 , 则必须都要计算校验和 / extern void nids_register_chksum_ctl(struct nids_chksum_ctl , int); endif / _NIDS_NIDS_H / 本篇文章为转载内容。原文链接：https://blog.csdn.net/xieqb/article/details/7681968。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...是为实时数据流提供高性能处理的框架。哎呀，兄弟！把这两样技术给整到一块儿用，那效果简直不要太棒！不仅能快速消化那些源源不断的数据洪流，还能帮咱们做出超明智的决定，简直就是开挂的存在嘛！本文旨在探索Mahout与Spark Streaming如何协同工作，为实时流数据分析提供强大的解决方案。 2. Mahout概述 Mahout是一个基于Hadoop的机器学习库，旨在利用分布式计算资源来加速大规模数据集上的算法执行。哎呀，这个家伙可真厉害！它能用上各种各样的机器学习魔法，比如说分门别类的技巧（就是咱们说的分类）、把相似的东西归到一块儿的本事（聚类）还有能给咱们推荐超棒东西的神奇技能（推荐系统）。而且，它最擅长的就是对付那些海量的数据，就像大鱼吃小鱼一样，毫不费力就能搞定！通过Mahout，我们可以构建复杂的模型来挖掘数据中的模式和关系，从而驱动业务决策。 3. Spark Streaming简介 Apache Spark Streaming是Spark生态系统的一部分，专为实时数据流处理设计。哎呀，这个玩意儿简直就是程序员们的超级神器！它能让咱这些码农兄弟们轻松搞定那些超快速、高效率的实时应用，你懂的，就是那种分秒必争、数据飞速流转的那种。想象一下，一秒钟能处理几千条数据，那感觉简直不要太爽啊！就像是在玩转数据的魔法世界，每一次点击都是对速度与精准的极致追求。这不就是我们程序员的梦想吗？在数据的海洋里自由翱翔，每一刻都在创造奇迹！Spark Streaming的精髓就像个魔术师，能把连续不断的水流（数据流）变换成小段的小溪（微批次）。这小溪再通过Spark这个强大的分布式计算平台，就像是在魔法森林里跑的水车，一边转一边把水（数据）处理得干干净净。这样一来，咱们就能在实时中捕捉到信息的脉动，做出快速反应，既高效又灵活！ 4. Mahout与Spark Streaming的集成 为了将Mahout的机器学习能力与Spark Streaming的实时处理能力结合起来，我们需要创建一个流水线，使得Mahout可以在实时数据流上执行分析任务。这可以通过以下步骤实现： - 数据接入：首先，我们需要将实时数据流接入Spark Streaming。这可以通过定义一个DStream（Data Stream）对象来完成，该对象代表了数据流的抽象表示。 scala import org.apache.spark.streaming._ import org.apache.spark.streaming.dstream._ val sparkConf = new SparkConf().setAppName("RealtimeMahoutAnalysis").setMaster("local[2]") val sc = new SparkContext(sparkConf) valssc = new StreamingContext(sc, Seconds(1)) // 创建StreamingContext，时间间隔为1秒 val inputStream = TextFileStream("/path/to/your/data") // 假设数据来自文件系统 val dstream = inputStream foreachRDD { rdd => rdd.map { line => val fields = line.split(",") (fields(0), fields.slice(1, fields.length)) } } - Mahout模型训练：然后，我们可以使用Mahout中的算法对数据进行预处理和建模。例如，假设我们想要进行用户行为的聚类分析，可以使用Mahout的KMeans算法。 scala import org.apache.mahout.cf.taste.hadoop.recommender.KNNRecommender import org.apache.mahout.cf.taste.impl.model.file.FileDataModel import org.apache.mahout.cf.taste.impl.neighborhood.ThresholdUserNeighborhood import org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender import org.apache.mahout.cf.taste.impl.similarity.PearsonCorrelationSimilarity import org.apache.mahout.math.RandomAccessSparseVector import org.apache.hadoop.conf.Configuration val dataModel = new FileDataModel(new File("/path/to/your/data.csv")) val neighborhood = new ThresholdUserNeighborhood(0.5, dataModel, new Configuration()) val similarity = new PearsonCorrelationSimilarity(dataModel) val recommender = new GenericUserBasedRecommender(dataModel, neighborhood, similarity) val recommendations = dstream.map { (user, ratings) => val userVector = new RandomAccessSparseVector(ratings.size()) for ((itemId, rating) <- ratings) { userVector.setField(itemId.toInt, rating.toDouble) } val recommendation = recommender.recommend(user, userVector) (user, recommendation.map { (itemId, score) => (itemId, score) }) } - 结果输出：最后，我们可以将生成的推荐结果输出到合适的目标位置，如日志文件或数据库，以便后续分析和应用。 scala recommendations.foreachRDD { rdd => rdd.saveAsTextFile("/path/to/output") } 5. 总结与展望 通过将Mahout与Spark Streaming集成，我们能够构建一个强大的实时流数据分析平台，不仅能够实时处理大量数据，还能利用Mahout的高级机器学习功能进行深入分析。哎呀，这个融合啊，就像是给数据分析插上了翅膀，能即刻飞到你眼前，又准确得不得了！这样一来，咱们做决定的时候，心里那根弦就更紧了，因为有它在身后撑腰，决策那可是又稳又准，妥妥的！哎呀，随着科技车轮滚滚向前，咱们的Mahout和Spark Streaming这对好搭档，未来肯定会越来越默契，联手为我们做决策时，用上实时数据这个大宝贝，提供更牛逼哄哄的武器和方法！想象一下，就像你用一把锋利的剑，能更快更准地砍下胜利的果实，这俩家伙在数据战场上，就是那把超级厉害的宝剑，让你的决策快人一步，精准无比！ --- 以上内容是基于实际的编程实践和理论知识的融合，旨在提供一个从概念到实现的全面指南。哎呀，当真要将这个系统或者项目实际铺展开来的时候，咱们得根据手头的实际情况，比如数据的个性、业务的流程和咱们的技术底子，来灵活地调整策略，让一切都能无缝对接，发挥出最大的效用。就像是做菜，得看食材的新鲜度，再搭配合适的调料，才能做出让人满意的美味佳肴一样。所以，别死板地照搬方案，得因地制宜，因材施教，这样才能确保我们的工作既高效又有效。

...我们，我们将第一时间进行核实并删除相应内容。 最近在找工作，在这个过程中我感到很迷茫，投了很多简历，被查看的却很少，其中也有到现场去面试，结果也很不理想(╥╯^╰╥)。 哈哈，跑题了，我在看之前所做的项目时，在我的收藏夹中看到了以前收藏的有关爬虫的文章，点开后又重新学习了一下。 下面是这两篇文章的链接 java实现网络爬虫：https://www.cnblogs.com/1996swg/p/7355577.html Jsoup教程：https://www.jianshu.com/p/fd5caaaa950d 接下来，我通过Jsoup来实现爬取彼岸桌面里面的图片进行爬虫学习！！！ 我用的开发工具是IDEA，jdk是1.7版本，项目结构大致如下所示： 一、页面分析 首先来分析一下彼岸桌面的网页的结构： 我们第一个看到的是网站的域名为http://www.netbian.com/，它有如上所示的分类，我们尝试着点开一些分类去看一下他的链接。 通过点击每个分类，发现不同的分类下，地址栏显示为域名后面拼接这对应分类的拼音，但在分类为王者荣耀之后的拼接的确是“s/分类拼音”。这样我们可以创建一个枚举类，将所有分类集中管理。在common包下创建一个Kind枚举类： package com.asahi.common;/ 分类的枚举/public enum Kind {RILI("rili"), DONGMAN("dongman"), FENGJING("fengjing"), MEINV("meinv"), YOUXI("youxi"), YINGSHI("yingshi"),DONGTAI("dongtai"), WEIMEI("weimei"), SHEJI("sheji"), KEAI("keai"), QICHE("qiche"), HUAHUI("huahui"),DONGWU("dongwu"), JIERI("jieri"), RENWU("renwu"), MEISHI("meishi"), SHUIGUO("shuiguo"), JIANZHU("jianzhu"),TIYU("tiyu"), JUNSHI("junshi"), FEIZHULIU("feizhuliu"), QITA("qita"), WANGZHERONGYAO("s/wangzherongyao"), HUYAN("s/huyan"), LOL("s/lol");String kind;Kind(String kind) {this.kind = kind;}public static boolean contains(String test) {for (Kind c : Kind.values()) {if (c.kind.equals(test)) {return true;} }return false;} } 这里我添加了一个比较的方法供之后判断输入的分类名是否包含在这些分类里面。 接下来我们在分析分类面的展示情况，以美女分类页面为例(●´∀｀●)，最下边有分页，如果只获取这个页面的图片并不能获取所有美女图，我们还需要点击每一个分页，从分页中获取所有的图片。通过分析发现，第一页的链接是在原有链接基础上拼接“/index.htm”，从第二页之后拼接的是“/index_页号.htm”。 这样我们只需要获取总页数在依次遍历拼接就可以了，现在的问题是如何获取总页数，我一开始的想法是获取分页中“共167页”这个标签后再只保留数字就可以个，但发现运行后获取不到该元素节点，经过排查了解到这个标签是通过js生成的，于是我转换了思路，通过获取最后一个页号来得到一共分了多少页 Document root_doc = Jsoup.connect("http://www.netbian.com/" + kind + "/").get();Elements els = root_doc.select("main .page a");//这里els.eq(els.size() - 2的原因是后边确定按钮用的是a标签要去掉，再去掉一个“下一页”标签Integer page = Integer.parseInt(els.eq(els.size() - 2).text()); 分类页中图片所在的标签结构为： 分类页面下的图片不是我们想要的，我们想要的是点击进去详细页的高清大图，所以需要获取a标签的链接，再从这个链接中获取真正想要的图片。 详细页中图片所在的标签结构为： 二、代码实现 到这里分类页分析的差不多了，我们通过代码来进行获取图片。首先导入Jsoup的jar包：jsoup-1.12.1.jar，如果采用Maven请导入下边的依赖。 <dependency><groupId>org.jsoup</groupId><artifactId>jsoup</artifactId><version>1.12.1</version></dependency> 在utils创建JsoupPic类，并添加getPic方法，代码如下： public static void getPic(String kind) throws Exception {//get请求方式进行请求Document root_doc = Jsoup.connect("http://www.netbian.com/" + kind + "/").get();//获取分页标签，用于获取总页数Elements els = root_doc.select("main .page a");Integer page = Integer.parseInt(els.eq(els.size() - 2).text());for (int i = 1; i < page; i++) {Document document = null;//这里判断的是当前页号是否为1，如果为1就不拼页号，否则拼上对应的页号if (i == 1) {document = Jsoup.connect("http://www.netbian.com/" + kind + "/index.htm").get();} else {document = Jsoup.connect("http://www.netbian.com/" + kind + "/index_" + i + ".htm").get();}//获取每个分页链接里面a标签的链接，进入链接页面获取当前图拼的大尺寸图片Elements elements = document.select("main .list li a");for (Element element : elements) {String href = element.attr("href");String picUrl = "http://www.netbian.com" + href;Document document1 = Jsoup.connect(picUrl).get();Elements elements1 = document1.select(".endpage .pic p a img");//获取所有图片的链接System.out.println(elements1);} }} 在分类页中有一个隐藏的问题图片： 正常的图片链接都是以“/”开头，以“.htm”结尾，而每个分类下的第三张图片的链接都是“http://pic.netbian.com/”，如果不过滤的话会报如下错误： 所以这里必须要判断一下: Elements elements = document.select("main .list li a");for (Element element : elements) {String href = element.attr("href");//判断是否是以“/”开头if (href.startsWith("/")) {String picUrl = "http://www.netbian.com" + href;Document document1 = Jsoup.connect(picUrl).get();Elements elements1 = document1.select(".endpage .pic p a img");System.out.println(elements1);} } 到这里，页面就已经分析好了，问题基本上已经解决了，接下来我们需要将图片存到我们的系统里，这里我将图片保存到我的电脑桌面上，并按照分类来存储图片。 首先是要获取桌面路径，在utils包下创建Download类，添加getDesktop方法，代码如下： public static File getDesktop(){FileSystemView fsv = FileSystemView.getFileSystemView();File path=fsv.getHomeDirectory(); return path;} 接着我们再该类中添加下载图片的方法： //urlPath为网络图片的路径，savePath为要保存的本地路径（这里指定为桌面下的images文件夹）public static void download(String urlPath,String savePath) throws Exception {// 构造URLURL url = new URL(urlPath);// 打开连接URLConnection con = url.openConnection();//设置请求超时为5scon.setConnectTimeout(51000);// 输入流InputStream is = con.getInputStream();// 1K的数据缓冲byte[] bs = new byte[1024];// 读取到的数据长度int len;// 输出的文件流File sf=new File(savePath);int randomNo=(int)(Math.random()1000000);String filename=urlPath.substring(urlPath.lastIndexOf("/")+1,urlPath.length());//获取服务器上图片的名称filename=new java.text.SimpleDateFormat("yyyy-MM-dd-HH-mm-ss").format(new Date())+randomNo+filename;//时间+随机数防止重复OutputStream os = new FileOutputStream(sf.getPath()+"\\"+filename);// 开始读取while ((len = is.read(bs)) != -1) {os.write(bs, 0, len);}// 完毕，关闭所有链接os.close();is.close();} 写好后，我们再完善一下JsouPic中的getPic方法。 public static void getPic(String kind) throws Exception {//get请求方式进行请求Document root_doc = Jsoup.connect("http://www.netbian.com/" + kind + "/").get();//获取分页标签，用于获取总页数Elements els = root_doc.select("main .page a");Integer page = Integer.parseInt(els.eq(els.size() - 2).text());for (int i = 1; i < page; i++) {Document document = null;//这里判断的是当前页号是否为1，如果为1就不拼页号，否则拼上对应的页号if (i == 1) {document = Jsoup.connect("http://www.netbian.com/" + kind + "/index.htm").get();} else {document = Jsoup.connect("http://www.netbian.com/" + kind + "/index_" + i + ".htm").get();}File desktop = Download.getDesktop();Download.checkPath(desktop.getPath() + "\\images\\" + kind);//获取每个分页链接里面a标签的链接，进入链接页面获取当前图拼的大尺寸图片Elements elements = document.select("main .list li a");for (Element element : elements) {String href = element.attr("href");if (href.startsWith("/")) {String picUrl = "http://www.netbian.com" + href;Document document1 = Jsoup.connect(picUrl).get();Elements elements1 = document1.select(".endpage .pic p a img");Download.download(elements1.attr("src"), desktop.getPath() + "\\images\\" + kind);} }} } 在Download类中，我添加了checkPath方法，用于判断目录是否存在，不存在就创建一个。 public static void checkPath(String savePath) throws Exception {File file = new File(savePath);if (!file.exists()){file.mkdirs();} } 最后在mainapp包内创建PullPic类，并添加主方法。 package com.asahi.mainapp;import com.asahi.common.Kind;import com.asahi.common.PrintLog;import com.asahi.utils.JsoupPic;import java.util.Scanner;public class PullPic {public static void main(String[] args) throws Exception {new PullPic().downloadPic();}public void downloadPic() throws Exception {System.out.println("启动程序>>\n请输入所爬取的分类：");Scanner scanner = new Scanner(System.in);String kind = scanner.next();while(!Kind.contains(kind)){System.out.println("分类不存在，请重新输入：");kind = scanner.next();}System.out.println("分类输入正确！");System.out.println("开始下载>>");JsoupPic.getPic(kind);} } 三、成果展示 最终的运行结果如下： 最终的代码已上传到我的github中，点击“我的github”进行查看。 在学习Java爬虫的过程中，我收获了很多，一开始做的时候确实遇到了很多困难，这次写的获取图片也是最基础的，还可以继续深入。本来我想写一个通过多线程来获取图片来着，也尝试着去写了一下，越写越跑偏，暂时先放着不处理吧，等以后有时间再来弄，我想问题应该不大，只是考虑的东西有很多。希望大家多多指点不足，有哪些需要改进的地方，我也好多学习学习๑乛◡乛๑。 本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_39693281/article/details/108463868。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...我们，我们将第一时间进行核实并删除相应内容。 Proxy 、Relect、响应式 Proxy 、Relect、响应式 1. 监听对象的操作 2. Proxy基本使用 2.1 Proxy 的 set 和 get 捕获器 2.2 Proxy 所有捕获器 (13个) 2.3 Proxy 的 construct 和 apply 3. Reflect 3.1 Reflect 的作用 3.2 Reflect 的常见方法 3.3 Reflect 的使用 3.4 Receiver的作用 3.5 Reflect 的 construct 4. 响应式 4.1 什么是响应式？ 4.2 响应式函数设计 4.3 响应式依赖的收集 4.4 监听对象的变化 4.5 对象的依赖管理 4.6 对 Depend 重构 4.7 创建响应式对象 4.8 Vue2 响应式原理 Proxy 、Relect、响应式 1. 监听对象的操作 需求：有一个对象，我们希望监听这个对象中的属性被设置或获取的过程 可以通过属性描述符中的存储属性描述符来做到 这段代码就利用了 Object.defineProperty 的存储属性描述符来对属性的操作进行监听 const obj = {name: 'why',age: 18}Object.keys(obj).forEach((key) => {let value = obj[key]Object.defineProperty(obj, key, {get: function () {console.log(监听到obj对象的${key}属性被访问了)return value},set: function (newValue) {console.log(监听到obj对象的${key}属性被设置值)value = newValue} })})obj.name = 'kobe'obj.age = 30console.log(obj.name)console.log(obj.age)/ 监听到obj对象的name属性被设置值监听到obj对象的age属性被设置值监听到obj对象的name属性被访问了kobe监听到obj对象的age属性被访问了30/ 属性描述符监听对象的缺点： 首先，Object.defineProperty 设计的初衷，不是为了去监听截止一个对象中所有的属性的 我们在定义某些属性的时候，初衷其实是定义普通的属性，但是后面我们强行将它变成了数据属性描述符 其次，如果我们想监听更加丰富的操作，比如新增属性、删除属性，那么 Object.defineProperty 是无能为力的 所以我们要知道，存储数据描述符设计的初衷并不是为了去监听一个完整的对象 Ps: 原来的对象是 数据属性描述符，通过 Object.defineProperty 变成了 访问属性描述符 2. Proxy基本使用 在ES6中，新增了一个Proxy类，这个类从名字就可以看出来，是用于帮助我们创建一个代理的： 也就是说，如果我们希望监听一个对象的相关操作，那么我们可以先创建一个代理对象（Proxy对象） 之后对该对象的所有操作，都通过代理对象来完成，代理对象可以监听我们想要对原对象进行哪些操作 将上面的案例用 Proxy 来实现一次： 首先，我们需要 new Proxy 对象，并且传入需要侦听的对象以及一个处理对象，可以称之为 handler； const p = new Proxy(target, handler) 其次，我们之后的操作都是直接对 Proxy 的操作，而不是原有的对象，因为我们需要在 handler 里面进行侦听 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {// 获取值时的捕获器get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return target[key]},// 设置值时的捕获器set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)target[key] = newValue} })console.log(objProxy.name)console.log(objProxy.age)objProxy.name = 'kobe'objProxy.age = 30console.log(obj.name)console.log(obj.age)/ 监听到obj对象的name属性被访问了why监听到obj对象的age属性被访问了18监听到obj对象的name属性被设置值监听到obj对象的age属性被设置值kobe30/ 2.1 Proxy 的 set 和 get 捕获器 如果我们想要侦听某些具体的操作，那么就可以在 handler 中添加对应的捕捉器（Trap） set 和 get 分别对应的是函数类型 set 函数有四个参数： target：目标对象（侦听的对象） property：将被设置的属性 key value：新属性值 receiver：调用的代理对象 get 函数有三个参数 target：目标对象（侦听的对象） property：被获取的属性 key receiver：调用的代理对象 2.2 Proxy 所有捕获器 (13个) handler.getPrototypeOf() Object.getPrototypeOf 方法的捕捉器 handler.setPrototypeOf() Object.setPrototypeOf 方法的捕捉器 handler.isExtensible() Object.isExtensible 方法的捕捉器 handler.preventExtensions() Object.preventExtensions 方法的捕捉器 handler.getOwnPropertyDescriptor() Object.getOwnPropertyDescriptor 方法的捕捉器 handler.defineProperty() Object.defineProperty 方法的捕捉器 handler.ownKeys() Object.getOwnPropertyNames 方法和 Object.getOwnPropertySymbols 方法的捕捉器 handler.has() in 操作符的捕捉器 handler.get() 属性读取操作的捕捉器 handler.set() 属性设置操作的捕捉器 handler.deleteProperty() delete 操作符的捕捉器 handler.apply() 函数调用操作的捕捉器 handler.construct() new 操作符的捕捉器 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {// 获取值时的捕获器get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return target[key]},// 设置值时的捕获器set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)target[key] = newValue},// 监听 in 的捕获器has: function (target, key) {console.log(监听到obj对象的${key}属性的in操作)return key in target},// 监听 delete 的捕获器deleteProperty: function (target, key) {console.log(监听到obj对象的${key}属性的delete操作)delete target[key]} })// in 操作符console.log('name' in objProxy)// delete 操作delete objProxy.name/ 监听到obj对象的name属性的in操作true监听到obj对象的name属性的delete操作/ 2.3 Proxy 的 construct 和 apply 到捕捉器中还有 construct 和 apply，它们是应用于函数对象的 function foo() {console.log('调用了 foo')}const fooProxy = new Proxy(foo, {apply: function (target, thisArg, argArray) {console.log(对 foo 函数进行了 apply 调用)target.apply(thisArg, argArray)},construct: function (target, argArray, newTarget) {console.log(对 foo 函数进行了 new 调用)return new target(...argArray)} })fooProxy.apply({}, ['abc', 'cba'])new fooProxy('abc', 'cba')/ 对 foo 函数进行了 apply 调用调用了 foo对 foo 函数进行了 new 调用调用了 foo/ 3. Reflect 3.1 Reflect 的作用 Reflect 也是 ES6 新增的一个 API，它是一个对象，字面的意思是反射 Reflect 的作用： 它主要提供了很多操作 JavaScript 对象的方法，有点像 Object 中操作对象的方法 比如 Reflect.getPrototypeOf(target) 类似于 Object.getPrototypeOf() 比如 Reflect.defineProperty(target, propertyKey, attributes) 类似于 Object.defineProperty() 如果我们有 Object 可以做这些操作，那么为什么还需要有Reflect这样的新增对象呢？ 这是因为在早期的 ECMA 规范中没有考虑到这种对 对象本身 的操作如何设计会更加规范，所以将这些 API 放到了 Object上面 但是 Object 作为一个构造函数，这些操作实际上放到它身上并不合适 另外还包含一些类似于 in、delete 操作符，让 JS 看起来是会有一些奇怪的 所以在 ES6 中新增了 Reflect，让我们这些操作都集中到了 Reflect 对象上 那么 Object 和 Reflect 对象之间的 API 关系，可以参考 MDN 文档： 比较 Reflect 和 Object 方法 3.2 Reflect 的常见方法 Reflect中有哪些常见的方法呢？它和Proxy是一一对应的，也是13个 Reflect.getPrototypeOf(target) 类似于 Object.getPrototypeOf() Reflect.setPrototypeOf(target, prototype) 设置对象原型的函数. 返回一个 Boolean， 如果更新成功，则返回 true Reflect.isExtensible(target) 类似于 Object.isExtensible() Reflect.preventExtensions(target) 类似于 Object.preventExtensions() , 返回一个 Boolean Reflect.getOwnPropertyDescriptor(target, propertyKey) 类似于 Object.getOwnPropertyDescriptor() , 如果对象中存在该属性，则返回对应的属性描述符, 否则返回 undefined Reflect.defineProperty(target, propertyKey, attributes) 和 Object.defineProperty() 类似, 如果设置成功就会返回 true Reflect.ownKeys(target) 返回一个包含所有自身属性（不包含继承属性）的数组 （类似于 Object.keys(), 但不会受 enumerable 影响） Reflect.has(target, propertyKey) 判断一个对象是否存在某个属性，和 in 运算符 的功能完全相同 Reflect.get(target, propertyKey[, receiver]) 获取对象身上某个属性的值，类似于 target[name] Reflect.set(target, propertyKey, value[, receiver]) 将值分配给属性的函数，返回一个 Boolean，如果更新成功，则返回 true Reflect.deleteProperty(target, propertyKey) 作为函数的 delete 操作符，相当于执行 delete target[name] Reflect.apply(target, thisArgument, argumentsList) 对一个函数进行调用操作，同时可以传入一个数组作为调用参数。和 Function.prototype.apply() 功能类似 Reflect.construct(target, argumentsList[, newTarget]) 对构造函数进行 new 操作，相当于执行 new target(...args) 3.3 Reflect 的使用 那么我们可以将之前Proxy案例中对原对象的操作，都修改为Reflect来操作 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return Reflect.get(target, key)// return target[key] // 对原来对象进行了直接操作},set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)Reflect.set(target, key, newValue)// target[key] = newValue // 对原来对象进行了直接操作} })objProxy.name = 'kobe'console.log(objProxy.name)/ 监听到obj对象的name属性被设置值监听到obj对象的name属性被访问了kobe/ 3.4 Receiver的作用 我们发现在使用getter、setter的时候有一个receiver的参数，它的作用是什么呢？ 如果我们的源对象（obj）有 setter 、getter 的访问器属性，那么可以通过 receiver 来改变里面的 this const obj = {_name: 'why',get name() {return this._name // 不使用receiver, _name属性的操作不会被objProxy代理，因为this指向obj},set name(newValue) {this._name = newValue} }const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// receiver 是创建出来的代理对象console.log('get 方法被访问-------', key, receiver)console.log(objProxy === receiver) // truereturn Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)} })objProxy.name = 'kobe'console.log(objProxy.name) // kobe/ get 方法被访问------- name { _name: 'kobe', name: [Getter/Setter] }trueget 方法被访问------- _name { _name: 'kobe', name: [Getter/Setter] }truekobe/ 3.5 Reflect 的 construct function Student(name, age) {this.name = namethis.age = age}function Teacher() {}const stu = new Student('why', 18)console.log(stu)console.log(stu.__proto__ === Student.prototype)/ Student { name: 'why', age: 18 }true/// 执行 Student 函数中的内容，但是创建出来的对象是 Teacher 对象const teacher = Reflect.construct(Student, ['why', 18], Teacher)console.log(teacher)console.log(teacher.__proto__ === Teacher.prototype)/ Teacher { name: 'why', age: 18 }true/ 4. 响应式 4.1 什么是响应式？ 先来看一下响应式意味着什么？我们来看一段代码： m 有一个初始化的值，有一段代码使用了这个值； 那么在 m 有一个新的值时，这段代码可以自动重新执行 let m = 0// 一段代码console.log(m)console.log(m 2)console.log(m 2)m = 200 上面的这样一种可以自动响应数据变量的代码机制，我们就称之为是响应式的 对象的响应式 4.2 响应式函数设计 首先，执行的代码中可能不止一行代码，所以我们可以将这些代码放到一个函数中： 那么问题就变成了，当数据发生变化时，自动去执行某一个函数； 但是有一个问题：在开发中是有很多的函数的，如何区分一个函数需要响应式，还是不需要响应式呢？ 很明显，下面的函数中 foo 需要在 obj 的 name 发生变化时，重新执行，做出相应； bar 函数是一个完全独立于 obj 的函数，它不需要执行任何响应式的操作； // 对象的响应式const obj = {name: 'why',age: 18}function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)}function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe' // name 发生改变时候 foo 函数执行 响应式函数的实现 watchFn 如何区分响应式函数？ 这个时候我们封装一个新的函数 watchFn 凡是传入到 watchFn 的函数，就是需要响应式的 其他默认定义的函数都是不需要响应式的 / 封装一个响应式的函数 /let reactiveFns = []function watchFn(fn) {reactiveFns.push(fn)}// 对象的响应式const obj = {name: 'why',age: 18}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' // name 发生改变时候 foo 函数执行reactiveFns.forEach((fn) => {fn()}) 4.3 响应式依赖的收集 目前收集的依赖是放到一个数组中来保存的，但是这里会存在数据管理的问题： 在实际开发中需要监听很多对象的响应式 这些对象需要监听的不只是一个属性，它们很多属性的变化，都会有对应的响应式函数 不可能在全局维护一大堆的数组来保存这些响应函数 所以要设计一个类，这个类用于管理某一个对象的某一个属性的所有响应式函数： 相当于替代了原来的简单 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 线程池的错误用法 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. 结语 好了，今天的分享就到这里啦！并发编程确实是一项强大的技能，但也需要谨慎对待。大家看看今天这个例子，是不是觉得有点隐患啊？希望能引起大家的注意，也学着怎么避开这些坑，别踩雷了！ 最后，我想说的是，编程是一门艺术，也是一场冒险。每次遇到新挑战，我都觉得像打开一个神秘的盲盒，既兴奋又紧张。不过呢，光有好奇心还不够，还得有点儿耐心，就像种花一样，得一点点浇水施肥，不能急着看结果。相信只要我们不断学习、不断反思，就一定能写出更加优雅、高效的代码！ 祝大家编码愉快！

...升了处理海量数据时的性能表现。 此外，Google公司近期发布的关于Bloom Filter的新研究成果，揭示了一种新型布隆过滤器变体——Counting Bloom Filter with Carry Sketches（CBCS），能够在保持较低错误率的同时，更精准地统计大规模数据集中元素出现的次数，为解决海量数据判重问题提供了新的解决方案。 同时，针对分布式环境下数据存储与计算的需求，Hadoop生态系统的组件如HDFS和YARN也在持续演进中，以适应实时流处理、机器学习等新兴应用场景。而诸如Kafka、Flink等流处理框架的兴起，也为海量数据的实时分析提供了强大支持。 不仅如此，学术界对于Trie树、Bitmap等数据结构的研究也在不断深入，结合新型硬件如SSD、GPU等进行并行优化，使得这些经典数据结构在现代海量数据处理场景下焕发新生。未来，随着量子计算和边缘计算等前沿技术的发展，海量数据处理的方法将更加丰富多元，效率也将有质的飞跃。 综上所述，海量数据处理技术正以前所未有的速度发展和完善，从理论研究到工程实践，各类创新技术和解决方案层出不穷，为大数据时代的数据价值挖掘奠定了坚实基础。广大读者可以通过关注最新的科研成果、行业报告和技术博客，深入了解这一领域的发展趋势和应用案例，以便更好地应对和解决实际工作中的海量数据挑战。

...我们，我们将第一时间进行核实并删除相应内容。 s_msckf：采用多状态约束的双目vio系统 !!!注意imuCallback：接收IMU数据，将IMU数据存到imu_msg_buffer中，这里只会利用开头200帧IMU数据进行静止初始化，不做其他处理。featureCallback：接收双目特征，进行后端处理。利用IMU进行EKF Propagation，利用双目特征进行EKF Update。静止初始化(initializeGravityAndBias)：将前200帧加速度和角速度求平均, 平均加速度的模值g作为重力加速度, 平均角速度作为陀螺仪的bias, 计算重力向量(0,0,-g)和平均加速度之间的夹角(旋转四元数), 标定初始时刻IMU系与world系之间的夹角. 因此MSCKF要求前200帧IMU是静止不动的 sudo apt-get install libsuitesparse-devcd ~/catkin_ws/srcgit clone KumarRobotics/msckf_viocd ..catkin_make --pkg msckf_vio --cmake-args -DCMAKE_BUILD_TYPE=Release激活环境变量很关键source /devel/setup.bashroslaunch msckf_vio msckf_vio_euroc.launch注意文件路径rosrun rviz rviz -d rviz/rviz_euroc_config.rviz (改成你自己的rviz文件)rosbag play ~/data/euroc/MH_04_difficult.bag(改成你自己的rosbag文件) 可以看到，s_msckf的输出是没有轨迹的，可以增加如下脚本，将/odom存为/path，在rviz订阅即可可视化轨迹 脚本来自其issue：https://github.com/KumarRobotics/msckf_vio/issues/13 !/usr/bin/env pythonimport rospyfrom nav_msgs.msg import Odometry, Pathfrom geometry_msgs.msg import PoseStampedclass OdomToPath:def __init__(self):self.path_pub = rospy.Publisher('/slz_path', Path, latch=True, queue_size=10)self.odom_sub = rospy.Subscriber('/firefly_sbx/vio/odom', Odometry, self.odom_cb, queue_size=10)self.path = Path()def odom_cb(self, msg):cur_pose = PoseStamped()cur_pose.header = msg.headercur_pose.pose = msg.pose.poseself.path.header = msg.headerself.path.poses.append(cur_pose)self.path_pub.publish(self.path)if __name__ == '__main__':rospy.init_node('odom_to_path')odom_to_path = OdomToPath()rospy.spin() 或者增加一个draw_path的功能包： cpp为： include <stdio.h>include <stdlib.h>include <unistd.h>include <ros/ros.h>include <ros/console.h>include <nav_msgs/Path.h>include <std_msgs/String.h>include <nav_msgs/Odometry.h>include <geometry_msgs/Quaternion.h>include <geometry_msgs/PoseStamped.h>nav_msgs::Path path;ros::Publisher path_pub;ros::Subscriber odomSub;ros::Subscriber odom_raw_Sub;void odomCallback(const nav_msgs::Odometry::ConstPtr& odom){geometry_msgs::PoseStamped this_pose_stamped;this_pose_stamped.header= odom->header;this_pose_stamped.pose = odom->pose.pose;//this_pose_stamped.pose.position.x = odom->pose.pose.position.x;//this_pose_stamped.pose.position.y = odom->pose.pose.position.y;//this_pose_stamped.pose.orientation = odom->pose.pose.orientation;//this_pose_stamped.header.stamp = ros::Time::now();//this_pose_stamped.header.frame_id = "world";//frame_id 是消息中与数据相关联的参考系id，例如在在激光数据中，frame_id对应激光数据采集的参考系 path.header= this_pose_stamped.header;path.poses.push_back(this_pose_stamped);//path.header.stamp = ros::Time::now();//path.header.frame_id= "world";path_pub.publish(path);//printf("path_pub ");//printf("odom %.3lf %.3lf\n",odom->pose.pose.position.x,odom->pose.pose.position.y);}int main (int argc, char argv){ros::init (argc, argv, "showpath");ros::NodeHandle ph;path_pub = ph.advertise<nav_msgs::Path>("/trajectory",10, true);odomSub = ph.subscribe<nav_msgs::Odometry>("/firefly_sbx/vio/odom", 10, odomCallback);//ros::Rate loop_rate(50);while (ros::ok()){ros::spinOnce(); // check for incoming messages//loop_rate.sleep();}return 0;} cmakelists.txt cmake_minimum_required(VERSION 2.8.3)project(draw) Compile as C++11, supported in ROS Kinetic and newer add_compile_options(-std=c++11) Find catkin macros and libraries if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz) is used, also find other catkin packagesfind_package(catkin REQUIRED COMPONENTSgeometry_msgsroscpprospystd_msgsmessage_generation)catkin_package( INCLUDE_DIRS include LIBRARIES learning_communicationCATKIN_DEPENDS geometry_msgs roscpp rospy std_msgs message_runtime DEPENDS system_lib) Build include_directories(include${catkin_INCLUDE_DIRS})add_executable(draw_path draw.cpp)target_link_libraries(draw_path ${catkin_LIBRARIES}) package.xml <?xml version="1.0"?><package><name>draw</name><version>0.0.0</version><description>The learning_communication package</description><!-- One maintainer tag required, multiple allowed, one person per tag --><!-- Example: --><!-- <maintainer email="jane.doe@example.com">Jane Doe</maintainer> --><maintainer email="hcx@todo.todo">hcx</maintainer><!-- One license tag required, multiple allowed, one license per tag --><!-- Commonly used license strings: --><!-- BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1, LGPLv3 --><license>TODO</license><!-- Url tags are optional, but multiple are allowed, one per tag --><!-- Optional attribute type can be: website, bugtracker, or repository --><!-- Example: --><!-- <url type="website">http://wiki.ros.org/learning_communication</url> --><!-- Author tags are optional, multiple are allowed, one per tag --><!-- Authors do not have to be maintainers, but could be --><!-- Example: --><!-- <author email="jane.doe@example.com">Jane Doe</author> --><!-- The _depend tags are used to specify dependencies --><!-- Dependencies can be catkin packages or system dependencies --><!-- Examples: --><!-- Use build_depend for packages you need at compile time: --><!-- <build_depend>message_generation</build_depend> --><!-- Use buildtool_depend for build tool packages: --><!-- <buildtool_depend>catkin</buildtool_depend> --><!-- Use run_depend for packages you need at runtime: --><!-- <run_depend>message_runtime</run_depend> --><!-- Use test_depend for packages you need only for testing: --><!-- <test_depend>gtest</test_depend> --><buildtool_depend>catkin</buildtool_depend><build_depend>geometry_msgs</build_depend><build_depend>roscpp</build_depend><build_depend>rospy</build_depend><build_depend>std_msgs</build_depend><run_depend>geometry_msgs</run_depend><run_depend>roscpp</run_depend><run_depend>rospy</run_depend><run_depend>std_msgs</run_depend><build_depend>message_generation</build_depend><run_depend>message_runtime</run_depend><!-- The export tag contains other, unspecified, tags --><export><!-- Other tools can request additional information be placed here --></export></package> vins_fusion: 双目vio等多系统 mkdir -p vins-catkin_ws/srccd vins-catkin_ws/srcgit clone https://github.com/HKUST-Aerial-Robotics/VINS-Fusion.gitcd ..catkin_makesource devel/setup.bash按照readme 3.1 Monocualr camera + IMUroslaunch vins vins_rviz.launchrosrun vins vins_node ~/catkin_ws/src/VINS-Fusion/config/euroc/euroc_mono_imu_config.yaml (optional) rosrun loop_fusion loop_fusion_node ~/catkin_ws/src/VINS-Fusion/config/euroc/euroc_mono_imu_config.yaml rosbag play YOUR_DATASET_FOLDER/MH_01_easy.bag 3.2 Stereo cameras + IMUroslaunch vins vins_rviz.launchrosrun vins vins_node ~/catkin_ws/src/VINS-Fusion/config/euroc/euroc_stereo_imu_config.yaml (optional) rosrun loop_fusion loop_fusion_node ~/catkin_ws/src/VINS-Fusion/config/euroc/euroc_stereo_imu_config.yaml rosbag play YOUR_DATASET_FOLDER/MH_01_easy.bag 3.3 Stereo camerasroslaunch vins vins_rviz.launchrosrun vins vins_node ~/catkin_ws/src/VINS-Fusion/config/euroc/euroc_stereo_config.yaml (optional) rosrun loop_fusion loop_fusion_node ~/catkin_ws/src/VINS-Fusion/config/euroc/euroc_stereo_config.yaml rosbag play YOUR_DATASET_FOLDER/MH_01_easy.bag<img src="https://github.com/HKUST-Aerial-Robotics/VINS-Fusion/blob/master/support_files/image/euroc.gif" width = 430 height = 240 /> 4. KITTI Example 4.1 KITTI Odometry (Stereo)Download [KITTI Odometry dataset](http://www.cvlibs.net/datasets/kitti/eval_odometry.php) to YOUR_DATASET_FOLDER. Take sequences 00 for example,Open two terminals, run vins and rviz respectively. (We evaluated odometry on KITTI benchmark without loop closure funtion)roslaunch vins vins_rviz.launch(optional) rosrun loop_fusion loop_fusion_node ~/catkin_ws/src/VINS-Fusion/config/kitti_odom/kitti_config00-02.yamlrosrun vins kitti_odom_test ~/catkin_ws/src/VINS-Fusion/config/kitti_odom/kitti_config00-02.yaml YOUR_DATASET_FOLDER/sequences/00/ 4.2 KITTI GPS Fusion (Stereo + GPS)Download [KITTI raw dataset](http://www.cvlibs.net/datasets/kitti/raw_data.php) to YOUR_DATASET_FOLDER. Take [2011_10_03_drive_0027_synced](https://s3.eu-central-1.amazonaws.com/avg-kitti/raw_data/2011_10_03_drive_0027/2011_10_03_drive_0027_sync.zip) for example.Open three terminals, run vins, global fusion and rviz respectively. Green path is VIO odometry; blue path is odometry under GPS global fusion.roslaunch vins vins_rviz.launchrosrun vins kitti_gps_test ~/catkin_ws/src/VINS-Fusion/config/kitti_raw/kitti_10_03_config.yaml YOUR_DATASET_FOLDER/2011_10_03_drive_0027_sync/ rosrun global_fusion global_fusion_node<img src="https://github.com/HKUST-Aerial-Robotics/VINS-Fusion/blob/master/support_files/image/kitti.gif" width = 430 height = 240 /> 5. VINS-Fusion on car demonstrationDownload [car bag](https://drive.google.com/open?id=10t9H1u8pMGDOI6Q2w2uezEq5Ib-Z8tLz) to YOUR_DATASET_FOLDER.Open four terminals, run vins odometry, visual loop closure(optional), rviz and play the bag file respectively. Green path is VIO odometry; red path is odometry under visual loop closure.roslaunch vins vins_rviz.launchrosrun vins vins_node ~/catkin_ws/src/VINS-Fusion/config/vi_car/vi_car.yaml (optional) rosrun loop_fusion loop_fusion_node ~/catkin_ws/src/VINS-Fusion/config/vi_car/vi_car.yaml rosbag play YOUR_DATASET_FOLDER/car.bag 本篇文章为转载内容。原文链接：https://blog.csdn.net/slzlincent/article/details/104364909。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...我们，我们将第一时间进行核实并删除相应内容。 目录 效果 代码 SpringBoot Vue 效果 步骤 点击下载 在输入框输入下载的文件名称 点击暂停 再次点击开始 下载完成 代码 SpringBoot pom <!-- 做断点下载使用--><dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpcore</artifactId></dependency><dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpclient</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>commons-io</groupId><artifactId>commons-io</artifactId><version>2.8.0</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency> controller package com.kang.controller;import lombok.extern.slf4j.Slf4j;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.io.;import java.net.URLEncoder;import java.util.Optional;/ @Description 文件切片下载 @ClassName DownLoadController @Author 康世行 @Date 20:58 2023/2/22 @Version 1.0/@Controller@Slf4jpublic class DownLoadController {private final static String utf8 = "utf-8";@RequestMapping("/down")public void downLoadFile(HttpServletRequest request, HttpServletResponse response) throws IOException {// 设置编码格式response.setCharacterEncoding(utf8);//获取文件路径String fileName=request.getParameter("fileName");String drive=request.getParameter("drive");//参数校验log.info(fileName,drive);//完整路径(路径拼接待优化-前端传输优化-后端从新格式化 )String pathAll=drive+":\\"+fileName;log.info("pathAll{}",pathAll);Optional<String> pathFlag = Optional.ofNullable(pathAll);File file=null;if (pathFlag.isPresent()){//根据文件名，读取file流file = new File(pathAll);log.info("文件路径是{}",pathAll);if (!file.exists()){log.warn("文件不存在");return;} }else {//请输入文件名log.warn("请输入文件名！");return;}InputStream is = null;OutputStream os = null;try {//分片下载long fSize = file.length();//获取长度response.setContentType("application/x-download");String file_Name = URLEncoder.encode(file.getName(),"UTF-8");response.addHeader("Content-Disposition","attachment;filename="+fileName);//根据前端传来的Range 判断支不支持分片下载response.setHeader("Accept-Range","bytes");//获取文件大小//response.setHeader("fSize",String.valueOf(fSize));response.setHeader("fName",file_Name);//定义断点long pos = 0,last = fSize-1,sum = 0;//判断前端需不需要分片下载if (null != request.getHeader("Range")){response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);String numRange = request.getHeader("Range").replaceAll("bytes=","");String[] strRange = numRange.split("-");if (strRange.length == 2){pos = Long.parseLong(strRange[0].trim());last = Long.parseLong(strRange[1].trim());//若结束字节超出文件大小 取文件大小if (last>fSize-1){last = fSize-1;} }else {//若只给一个长度 开始位置一直到结束pos = Long.parseLong(numRange.replaceAll("-","").trim());} }long rangeLenght = last-pos+1;String contentRange = new StringBuffer("bytes").append(pos).append("-").append(last).append("/").append(fSize).toString();response.setHeader("Content-Range",contentRange);// response.setHeader("Content-Lenght",String.valueOf(rangeLenght));os = new BufferedOutputStream(response.getOutputStream());is = new BufferedInputStream(new FileInputStream(file));is.skip(pos);//跳过已读的文件(重点，跳过之前已经读过的文件)byte[] buffer = new byte[1024];int lenght = 0;//相等证明读完while (sum < rangeLenght){lenght = is.read(buffer,0, (rangeLenght-sum)<=buffer.length? (int) (rangeLenght - sum) :buffer.length);sum = sum+lenght;os.write(buffer,0,lenght);}log.info("下载完成");}finally {if (is!= null){is.close();}if (os!=null){os.close();} }} } 启动成功 Vue <html xmlns:th="http://www.thymeleaf.org"><head><meta charset="utf-8"/><title>狂神说Java-ES仿京东实战</title><link rel="stylesheet" th:href="@{/css/style.css}"/></head><body class="pg"><div class="page" id="app"><div id="mallPage" class=" mallist tmall- page-not-market "><!-- 头部搜索 --><div id="header" class=" header-list-app"><div class="headerLayout"><div class="headerCon "><!-- Logo--><h1 id="mallLogo"><img th:src="@{/images/jdlogo.png}" alt=""></h1><div class="header-extra"><!--搜索--><div id="mallSearch" class="mall-search"><form name="searchTop" class="mallSearch-form clearfix"><fieldset><legend>天猫搜索</legend><div class="mallSearch-input clearfix"><div class="s-combobox" id="s-combobox-685"><div class="s-combobox-input-wrap"><input v-model="keyword" type="text" autocomplete="off" value="java" id="mq"class="s-combobox-input" aria-haspopup="true"></div></div><button type="submit" @click.prevent="searchKey" id="searchbtn">搜索</button></div></fieldset></form><ul class="relKeyTop"><li><a>狂神说Java</a></li><li><a>狂神说前端</a></li><li><a>狂神说Linux</a></li><li><a>狂神说大数据</a></li><li><a>狂神聊理财</a></li></ul></div></div></div></div></div><el-button @click="download" id="download">下载</el-button><!-- <el-button @click="concurrenceDownload" >并发下载测试</el-button>--><el-button @click="stop">停止</el-button><el-button @click="start">开始</el-button>{ {fileFinalOffset} }{ {contentList} }<el-progress type="circle" :percentage="percentage"></el-progress></div><!--前端使用Vue，实现前后端分离--><script th:src="@{/js/axios.min.js}"></script><script th:src="@{/js/vue.min.js}"></script><!-- 引入样式 --><link rel="stylesheet" href="https://unpkg.com/element-ui/lib/theme-chalk/index.css"><!-- 引入组件库 --><script src="https://unpkg.com/element-ui/lib/index.js"></script><script>new Vue({ el: 'app',data: {keyword: '', //搜索关键字results: [] ,//搜索结果percentage: 0, // 下载进度filesCurrentPage:0,//文件开始偏移量fileFinalOffset:0, //文件最后偏移量stopRecursiveTags:true, //停止递归标签，默认是true 继续进行递归contentList: [], // 文件流数组breakpointResumeTags:false, //断点续传标签，默认是false 不进行断点续传temp:[],fileMap:new Map(),timer:null, //定时器名称},methods: {//根据关键字搜索商品信息searchKey(){var keyword=this.keyword;axios.get('/search/JD/search/'+keyword+"/1/10").then(res=>{this.results=res.data;//绑定数据console.log(this.results)console.table(this.results)})},//停止下载stop(){//改变递归标签为falsethis.stopRecursiveTags=false;},//开始下载start(){//重置递归标签为true 最后进行合并this.stopRecursiveTags=true;//重置断点续传标签this.breakpointResumeTags=true;//重新调用下载方法this.download();},// 分段下载需要后端配合download() {// 下载地址const url = "/down?fileName="+this.keyword.trim()+"&drive=E";console.log(url)const chunkSize = 1024 1024 50; // 单个分段大小，这里测试用100Mlet filesTotalSize = chunkSize; // 安装包总大小，默认100Mlet filesPages = 1; // 总共分几段下载//计算百分比之前先清空上次的if(this.percentage==100){this.percentage=0;}let sentAxios = (num) => {let rande = chunkSize;//判断是否开启了断点续传(断点续传没法并行-需要上次请求的结果作为参数)if (this.breakpointResumeTags){rande = ${Number(this.fileFinalOffset)+1}-${num chunkSize + 1};}else {if (num) {rande = ${(num - 1) chunkSize + 2}-${num chunkSize + 1};} else {// 第一次0-1方便获取总数，计算下载进度，每段下载字节范围区间rande = "0-1";} }let headers = {range: rande,};axios({method: "get",url: url.trim(),async: true,data: {},headers: headers,responseType: "blob"}).then((response) => {if (response.status == 200 || response.status == 206) {//检查了下才发现，后端对文件流做了一层封装，所以将content指向response.data即可const content = response.data;//截取文件总长度和最后偏移量let result= response.headers["content-range"].split("/");// 获取文件总大小，方便计算下载百分比filesTotalSize =result[1];//获取最后一片文件位置，用于断点续传this.fileFinalOffset=result[0].split("-")[1]// 计算总共页数，向上取整filesPages = Math.ceil(filesTotalSize / chunkSize);// 文件流数组this.contentList.push(content);// 递归获取文件数据(判断是否要继续递归)if (this.filesCurrentPage < filesPages&&this.stopRecursiveTags==true) {this.filesCurrentPage++;//计算下载百分比 当前下载的片数/总片数this.percentage=Number((this.contentList.length/filesPages)100).toFixed(2);sentAxios(this.filesCurrentPage);//结束递归return;}//递归标签为true 才进行下载if (this.stopRecursiveTags){// 文件名称const fileName =decodeURIComponent(response.headers["fname"]);//构造一个blob对象来处理数据const blob = new Blob(this.contentList);//对于<a>标签，只有 Firefox 和 Chrome（内核） 支持 download 属性//IE10以上支持blob但是依然不支持downloadif ("download" in document.createElement("a")) {//支持a标签download的浏览器const link = document.createElement("a"); //创建a标签link.download = fileName; //a标签添加属性link.style.display = "none";link.href = URL.createObjectURL(blob);document.body.appendChild(link);link.click(); //执行下载URL.revokeObjectURL(link.href); //释放urldocument.body.removeChild(link); //释放标签} else {//其他浏览器navigator.msSaveBlob(blob, fileName);} }} else {//调用暂停方法，记录当前下载位置console.log("下载失败")} }).catch(function (error) {console.log(error);});};// 第一次获取数据方便获取总数sentAxios(this.filesCurrentPage);this.$message({message: '文件开始下载！',type: 'success'});} }})</script></body></html> 本篇文章为转载内容。原文链接：https://blog.csdn.net/kangshihang1998/article/details/129407214。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...定了系统的容错能力和性能。其实啊，通常咱们都会建议弄三个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的学习之路还有很多内容需要探索，比如监控、调优、安全等等。其实我觉得啊，只要你把命名的规矩弄明白了，东西该怎么放也心里有数了，那你就算是走上正轨啦，成功嘛，它就已经在向你招手啦！加油吧，朋友们！ --- 希望这篇文章对你有所帮助，如果有任何疑问，欢迎随时交流哦！

...读可以从以下几个方向进行： 1. 最新GC算法进展：随着JDK版本的不断更新，Oracle和OpenJDK社区对垃圾收集器进行了持续优化。例如，最新的ZGC和Shenandoah GC采用了更为先进的内存管理技术，如颜色指针、读屏障等，以实现更低延迟的并发标记清理过程。关注这些前沿GC算法的研究与发展，可以更全面地了解现代JVM如何高效处理大规模堆内存引用关系。 2. G1垃圾收集器与RSet深入解读：G1作为当前HotSpot JVM推荐的默认垃圾收集器，其内部机制中除了卡表外，Remembered Set（RSet）也是关键组件。详细了解RSet如何辅助卡表追踪跨区域引用，以及分区并发压缩等特性，将有助于读者掌握G1高效回收内存的具体实现原理。 3. 实际生产环境案例分析：通过阅读一些大型互联网企业或开源社区分享的实战经验文章，了解他们在使用CMS、G1等垃圾收集器时如何针对特定业务场景调整卡表相关参数，解决实际遇到的性能瓶颈问题。比如，如何根据应用特点选择合适的卡表大小、调整扫描频率以平衡GC开销与应用响应时间。 4. 学术研究论文：查阅近年来关于垃圾收集器优化的学术论文，比如《A Study of the G1 Garbage Collector》、《The Z Garbage Collector》等，可深入了解卡表设计背后的理论依据，以及研究人员为提升GC效率所做的各种尝试和改进。 5. 官方文档及源码阅读：直接研读Oracle官方发布的Java SE HotSpot VM Garbage Collection Tuning Guide，以及JDK源码中的CardTableBarrierSet等相关类实现，可以更直观地把握卡表的具体工作流程和技术细节。同时，关注JDK开发团队的博客、邮件列表讨论等，获取第一手的更新信息和未来发展方向。