[数据类型兼容的相减运算 ]的搜索结果

...，二维数组是一种多维数据结构，用于存储表格形式的数据。在本文的上下文中，二维数组squareSet被用来存储消除类游戏中的方块信息，每个元素是一个子数组，代表一行方块，子数组中的每个元素则表示一个具体方块的信息，如颜色、行列位置等。通过使用二维数组，开发者能够方便地根据行列索引访问和操作每一个方块。 连通图算法 , 在计算机科学中，连通图算法是指处理图论问题的一种方法，通常用于确定图中的节点（或对象）是否通过边（或关系）彼此相连形成一个连通分量。在这篇文章中，作者应用了一个递归实现的连通图算法——checkLinked函数，当玩家鼠标移入某个方块时，该算法会遍历与其颜色相同的相邻方块，检查并收集所有可以消除的连通方块，以便进行后续的计分和动画效果展示。 定时器（Timer） , 定时器是浏览器提供的JavaScript特性之一，允许开发人员设置一段代码在特定时间间隔后执行。在这篇文章描述的游戏开发过程中，定时器被用来实现选中方块的闪烁特效。通过设置一个定时器（例如timer变量），每经过一定的时间间隔（如300毫秒），就改变选中方块的样式属性，使其产生连续的视觉变化，从而达到闪烁的效果。 绝对定位（Absolute Positioning） , 在CSS布局中，绝对定位是一种定位模式，它允许开发人员为元素指定精确的坐标值来决定其在页面上的确切位置，而不是遵循正常的文档流。文章中创建的小方块采用的就是绝对定位方式，确保它们可以根据行列位置准确地放置于游戏画布上，无论其他元素如何变化，这些方块的位置始终保持不变。

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

...被加载执行的用户进程数据段所对应的全局描述符号给显示到桌面上，上面代码执行后情况如下： 我们看到，在控制台中执行hlt命令后，内核加载了用户进程，同时在控制台下方输出了一个字符串，也就是0x1E,这个数值对应的就是当前运行用户进程其数据段对应的全局描述符号。一旦有这个信息之后，另一个进程就可以有机可乘了。 接着我们在本地目录创建一个新文件叫crack.c,其内容如下： void main() {char p = (char)0x123;p[0] = 'c';p[1] = 'r';p[2] = 'a';p[3] = 'c';p[4] = 'k';p[5] = 0;} 它的目的简单，就是针对内存地址0x123处写入字符串”crack”.接着我们修改一下makefile，使得内核编译时，能把crack.c编译成二进制文件： CFLAGS=-fno-stack-protectorckernel : ckernel_u.asm app_u.asm crack_u.asm cp ckernel_u.asm win_sheet.h win_sheet.c mem_util.h mem_util.c write_vga_desktop.c timer.c timer.h global_define.h global_define.c multi_task.c multi_task.h app_u.asm app.c crack_u.asm crack.c makefile '/media/psf/Home/Documents/操作系统/文档/19/OS-kernel-win-sheet/'ckernel_u.asm : ckernel.o....crack_u.asm : crack.o./objconv -fnasm crack.o crack_u.asmcrack.o : crack.cgcc -m32 -fno-stack-protector -fno-asynchronous-unwind-tables -s -c -o crack.o crack.c 然后我们在本地目录下，把api_call.asm拷贝一份，并命名为crack_call.asm,后者内容与前者完全相同，只不过稍微有那么一点点改变，例如： BITS 32mov AX, 30 8mov DS, axcall mainmov edx, 4 ;返回内核int 02Dh.... 这里需要注意，语句： mov AX, 30 8mov DS, ax 其中30对应的就是前面显示的0x1E，这两句汇编的作用是，把程序crack的数据段设置成下标为30的全局描述符所指向的内存段一致。这就意味着crack进程所使用的数据段就跟hlt启动的进程所使用的数据段一致了！于是在crack.c中，它对内存地址为0x123的地方写入字符串”crack”,那就意味着对hlt加载用户进程的内存空间写入对应字符串！ 完成上面代码后，我们在java项目中，增加代码，一是用来编译crack进程，而是把crack代码写入虚拟磁盘。在OperatingSystem.java中，将代码做如下添加： public void makeFllopy() {writeFileToFloppy("kernel.bat", false, 1, 1);....header = new FileHeader();header.setFileName("crack");header.setFileExt("exe");file = new File("crack.bat");in = null;try {in = new FileInputStream(file);long len = file.length();int count = 0;while (count < file.length()) {bbuf[count] = (byte) in.read();count++;}in.close();}catch(IOException e) {e.printStackTrace();return;}header.setFileContent(bbuf);fileSys.addHeader(header);....}public static void main(String[] args) {CKernelAsmPrecessor kernelPrecessor = new CKernelAsmPrecessor();kernelPrecessor.process();kernelPrecessor.createKernelBinary();CKernelAsmPrecessor appPrecessor = new CKernelAsmPrecessor("hlt.bat", "app_u.asm", "app.asm", "api_call.asm");appPrecessor.process();appPrecessor.createKernelBinary();CKernelAsmPrecessor crackPrecessor = new CKernelAsmPrecessor("crack.bat", "crack_u.asm", "crack.asm", "crack_call.asm");crackPrecessor.process();crackPrecessor.createKernelBinary();OperatingSystem op = new OperatingSystem("boot.bat");op.makeFllopy();} 在main函数中，我们把crack.c及其附属汇编文件结合在一起，编译成二进制文件crack.bat，在makeFllopy中，我们把编译后的crack.bat二进制数据读入，并把它写入到虚拟磁盘中，当系统运行起来后，可以把crack.bat二进制内容作为进程加载执行。 完成上面代码后，回到内核的C语言部分，也就是write_vga_desktop.c做一些修改，在kernel_api函数中，修改如下： int kernel_api(int edi, int esi, int ebp, int esp,int ebx, int edx, int ecx, int eax) {....else if (edx == 14) {sheet_free(shtctl, (struct SHEET)ebx);//change herecons_putstr((char)(task->pTaskBuffer->pDataSeg + 0x123));}....}void console_task(struct SHEET sheet, int memtotal) {....for(;;) {....else if (i == KEY_RETURN) {....else if (strcmp(cmdline, "crack") == 1) {cmd_execute_program("crack.exe");}....}....} 在kernel_api中，if(edx == 14)对应的api调用是api_closewin，也就是当用户进程关闭窗口时，我们把进程数据偏移0x123处的数据当做字符串打印到控制台窗口上，在console_task控制台进程主函数中，我们增加了对命令crack的响应，当用户在控制台上输入命令”crack”时，将crack代码加载到内核中运行。上面代码完成后，编译内核，然后用虚拟机将内核加载，系统启动后，我们现在一个控制台中输入hlt，先启动用户进程。然后点击”shift + w”,启动另一个控制台窗口，在其中输入crack，运行crack程序： 接着把点击tab键，把焦点恢复到窗口task_a，然后用鼠标点击运行hlt命令的窗口，把输入焦点切换到该控制台，然后再次点击tab键，把执行权限提交给运行hlt命令的控制台，此时点击回车，介绍用户进程启动的窗口，结果情况如下： 此时我们可以看到，运行hlt命令，执行用户进程的控制台窗口居然输出了字符串”crack”,而这个字符串正是crack.c在执行时，写入地址0x123的字符串。这就意味着一个恶意进程成功修改了另一个进程的内存数据，也相当于一个流氓程序把一只咸猪手伸到其他用户进程的裙底，蹂躏一番后留下了猥琐的证据。 那么如何防范恶意进程对其他程序的非法入侵呢，这就得使用CPU提供的LDT机制，也就是局部描述符表，该机制的使用，我们将在下一节详细讲解。更详细的讲解和代码演示调试，请参看视频： 更详细的讲解和代码调试演示过程，请参看视频 Linux kernel Hacker, 从零构建自己的内核 更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号： 本篇文章为转载内容。原文链接：https://blog.csdn.net/tyler_download/article/details/78731905。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...back：接收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。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...Spark，它可是大数据处理界的明星选手，性能强大，功能丰富。但即使是这么优秀的框架，有时候也会让我们头疼不已。 分布式缓存是Spark的一个重要特性，它的核心目标是减少重复计算，提升任务执行效率。简单来说，就是把一些频繁使用的数据放到内存里，供多个任务共享。听起来是不是很美好？但实际上，我在实际开发过程中遇到了不少麻烦。 比如有一次，我正在做一个数据分析项目，需要多次对同一份数据进行操作。我寻思着，这不就是常规操作嘛，直接用Spark的分布式缓存功能得了，这样岂不是能省掉好多重复加载的麻烦？嘿，事情是这样的——我辛辛苦苦搞完了任务，满怀期待地提交上去，结果发现这运行速度简直让人无语，不仅没达到预期的飞快效果，反而比啥缓存都不用的时候还慢！当时我就蒙圈了，心里直嘀咕：“卧槽，这是什么神仙操作？”没办法，只能硬着头皮一点点去查问题，最后才慢慢搞清楚了分布式缓存里到底藏着啥猫腻。 二、深入分析 为什么缓存反而变慢？ 经过一番折腾，我发现问题出在以下几个方面： 2.1 数据量太大导致内存不足 首先，大家要明白一点，Spark的分布式缓存本质上是将数据存储在集群节点的内存中。要是数据量太大，超出了单个节点能装下的内存容量，那就会把多余的数据写到磁盘上，这个过程叫“磁盘溢写”。但这样一来，任务的速度就会被拖慢，变得特别磨叽。 举个例子吧，假设你有一份1GB大小的数据集，而你的集群节点只有512MB的可用内存。你要是想把这份数据缓存起来，Spark会自己挑个序列化的方式给数据“打包”，顺便还能压一压体积。不过呢，就算是这样，还是有可能会出现溢写这种烦人的情况，挡都挡不住。唉，真是没想到啊，本来想靠着缓存省事儿提速呢，结果这操作反倒因为磁盘老是读写（频繁I/O）变得更卡了，简直跟开反向加速器似的！ 解决办法也很简单——要么增加节点的内存配置，要么减少需要缓存的数据规模。当然，这需要根据实际情况权衡利弊。 2.2 序列化方式的选择不当 另一个容易被忽视的问题是序列化方式的选择。Spark提供了多种序列化机制，包括JavaSerializer、KryoSerializer等。不同的序列化方式会影响数据的大小以及读取效率。 我曾经试过直接使用默认的JavaSerializer，结果发现性能非常差。后来改用了KryoSerializer之后，才明显感觉到速度有所提升。话说回来啊，用 KryoSerializer 的时候可别忘了先给所有要序列化的类都注册好，不然程序很可能就“翻车”报错啦！ java import org.apache.spark.serializer.KryoRegistrator; import com.esotericsoftware.kryo.Kryo; public class MyRegistrator implements KryoRegistrator { @Override public void registerClasses(Kryo kryo) { kryo.register(MyClass.class); // 注册其他需要序列化的类... } } 然后在SparkConf中设置： java SparkConf conf = new SparkConf(); conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer"); conf.set("spark.kryo.registrator", "MyRegistrator"); 2.3 缓存时机的选择失误 还有一个关键点在于缓存的时机。有些人一启动任务就赶紧给数据加上.cache()，觉得这样数据就能一直乖乖待在内存里，不用再费劲去读了。但实际上，这种做法并不总是最优解。 比如，在某些情况下，数据可能只会在特定阶段被频繁访问，而在其他阶段则很少用到。要是你提前把这部分数据缓存了，不光白白占用了宝贵的内存空间，搞不好后面真要用缓存的地方还找不到足够的空位呢！ 因此，合理规划缓存策略非常重要。比如说，在某个任务快开始了，你再随手调用一下.cache()这个方法，这样就能保证数据乖乖地待在内存里，别到时候卡壳啦！ 三、实践案例 如何正确使用分布式缓存？ 接下来，我想分享几个具体的案例，帮助大家更好地理解和运用分布式缓存。 案例1：简单的词频统计 假设我们有一个文本文件，里面包含了大量的英文单词。我们的目标是统计每个单词出现的次数。为了提高效率，我们可以先将文件内容缓存起来，然后再进行处理。 scala val textFile = sc.textFile("hdfs://path/to/input.txt") textFile.cache() val wordCounts = textFile.flatMap(_.split(" ")) .map(word => (word, 1)) .reduceByKey(_ + _) wordCounts.collect().foreach(println) 在这个例子中，.cache()方法确保了textFile RDD的内容只被加载一次，并且可以被后续的操作共享。其实嘛，要是没用缓存的话，每次你调用flatMap或者map的时候，都得重新去原始数据里翻一遍，这就跟每次出门都得把家里所有东西再检查一遍似的，纯属给自己找麻烦啊！ 案例2：多步骤处理流程 有时候，一个任务可能会涉及到多个阶段的处理，比如过滤、映射、聚合等等。在这种情况下，合理安排缓存的位置尤为重要。 python from pyspark.sql import SparkSession spark = SparkSession.builder.appName("WordCount").getOrCreate() df = spark.read.text("hdfs://path/to/input.txt") 第一步：将文本拆分为单词 words = df.selectExpr("split(value, ' ') as words").select("words.") 第二步：缓存中间结果 words.cache() 第三步：统计每个单词的出现次数 word_counts = words.groupBy("value").count() word_counts.show() 这里，我们在第一步处理完之后立即调用了.cache()方法，目的是为了保留中间结果，方便后续步骤复用。要是不这么干啊，那每走一步都得把上一步的算一遍，想想就费劲，效率肯定低得让人抓狂。 四、总结与展望 通过今天的讨论，相信大家对Spark的分布式缓存有了更深刻的认识。虽然它能带来显著的性能提升，但也并非万能药。其实啊，要想把它用得溜、用得爽，就得先搞懂它是怎么工作的，再根据具体的情况去灵活调整。不然的话，它的那些本事可就都浪费啦！ 未来，随着硬件条件的不断改善以及算法优化的持续推进，相信Spark会在更多领域展现出更加卓越的表现。嘿，咱们做开发的嘛，就得有颗永远好奇的心！就跟追剧似的，新技术一出就得赶紧瞅两眼，说不定哪天就用上了呢。别怕麻烦，多学点东西总没错，说不定哪天就能整出个大招儿来！ 最后，感谢大家耐心阅读这篇文章。如果你有任何疑问或者想法，欢迎随时交流！让我们一起努力，共同进步吧！

...;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。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...ch以及MXNet的兼容性，并且支持更多的硬件后端，包括GPU、CPU、ASIC和FPGA等。 此外，随着AI技术在边缘计算领域的快速发展，TVM在边缘设备上的应用也越来越受到关注。一项最新研究显示，通过TVM进行模型压缩和量化，能够在保持模型精度的同时，显著减少推理时延，有效提升了诸如自动驾驶、无人机监控等场景中边缘设备的实时处理能力。 对于希望深入了解TVM内部工作原理和技术细节的读者，推荐查阅其官方文档和论文《TVM: An Automated End-to-End Optimizing Compiler for Deep Learning》。该论文详细阐述了TVM的设计理念和关键技术，为开发者提供了理论基础和实践指导。同时，积极参与TVM社区的讨论和贡献，也是提升自己在深度学习编译器领域技能的重要途径。不少开发人员分享了他们在使用TVM过程中优化模型性能、解决实际问题的经验心得，这些内容均可在GitHub项目页面及相关的技术论坛中找到，值得深入研读和参考。

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

...太低。 ·借助额外的数据结构描述这种引用关系，例如使用类似位图（bitmap）的方法，记录A和B的内存块之间的引用关系，用一个位来描述一个字，假设在32位机器上（一个字为32位），需要32KB（32KB×32=1M）的空间来描述一个分区。那么我们就可以在这个对象ObjA所在分区A里面添加一个额外的指针，这个指针指向另外一个分区B的位图，如果我们可以把对象ObjA和指针关系进行映射，那么当访问ObjA的时候，顺便访问这个额外的指针，从这个指针指向的位图就能找到被ObjA引用的分区B对应的内存块。通常我们只需要判定位图里面对应的位是否有1，有的话则认为发生了引用。 class CardTable: public CHeapObj<mtGC> {friend class VMStructs;public:typedef uint8_t CardValue;// All code generators assume that the size of a card table entry is one byte.// They need to be updated to reflect any change to this.// This code can typically be found by searching for the byte_map_base() method.STATIC_ASSERT(sizeof(CardValue) == 1);protected:// The declaration order of these const fields is important; see the// constructor before changing.const MemRegion _whole_heap; // the region covered by the card tableconst size_t _page_size; // page size used when mapping _byte_mapsize_t _byte_map_size; // in bytesCardValue _byte_map; // the card marking arrayCardValue _byte_map_base;// Some barrier sets create tables whose elements correspond to parts of// the heap; the CardTableBarrierSet is an example. Such barrier sets will// normally reserve space for such tables, and commit parts of the table// "covering" parts of the heap that are committed. At most one covered// region per generation is needed.static constexpr int max_covered_regions = 2;// The covered regions should be in address order.MemRegion _covered[max_covered_regions];// The last card is a guard card; never committed.MemRegion _guard_region;inline size_t compute_byte_map_size(size_t num_bytes);enum CardValues {clean_card = (CardValue)-1,dirty_card = 0,CT_MR_BS_last_reserved = 1};// a word's worth (row) of clean card valuesstatic const intptr_t clean_card_row = (intptr_t)(-1);// CardTable entry sizestatic uint _card_shift;static uint _card_size;static uint _card_size_in_words;size_t last_valid_index() const {return cards_required(_whole_heap.word_size()) - 1;}private:void initialize_covered_region(void region0_start, void region1_start);MemRegion committed_for(const MemRegion mr) const;public:CardTable(MemRegion whole_heap);virtual ~CardTable() = default;void initialize(void region0_start, void region1_start);// Barrier set functions.// Initialization utilities; covered_words is the size of the covered region// in, um, words.inline size_t cards_required(size_t covered_words) const {assert(is_aligned(covered_words, _card_size_in_words), "precondition");return covered_words / _card_size_in_words;}// Dirty the bytes corresponding to "mr" (not all of which must be// covered.)void dirty_MemRegion(MemRegion mr);// Clear (to clean_card) the bytes entirely contained within "mr" (not// all of which must be covered.)void clear_MemRegion(MemRegion mr);// Return true if "p" is at the start of a card.bool is_card_aligned(HeapWord p) {CardValue pcard = byte_for(p);return (addr_for(pcard) == p);}// Mapping from address to card marking array entryCardValue byte_for(const void p) const {assert(_whole_heap.contains(p),"Attempt to access p = " PTR_FORMAT " out of bounds of "" card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")",p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end()));CardValue result = &_byte_map_base[uintptr_t(p) >> _card_shift];assert(result >= _byte_map && result < _byte_map + _byte_map_size,"out of bounds accessor for card marking array");return result;}// The card table byte one after the card marking array// entry for argument address. Typically used for higher bounds// for loops iterating through the card table.CardValue byte_after(const void p) const {return byte_for(p) + 1;}void invalidate(MemRegion mr);// Provide read-only access to the card table array.const CardValue byte_for_const(const void p) const {return byte_for(p);}const CardValue byte_after_const(const void p) const {return byte_after(p);}// Mapping from card marking array entry to address of first wordHeapWord addr_for(const CardValue p) const {assert(p >= _byte_map && p < _byte_map + _byte_map_size,"out of bounds access to card marking array. p: " PTR_FORMAT" _byte_map: " PTR_FORMAT " _byte_map + _byte_map_size: " PTR_FORMAT,p2i(p), p2i(_byte_map), p2i(_byte_map + _byte_map_size));// As _byte_map_base may be "negative" (the card table has been allocated before// the heap in memory), do not use pointer_delta() to avoid the assertion failure.size_t delta = p - _byte_map_base;HeapWord result = (HeapWord) (delta << _card_shift);assert(_whole_heap.contains(result),"Returning result = " PTR_FORMAT " out of bounds of "" card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")",p2i(result), p2i(_whole_heap.start()), p2i(_whole_heap.end()));return result;}// Mapping from address to card marking array index.size_t index_for(void p) {assert(_whole_heap.contains(p),"Attempt to access p = " PTR_FORMAT " out of bounds of "" card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")",p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end()));return byte_for(p) - _byte_map;}CardValue byte_for_index(const size_t card_index) const {return _byte_map + card_index;}// Resize one of the regions covered by the remembered set.void resize_covered_region(MemRegion new_region);// Card-table-RemSet-specific things.static uintx ct_max_alignment_constraint();static uint card_shift() {return _card_shift;}static uint card_size() {return _card_size;}static uint card_size_in_words() {return _card_size_in_words;}static constexpr CardValue clean_card_val() { return clean_card; }static constexpr CardValue dirty_card_val() { return dirty_card; }static intptr_t clean_card_row_val() { return clean_card_row; }// Initialize card sizestatic void initialize_card_size();// Card marking array base (adjusted for heap low boundary)// This would be the 0th element of _byte_map, if the heap started at 0x0.// But since the heap starts at some higher address, this points to somewhere// before the beginning of the actual _byte_map.CardValue byte_map_base() const { return _byte_map_base; }virtual bool is_in_young(const void p) const = 0;}; class G1CardTable : public CardTable {friend class VMStructs;friend class G1CardTableChangedListener;G1CardTableChangedListener _listener;public:enum G1CardValues {g1_young_gen = CT_MR_BS_last_reserved << 1,// During evacuation we use the card table to consolidate the cards we need to// scan for roots onto the card table from the various sources. Further it is// used to record already completely scanned cards to avoid re-scanning them// when incrementally evacuating the old gen regions of a collection set.// This means that already scanned cards should be preserved.//// The merge at the start of each evacuation round simply sets cards to dirty// that are clean; scanned cards are set to 0x1.//// This means that the LSB determines what to do with the card during evacuation// given the following possible values://// 11111111 - clean, do not scan// 00000001 - already scanned, do not scan// 00000000 - dirty, needs to be scanned.//g1_card_already_scanned = 0x1};static const size_t WordAllClean = SIZE_MAX;static const size_t WordAllDirty = 0;STATIC_ASSERT(BitsPerByte == 8);static const size_t WordAlreadyScanned = (SIZE_MAX / 255) g1_card_already_scanned;G1CardTable(MemRegion whole_heap): CardTable(whole_heap), _listener() {_listener.set_card_table(this);}static CardValue g1_young_card_val() { return g1_young_gen; }static CardValue g1_scanned_card_val() { return g1_card_already_scanned; }void verify_g1_young_region(MemRegion mr) PRODUCT_RETURN;void g1_mark_as_young(const MemRegion& mr);size_t index_for_cardvalue(CardValue const p) const {return pointer_delta(p, _byte_map, sizeof(CardValue));}// Mark the given card as Dirty if it is Clean. Returns whether the card was// Clean before this operation. This result may be inaccurate as it does not// perform the dirtying atomically.inline bool mark_clean_as_dirty(CardValue card);// Change Clean cards in a (large) area on the card table as Dirty, preserving// already scanned cards. Assumes that most cards in that area are Clean.inline void mark_range_dirty(size_t start_card_index, size_t num_cards);// Change the given range of dirty cards to "which". All of these cards must be Dirty.inline void change_dirty_cards_to(CardValue start_card, CardValue end_card, CardValue which);inline uint region_idx_for(CardValue p);static size_t compute_size(size_t mem_region_size_in_words) {size_t number_of_slots = (mem_region_size_in_words / _card_size_in_words);return ReservedSpace::allocation_align_size_up(number_of_slots);}// Returns how many bytes of the heap a single byte of the Card Table corresponds to.static size_t heap_map_factor() { return _card_size; }void initialize(G1RegionToSpaceMapper mapper);bool is_in_young(const void p) const override;}; 以位为粒度的位图能准确描述每一个字的引用关系，但是一个位通常包含的信息太少，只能描述2个状态：引用还是未引用。实际应用中JVM在垃圾回收的时候需要更多的状态，如果增加至一个字节来描述状态，则位图需要256KB的空间，这个数字太大，开销占了25%。所以一个可能的做法位图不再描述一个字，而是一个区域，JVM选择512字节为单位，即用一个字节描述512字节的引用关系。选择一个区域除了空间利用率的问题之外，实际上还有现实的意义。我们知道Java对象实际上不是一个字能描述的（有一个参数可以控制对象最小对齐的大小，默认是8字节，实际上Java在JVM中还有一些附加信息，所以对齐后最小的Java对象是16字节），很多Java对象可能是几十个字节或者几百个字节，所以用一个字节描述一个区域是有意义的。但是我没有找到512的来源，为什么512效果最好？没有相应的数据来支持这个数字，而且这个值不可以配置，不能修改，但是有理由相信512字节的区域是为了节约内存额外开销。按照这个值，1MB的内存只需要2KB的额外空间就能描述引用关系。这又带来另一个问题，就是512字节里面的内存可能被引用多次，所以这是一个粗略的关系描述，那么在使用的时候需要遍历这512字节。 再举一个例子，假设有两个对象B、C都在这512字节的区域内。为了方便处理，记录对象引用关系的时候，都使用对象的起始位置，然后用这个地址和512对齐，因此B和C对象的卡表指针都指向这一个卡表的位置。那么对于引用处理也有可有两种处理方法：·处理的时候会以堆分区为处理单位，遍历整个堆分区，在遍历的时候，每次都会以对象大小为步长，结合卡表，如果该卡表中对应的位置被设置，则说明对象和其他分区的对象发生了引用。具体内容在后文中介绍Refine的时候还会详细介绍。·处理的时候借助于额外的数据结构，找到真正对象的位置，而不需要从头开始遍历。在后文的并发标记处理时就使用了这种方法，用于找到第一个对象的起始位置。在G1除了512字节粒度的卡表之外，还有bitMap，例如使用bitMap可以描述一个分区对另外一个分区的引用情况。在JVM中bitMap使用非常多，例如还可以描述内存的分配情况。 在G1除了512字节粒度的卡表之外，还有bitMap，例如使用bitMap可以描述一个分区对另外一个分区的引用情况。在JVM中bitMap使用非常多，例如还可以描述内存的分配情况。G1在混合收集算法中用到了并发标记。在并发标记的时候使用了bitMap来描述对象的分配情况。例如1MB的分区可以用16KB（16KB×ObjectAlignmentInBytes×8=1MB）来描述，即16KB额外的空间。其中ObjectAlignmentInBytes是8字节，指的是对象对齐，第二个8是指一个字节有8位。即每一个位可以描述64位。例如一个对象长度对齐之后为24字节，理论上它占用3个位来描述这个24字节已被使用了，实际上并不需要，在标记的时候只需要标记这3个位中的第一个位，再结合堆分区对象的大小信息就能准确找出。其最主要的目的是为了效率，标记一个位和标记3个位相比能节约不少时间，如果对象很大，则更划算。这些都是源码的实现细节，大家在阅读源码时需要细细斟酌。 本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_16500963/article/details/132133125。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...定 JDBC 事务的数据源、全局作业和/或触发器侦听器、插件、线程池，以及更多）配置 Quartz，但它根本没有与应用程序服务器的上下文或引用集成在一起。结果就是作业不能访问 Web 服务器的内部函数；例如，在使用 WebSphere 应用服务器时，由 Quartz 调度的作业并不能影响服务器的动态缓存和数据源。 二、java中实现定时任务分类 从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）： Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少，这篇文章将不做详细介绍。 使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。 Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。 从作业类的继承方式来讲，可以分为两类： 作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheduling.quartz.QuartzJobBean；java.util.Timer中需要继承自java.util.TimerTask。 作业类即普通的java类，不需要继承自任何基类。 注:个人推荐使用第二种方式，因为这样所以的类都是普通类，不需要事先区别对待。 从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种： 每隔指定时间则触发一次，在Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerBean 每到指定时间则触发一次，在Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerBean 注：并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。Quartz和spring task都可以支持这两种触发条件。 三、Quartz与Spring的集成 第一种，作业类继承自特定的基类：org.springframework.scheduling.quartz.QuartzJobBean。 第一步：定义作业类 Java代码 import org.quartz.JobExecutionContext; import org.quartz.JobExecutionException; import org.springframework.scheduling.quartz.QuartzJobBean; public class Job1 extends QuartzJobBean { private int timeout; private static int i = 0; //调度工厂实例化后，经过timeout时间开始执行调度 public void setTimeout(int timeout) { this.timeout = timeout; } / 要调度的具体任务 / @Override protected void executeInternal(JobExecutionContext context) throws JobExecutionException { System.out.println("定时任务执行中…"); } } 第二步：spring配置文件中配置作业类JobDetailBean Xml代码 <bean name="job1" class="org.springframework.scheduling.quartz.JobDetailBean"> <property name="jobClass" value="com.gy.Job1" /> <property name="jobDataAsMap"> <map> <entry key="timeout" value="0" /> </map> </property> </bean> 说明：org.springframework.scheduling.quartz.JobDetailBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAsMap属性即该任务类中需要注入的属性值。 第三步：配置作业调度的触发方式（触发器） Quartz的作业触发器有两种，分别是 org.springframework.scheduling.quartz.SimpleTriggerBean org.springframework.scheduling.quartz.CronTriggerBean 第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。 配置方式如下： Xml代码 <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"> <property name="jobDetail" ref="job1" /> <property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 --> <property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 --> </bean> 第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。 配置方式如下： Xml代码 <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail" ref="job1" /> <!—每天12:00运行一次 --> <property name="cronExpression" value="0 0 12 ?" /> </bean> 关于cronExpression表达式的语法参见附录。 第四步：配置调度工厂 Xml代码 <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"> <list> <ref bean="cronTrigger" /> </list> </property> </bean> 说明：该参数指定的就是之前配置的触发器的名字。 第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。 第二种，作业类不继承特定基类。 Spring能够支持这种方式，归功于两个类： org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean 这两个类分别对应spring支持的两种实现任务调度的方式，即前文提到到java自带的timer task方式和Quartz方式。这里我只写MethodInvokingJobDetailFactoryBean的用法，使用该类的好处是,我们的任务类不再需要继承自任何类，而是普通的pojo。 第一步：编写任务类 Java代码 public class Job2 { public void doJob2() { System.out.println("不继承QuartzJobBean方式-调度进行中..."); } } 可以看出，这就是一个普通的类，并且有一个方法。 第二步：配置作业类 Xml代码 <bean id="job2" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> <property name="targetObject"> <bean class="com.gy.Job2" /> </property> <property name="targetMethod" value="doJob2" /> <property name="concurrent" value="false" /><!-- 作业不并发调度 --> </bean> 说明：这一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属性：targetObject指定任务类，targetMethod指定运行的方法。往下的步骤就与方法一相同了，为了完整，同样贴出。 第三步：配置作业调度的触发方式（触发器） Quartz的作业触发器有两种，分别是 org.springframework.scheduling.quartz.SimpleTriggerBean org.springframework.scheduling.quartz.CronTriggerBean 第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。 配置方式如下： Xml代码 <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"> <property name="jobDetail" ref="job2" /> <property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 --> <property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 --> </bean> 第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。 配置方式如下： Xml代码 <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail" ref="job2" /> <!—每天12:00运行一次 --> <property name="cronExpression" value="0 0 12 ?" /> </bean> 以上两种调度方式根据实际情况，任选一种即可。 第四步：配置调度工厂 Xml代码 <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"> <list> <ref bean="cronTrigger" /> </list> </property> </bean> 说明：该参数指定的就是之前配置的触发器的名字。 第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。 到此，spring中Quartz的基本配置就介绍完了，当然了，使用之前，要导入相应的spring的包与Quartz的包，这些就不消多说了。 其实可以看出Quartz的配置看上去还是挺复杂的，没有办法，因为Quartz其实是个重量级的工具，如果我们只是想简单的执行几个简单的定时任务，有没有更简单的工具，有！ 四、Spring-Task 上节介绍了在Spring 中使用Quartz，本文介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种 形式，下面将分别介绍这两种方式。 第一种：配置文件方式 第一步：编写作业类 即普通的pojo，如下： Java代码 import org.springframework.stereotype.Service; @Service public class TaskJob { public void job1() { System.out.println(“任务进行中。。。”); } } 第二步：在spring配置文件头中添加命名空间及描述 Xml代码 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:task="http://www.springframework.org/schema/task" 。。。。。。 xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"> 第三步：spring配置文件中设置具体的任务 Xml代码 <task:scheduled-tasks> <task:scheduled ref="taskJob" method="job1" cron="0 ?"/> </task:scheduled-tasks> <context:component-scan base-package=" com.gy.mytask " /> 说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法这里不介绍了，详情见上篇文章附录。 <context:component-scan base-package="com.gy.mytask" />这个配置不消多说了，spring扫描注解用的。 到这里配置就完成了，是不是很简单。 第二种：使用注解形式 也许我们不想每写一个任务类还要在xml文件中配置下，我们可以使用注解@Scheduled，我们看看源文件中该注解的定义： Java代码 @Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Scheduled { public abstract String cron(); public abstract long fixedDelay(); public abstract long fixedRate(); } 可以看出该注解有三个方法或者叫参数，分别表示的意思是： cron：指定cron表达式 fixedDelay：官方文档解释：An interval-based trigger where the interval is measured from the completion time of the previous task. The time unit value is measured in milliseconds.即表示从上一个任务完成开始到下一个任务开始的间隔，单位是毫秒。 fixedRate：官方文档解释：An interval-based trigger where the interval is measured from the start time of the previous task. The time unit value is measured in milliseconds.即从上一个任务开始到下一个任务开始的间隔，单位是毫秒。 下面我来配置一下。 第一步：编写pojo Java代码 import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; @Component(“taskJob”) public class TaskJob { @Scheduled(cron = "0 0 3 ?") public void job1() { System.out.println(“任务进行中。。。”); } } 第二步：添加task相关的配置： Xml代码 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd" default-lazy-init="false"> <context:annotation-config /> <!—spring扫描注解的配置 --> <context:component-scan base-package="com.gy.mytask" /> <!—开启这个配置，spring才能识别@Scheduled注解 --> <task:annotation-driven scheduler="qbScheduler" mode="proxy"/> <task:scheduler id="qbScheduler" pool-size="10"/> 说明：理论上只需要加上<task:annotation-driven />这句配置就可以了，这些参数都不是必须的。 Ok配置完毕，当然spring task还有很多参数，我就不一一解释了，具体参考xsd文档http://www.springframework.org/schema/task/spring-task-3.0.xsd。 附录： cronExpression的配置说明，具体使用以及参数请百度google 字段 允许值 允许的特殊字符 秒 0-59 , - / 分 0-59 , - / 小时 0-23 , - / 日期 1-31 , - ? / L W C 月份 1-12 或者 JAN-DEC , - / 星期 1-7 或者 SUN-SAT , - ? / L C 年（可选） 留空, 1970-2099 , - / - 区间 通配符 ? 你不想设置那个字段 下面只例出几个式子 CRON表达式 含义 "0 0 12 ?" 每天中午十二点触发 "0 15 10 ? " 每天早上10：15触发 "0 15 10 ?" 每天早上10：15触发 "0 15 10 ? " 每天早上10：15触发 "0 15 10 ? 2005" 2005年的每天早上10：15触发 "0 14 ?" 每天从下午2点开始到2点59分每分钟一次触发 "0 0/5 14 ?" 每天从下午2点开始到2：55分结束每5分钟一次触发 "0 0/5 14,18 ?" 每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发 "0 0-5 14 ?" 每天14:00至14:05每分钟一次触发 "0 10,44 14 ? 3 WED" 三月的每周三的14：10和14：44触发 "0 15 10 ? MON-FRI" 每个周一、周二、周三、周四、周五的10：15触发 Cron 表达式包括以下 7 个字段： 秒 分 小时 月内日期 月 周内日期 年（可选字段） 特殊字符 Cron 触发器利用一系列特殊字符，如下所示： 反斜线（/）字符表示增量值。例如，在秒字段中“5/15”代表从第 5 秒开始，每 15 秒一次。 问号（?）字符和字母 L 字符只有在月内日期和周内日期字段中可用。问号表示这个字段不包含具体值。所以，如果指定月内日期，可以在周内日期字段中插入“?”，表示周内日期值无关紧要。字母 L 字符是 last 的缩写。放在月内日期字段中，表示安排在当月最后一天执行。在周内日期字段中，如果“L”单独存在，就等于“7”，否则代表当月内周内日期的最后一个实例。所以“0L”表示安排在当月的最后一个星期日执行。 在月内日期字段中的字母（W）字符把执行安排在最靠近指定值的工作日。把“1W”放在月内日期字段中，表示把执行安排在当月的第一个工作日内。 井号（）字符为给定月份指定具体的工作日实例。把“MON2”放在周内日期字段中，表示把任务安排在当月的第二个星期一。 星号（）字符是通配字符，表示该字段可以接受任何可能的值。 字段 允许值 允许的特殊字符 秒 0-59 , - / 分 0-59 , - / 小时 0-23 , - / 日期 1-31 , - ? / L W C 月份 1-12 或者 JAN-DEC , - / 星期 1-7 或者 SUN-SAT , - ? / L C 年（可选） 留空, 1970-2099 , - / 表达式意义 "0 0 12 ?" 每天中午12点触发 "0 15 10 ? " 每天上午10:15触发 "0 15 10 ?" 每天上午10:15触发 "0 15 10 ? " 每天上午10:15触发 "0 15 10 ? 2005" 2005年的每天上午10:15触发 "0 14 ?" 在每天下午2点到下午2:59期间的每1分钟触发 "0 0/5 14 ?" 在每天下午2点到下午2:55期间的每5分钟触发 "0 0/5 14,18 ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发 "0 0-5 14 ?" 在每天下午2点到下午2:05期间的每1分钟触发 "0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发 "0 15 10 ? MON-FRI" 周一至周五的上午10:15触发 "0 15 10 15 ?" 每月15日上午10:15触发 "0 15 10 L ?" 每月最后一日的上午10:15触发 "0 15 10 ? 6L" 每月的最后一个星期五上午10:15触发 "0 15 10 ? 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发 "0 15 10 ? 63" 每月的第三个星期五上午10:15触发 每天早上6点 0 6 每两个小时 0 /2 晚上11点到早上8点之间每两个小时，早上八点 0 23-7/2，8 每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点 0 11 4 1-3 1月1日早上4点 0 4 1 1 本篇文章为转载内容。原文链接：https://zhanghaiyang.blog.csdn.net/article/details/51397459。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...PR等相关法规对用户数据处理提出了严格要求，这也促使各平台在设计头像上传功能时，必须兼顾到用户信息的安全存储与传输。众多企业开始采用加密上传、权限控制等手段，确保用户头像数据的安全性。 综上所述，在当前互联网环境下，用户头像处理技术正不断迭代创新，以满足日益增长的个性化需求和严格的隐私保护规范。无论是大型社交平台的技术突破，还是各类开发框架对头像上传功能的优化改进，都为我们提供了丰富的实践案例与参考思路，值得广大开发者持续关注并深入研究。

...目录（历史）（镜像元数据、传输大小等） 镜像更新：official-images repo 的 library/mysql 标签 官方图像 repo 的库/mysql 文件（历史） 此描述的来源：docs repo 的 mysql/ 目录（历史） 2.4. 如何使用镜像 2.4.1. 启动一个mysql服务器实例 启动 MySQL 实例很简单： $ docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag 其中 some-mysql 是您要分配给容器的名称， my-secret-pw 是要为 MySQL root 用户设置的密码，而 tag 是指定您想要的 MySQL 版本的标签。 有关相关标签，请参见上面的列表。 以下是示例（通常要设置时区），注意-v 这里是挂载磁盘，请提前创建目录/var/mysql/data，/var/lib/mysql是容器里的原持久化目录： docker run --name mysql202201 -e MYSQL_ROOT_PASSWORD=123456 -e TZ=Asia/Shanghai -v /var/mysql/data:/var/lib/mysql -d mysql:5.7 2.4.2. 从 MySQL 命令行客户端连接到 MySQL 以下命令启动另一个 mysql 容器实例并针对您的原始 mysql 容器运行 mysql 命令行客户端，允许您针对您的数据库实例执行 SQL 语句： $ docker run -it --network some-network --rm mysql mysql -hsome-mysql -uexample-user -p 其中 some-mysql 是原始 mysql 容器的名称（连接到 some-network Docker 网络）。 此镜像也可以用作非 Docker 或远程实例的客户端： $ docker run -it --rm mysql mysql -hsome.mysql.host -usome-mysql-user -p 有关 MySQL 命令行客户端的更多信息，请参阅 MySQL 文档。 2.4.3. 容器外访问和查看 MySQL 日志 docker exec 命令允许您在 Docker 容器内运行命令。 以下命令行将为您提供 mysql 容器内的 bash shell： $ docker exec -it some-mysql bash 第一次启动一个MySQL容器后，需要对账户进行授权，否则无法远程访问，请先使用上面的命令进入容器内，然后使用以下命令连接到mysql服务： mysql -uroot -p 输入密码回车，进入mysql命令界面mysql> 接着授权root远程访问权限： mysql> GRANT ALL PRIVILEGES ON . TO 'root'@'%' IDENTIFIED BY '123456'; 然后就可以远程用MySQL客户端连接到MySQL容器了。 日志可通过 Docker 的容器日志获得： $ docker logs some-mysql 2.4.4. 使用自定义 MySQL 配置文件 MySQL 的默认配置可以在 /etc/mysql/my.cnf 中找到，其中可能包含额外的目录，例如 /etc/mysql/conf.d 或 /etc/mysql/mysql.conf.d。 请检查 mysql 映像本身中的相关文件和目录以获取更多详细信息。 如果 /my/custom/config-file.cnf 是你的自定义配置文件的路径和名称，你可以这样启动你的 mysql 容器（注意这个命令只使用了自定义配置文件的目录路径）： $ docker run --name some-mysql -v /my/custom:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag 这将启动一个新容器 some-mysql，其中 MySQL 实例使用来自 /etc/mysql/my.cnf 和 /etc/mysql/conf.d/config-file.cnf 的组合启动设置，后者的设置优先 . 没有 cnf 文件的配置 许多配置选项可以作为标志传递给 mysqld。 这将使您可以灵活地自定义容器，而无需 cnf 文件。 例如，如果要将所有表的默认编码和排序规则更改为使用 UTF-8 (utf8mb4)，只需运行以下命令： $ docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci 如果您想查看可用选项的完整列表，只需运行： $ docker run -it --rm mysql:tag --verbose --help 2.4.5. 环境变量 启动 mysql 镜像时，可以通过在 docker run 命令行中传递一个或多个环境变量来调整 MySQL 实例的配置。 请注意，如果您使用已包含数据库的数据目录启动容器，则以下任何变量都不会产生任何影响：任何预先存在的数据库在容器启动时将始终保持不变。 另请参阅 https://dev.mysql.com/doc/refman/5.7/en/environment-variables.html 以获取 MySQL 的环境变量的文档（尤其是 MYSQL_HOST 等变量，已知与此镜像一起使用时会导致问题）。 MYSQL_ROOT_PASSWORD 此变量是必需的，并指定将为 MySQL root 超级用户帐户设置的密码。 在上面的示例中，它被设置为 my-secret-pw。 MYSQL_DATABASE 此变量是可选的，允许您指定要在映像启动时创建的数据库的名称。 如果提供了用户/密码（见下文），则该用户将被授予对此数据库的超级用户访问权限（对应于 GRANT ALL）。 MYSQL_USER、MYSQL_PASSWORD 这些变量是可选的，用于创建新用户和设置该用户的密码。 该用户将被授予对 MYSQL_DATABASE 变量指定的数据库的超级用户权限（见上文）。 要创建用户，这两个变量都是必需的。 请注意，不需要使用此机制来创建超级用户超级用户，默认情况下会使用 MYSQL_ROOT_PASSWORD 变量指定的密码创建该用户。 MYSQL_ALLOW_EMPTY_PASSWORD 这是一个可选变量。 设置为非空值，例如 yes，以允许使用 root 用户的空白密码启动容器。 注意：除非您真的知道自己在做什么，否则不建议将此变量设置为 yes，因为这将使您的 MySQL 实例完全不受保护，从而允许任何人获得完全的超级用户访问权限。 MYSQL_RANDOM_ROOT_PASSWORD 这是一个可选变量。 设置为非空值，如 yes，为 root 用户生成随机初始密码（使用 pwgen）。 生成的根密码将打印到标准输出（生成的根密码：…）。 MYSQL_ONETIME_PASSWORD 一旦初始化完成，将 root（不是 MYSQL_USER 中指定的用户！）用户设置为过期，强制在第一次登录时更改密码。 任何非空值都将激活此设置。 注意：此功能仅在 MySQL 5.6+ 上受支持。 在 MySQL 5.5 上使用此选项将在初始化期间引发适当的错误。 MYSQL_INITDB_SKIP_TZINFO 默认情况下，入口点脚本会自动加载 CONVERT_TZ() 函数所需的时区数据。 如果不需要，任何非空值都会禁用时区加载。 2.4.6. Docker Secrets 作为通过环境变量传递敏感信息的替代方法，_FILE 可以附加到先前列出的环境变量中，从而导致初始化脚本从容器中存在的文件中加载这些变量的值。 特别是，这可用于从存储在 /run/secrets/<secret_name> 文件中的 Docker 机密中加载密码。 例如： $ docker run --name some-mysql -e MYSQL_ROOT_PASSWORD_FILE=/run/secrets/mysql-root -d mysql:tag 目前，这仅支持 MYSQL_ROOT_PASSWORD、MYSQL_ROOT_HOST、MYSQL_DATABASE、MYSQL_USER和 MYSQL_PASSWORD。 2.4.7. 初始化一个新实例 首次启动容器时，将使用提供的配置变量创建并初始化具有指定名称的新数据库。 此外，它将执行 /docker-entrypoint-initdb.d 中的扩展名为 .sh、.sql 和 .sql.gz 的文件。 文件将按字母顺序执行。 您可以通过将 SQL 转储安装到该目录并提供带有贡献数据的自定义镜像来轻松填充您的 mysql 服务。 SQL 文件将默认导入到 MYSQL_DATABASE 变量指定的数据库中。 2.5. 注意事项 2.5.1. 在哪里存储数据 重要提示：有几种方法可以存储在 Docker 容器中运行的应用程序使用的数据。 我们鼓励 mysql 映像的用户熟悉可用的选项，包括： 让 Docker 通过使用自己的内部卷管理将数据库文件写入主机系统上的磁盘来管理数据库数据的存储。 这是默认设置，对用户来说简单且相当透明。 缺点是对于直接在主机系统（即外部容器）上运行的工具和应用程序，可能很难找到这些文件。 在主机系统（容器外部）上创建一个数据目录，并将其挂载到容器内部可见的目录。 这会将数据库文件放置在主机系统上的已知位置，并使主机系统上的工具和应用程序可以轻松访问这些文件。 缺点是用户需要确保目录存在，例如主机系统上的目录权限和其他安全机制设置正确。 Docker 文档是了解不同存储选项和变体的一个很好的起点，并且有多个博客和论坛帖子在该领域讨论和提供建议。 我们将在这里简单地展示上面后一个选项的基本过程： 在主机系统上的合适卷上创建数据目录，例如 /my/own/datadir。 像这样启动你的 mysql 容器： $ docker run --name some-mysql -v /my/own/datadir:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag 命令的 -v /my/own/datadir:/var/lib/mysql 部分将底层主机系统中的 /my/own/datadir 目录挂载为容器内的 /var/lib/mysql ，默认情况下 MySQL 将 写入其数据文件。 2.5.2. 在 MySQL 初始化完成之前没有连接 如果容器启动时没有初始化数据库，则会创建一个默认数据库。 虽然这是预期的行为，但这意味着在初始化完成之前它不会接受传入的连接。 在使用同时启动多个容器的自动化工具（例如 docker-compose）时，这可能会导致问题。 如果您尝试连接到 MySQL 的应用程序没有处理 MySQL 停机时间或等待 MySQL 正常启动，那么在服务启动之前放置一个连接重试循环可能是必要的。 有关官方图像中此类实现的示例，请参阅 WordPress 或 Bonita。 2.5.3. 针对现有数据库的使用 如果您使用已经包含数据库的数据目录（特别是 mysql 子目录）启动 mysql 容器实例，则应该从运行命令行中省略 $MYSQL_ROOT_PASSWORD 变量； 在任何情况下都将被忽略，并且不会以任何方式更改预先存在的数据库。 2.5.4. 以任意用户身份运行 如果你知道你的目录的权限已经被适当地设置了（例如对一个现有的数据库运行，如上所述）或者你需要使用特定的 UID/GID 运行 mysqld，那么可以使用 --user 调用这个镜像设置为任何值（root/0 除外）以实现所需的访问/配置： $ mkdir data$ ls -lnd datadrwxr-xr-x 2 1000 1000 4096 Aug 27 15:54 data$ docker run -v "$PWD/data":/var/lib/mysql --user 1000:1000 --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag 2.5.5. 创建数据库转储 大多数普通工具都可以工作，尽管在某些情况下它们的使用可能有点复杂，以确保它们可以访问 mysqld 服务器。 确保这一点的一种简单方法是使用 docker exec 并从同一容器运行该工具，类似于以下内容： $ docker exec some-mysql sh -c 'exec mysqldump --all-databases -uroot -p"$MYSQL_ROOT_PASSWORD"' > /some/path/on/your/host/all-databases.sql 2.5.6. 从转储文件恢复数据 用于恢复数据。 您可以使用带有 -i 标志的 docker exec 命令，类似于以下内容： $ docker exec -i some-mysql sh -c 'exec mysql -uroot -p"$MYSQL_ROOT_PASSWORD"' < /some/path/on/your/host/all-databases.sql 备注 docker安装完MySQL，后面就是MySQL容器在跑，基本上就是当MySQL服务去操作，以前MySQL怎么做现在还是一样怎么做，只是个别操作因为docker包了一层，麻烦一点。 有需要的话，我们也可以基于MySQL官方镜像去定制我们自己的镜像，就比如主从镜像之类的。 本篇文章为转载内容。原文链接：https://blog.csdn.net/muluo7fen/article/details/122731852。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

....下载训练集 2.对数据进行调整 2.1 将ubyte格式转为jpg格式 2.2 将图片按照标签分类到具体文件夹 2.3 数据存在的缺陷 2.4 优化建议(核心) 二、模型训练 三、项目实现 1. 代码实现 2. 采用器件 2. 注意事项 总结 前言 第一次接触OpenMV也是第一次将理论用于实践，是老师让我实现的一个小测验，这几天完成后决定写下完整的过程。本文主要是当缝合怪，借鉴和参考了其他人的代码再根据我个人设备进行了一定的调整，此外还包括了我自身实践过程中的一些小意外。 ！！！一定要根据个人器件型号和个人设备来参考 一、数字识别的模型训练 1.下载训练集 研究期间，我发现大部分人以及官网教程采用的都是自己拍摄照片再进行网络训练，存在的缺陷就是数据集较小不全面、操作繁琐。个人认为如果是对标准的数字进行识别，自己手动拍取照片进行识别足够了。但想要应用于更广泛的情况，应该寻找更大的数据集，所以我找到了国外手写数字的数据集MNIST。建议四个文件都下载 数据链接：MINIST数据集 2.对数据进行调整 2.1 将ubyte格式转为jpg格式 代码参考链接：python将ubyte格式的MNIST数据集转成jpg图片格式并保存 import numpy as npimport cv2import osimport structdef trans(image, label, save):image位置，label位置和转换后的数据保存位置if 'train' in os.path.basename(image):prefix = 'train'else:prefix = 'test'labelIndex = 0imageIndex = 0i = 0lbdata = open(label, 'rb').read()magic, nums = struct.unpack_from(">II", lbdata, labelIndex)labelIndex += struct.calcsize('>II')imgdata = open(image, "rb").read()magic, nums, numRows, numColumns = struct.unpack_from('>IIII', imgdata, imageIndex)imageIndex += struct.calcsize('>IIII')for i in range(nums):label = struct.unpack_from('>B', lbdata, labelIndex)[0]labelIndex += struct.calcsize('>B')im = struct.unpack_from('>784B', imgdata, imageIndex)imageIndex += struct.calcsize('>784B')im = np.array(im, dtype='uint8')img = im.reshape(28, 28)save_name = os.path.join(save, '{}_{}_{}.jpg'.format(prefix, i, label))cv2.imwrite(save_name, img)if __name__ == '__main__':需要更改的文件路径！！！！！！此处是原始数据集位置train_images = 'C:/Users/ASUS/Desktop/train-images.idx3.ubyte'train_labels = 'C:/Users/ASUS/Desktop/train-labels.idx1.ubyte'test_images ='C:/Users/ASUS/Desktop/t10k-images.idx3.ubyte'test_labels = 'C:/Users/ASUS/Desktop/t10k-labels.idx1.ubyte'此处是我们将转化后的数据集保存的位置save_train ='C:/Users/ASUS/Desktop/MNIST/train_images/'save_test ='C:/Users/ASUS/Desktop/MNIST/test_images/'if not os.path.exists(save_train):os.makedirs(save_train)if not os.path.exists(save_test):os.makedirs(save_test)trans(test_images, test_labels, save_test)trans(train_images, train_labels, save_train) 2.2 将图片按照标签分类到具体文件夹 文章参考链接：python实现根据文件名自动分类转移至不同的文件夹 注意：为了适合这个数据集和我的win11系统对代码进行了一点调整，由于数据很多如果只需要部分数据一定要将那些数据单独放在一个文件夹。 导入库import osimport shutil 当前文件夹所在的路径，使用时需要进行修改current_path = 'C:/Users/ASUS/Desktop/MNIST/test'print('当前文件夹为:' + current_path) 读取该路径下的文件filename_list = os.listdir(current_path) 建立文件夹并且进行转移 假设原图片名称 test_001_2.jpgfor filename in filename_list:name1, name2, name3 = filename.split('_') name1 = test name2 = 001 name3 = 2.jpgname4, name5 = name3.split('.') name4 = 2 name5 = jpgif name5 == 'jpg' or name5 == 'png':try:os.mkdir(current_path+'/'+name4)print('成功建立文件夹:'+name4)except:passtry:shutil.move(current_path+'/'+filename, current_path+'/'+name4[:])print(filename+'转移成功！')except Exception as e:print('文件 %s 转移失败' % filename)print('转移错误原因:' + e)print('整理完毕！') 2.3 数据存在的缺陷 数据集内的图片数量很多，由于后面介绍的云端训练的限制，只能采用部分数据（本人采用的是1000张，大家可以自行增减数目）。 数据集为国外的数据集，很多数字写的跟我们不一样。如果想要更好的适用于我们国内的场景，可以对数据集进行手动的筛选。下面是他们写的数字2： 可以看出跟我们的不一样，不过数据集中仍然存在跟常规书写的一样的，我们需要进行人为的筛选。 2.4 优化建议(核心) 分析发现，部分数字精度不高的原因主要是国外手写很随意，我们可以通过调整网络参数(如下)、人为筛选数据(如上)、增大数据集等方式进行优化。 二、模型训练 主要参考文章：通过云端自动生成openmv的神经网络模型，进行目标检测 ！！！唯一不同的点是我图像参数设置的是灰度而不是上述文章的RGB。 下面是我模型训练时的参数设置（仅供参考）： 通过混淆矩阵可以看出，主要的错误在于数字2、6、8。我们可以通过查看识别错误的数字来分析可能的原因。 三、项目实现 ！！！我们需要先将上述步骤中导出文件中的所有内容复制粘贴带OpenMV中自带的U盘中。然后将其中的.py文件名称改为main 1. 代码实现 本人修改后的完整代码展示如下，使用的是OpenMV IDE（官网下载）： 数字识别后控制直流电机转速from pyb import Pin, Timerimport sensor, image, time, os, tf, math, random, lcd, uos, gc 根据识别的数字输出不同占比的PWM波def run(number):if inverse == True:ain1.low()ain2.high()else:ain1.high()ain2.low()ch1.pulse_width_percent(abs(number10)) 具体参数调整自行搜索sensor.reset() 初始化感光元件sensor.set_pixformat(sensor.GRAYSCALE) set_pixformat : 设置像素模式(GRAYSCALSE : 灰色; RGB565 : 彩色)sensor.set_framesize(sensor.QQVGA2) set_framesize : 设置处理图像的大小sensor.set_windowing((128, 160)) set_windowing ： 设置提取区域大小sensor.skip_frames(time = 2000) skip_frames ：跳过2000ms再读取图像lcd.init() 初始化lcd屏幕。inverse = False True : 电机反转 False : 电机正转ain1 = Pin('P1', Pin.OUT_PP) 引脚P1作为输出ain2 = Pin('P4', Pin.OUT_PP) 引脚P4作为输出ain1.low() P1初始化低电平ain2.low() P4初始化低电平tim = Timer(2, freq = 1000) 采用定时器2，频率为1000Hzch1 = tim.channel(4, Timer.PWM, pin = Pin('P5'), pulse_width_percent = 100) 输出通道1 配置PWM模式下的定时器（高电平有效） 端口为P5 初始占空比为100%clock = time.clock() 设置一个时钟用于追踪FPS 加载模型try:net = tf.load("trained.tflite", load_to_fb=uos.stat('trained.tflite')[6] > (gc.mem_free() - (641024)))except Exception as e:print(e)raise Exception('Failed to load "trained.tflite", did you copy the .tflite and labels.txt file onto the mass-storage device? (' + str(e) + ')') 加载标签try:labels = [line.rstrip('\n') for line in open("labels.txt")]except Exception as e:raise Exception('Failed to load "labels.txt", did you copy the .tflite and labels.txt file onto the mass-storage device? (' + str(e) + ')') 不断的进行运行while(True):clock.tick() 更新时钟img = sensor.snapshot().binary([(0,64)]) 抓取一张图像以灰度图显示lcd.display(img) 拍照并显示图像for obj in net.classify(img, min_scale=1.0, scale_mul=0.8, x_overlap=0.5, y_overlap=0.5): 初始化最大值和标签max_num = -1max_index = -1print("\nPredictions at [x=%d,y=%d,w=%d,h=%d]" % obj.rect())img.draw_rectangle(obj.rect()) 预测值和标签写成一个列表predictions_list = list(zip(labels, obj.output())) 输出各个标签的预测值，找到最大值进行输出for i in range(len(predictions_list)):print('%s 的概率为： %f' % (predictions_list[i][0], predictions_list[i][1]))if predictions_list[i][1] > max_num:max_num = predictions_list[i][1]max_index = int(predictions_list[i][0])run(max_index)print('该数字预测为：%d' % max_index)print('FPS为：', clock.fps())print('PWM波占空比为: %d%%' % (max_index10)) 2. 采用器件 使用的器件为OpenMV4 H7 Plus和L298N以及常用的直流电机。关键是找到器件的引脚图，再进行简单的连线即可。 参考文章：【L298N驱动模块学习笔记】–openmv驱动 参考文章：【openmv】原理图 引脚图 2. 注意事项 上述代码中我用到了lcd屏幕，主要是为了方便离机操作。使用过程中，OpenMV的lcd初始化时会重置端口，所有我们在输出PWM波的时候一定不要发生引脚冲突。我们可以在OpenMV官网查看lcd用到的端口： 可以看到上述用到的是P0、P2、P3、P6、P7和P8。所有我们输出PWM波时要避开这些端口。下面是OpenMV的PWM资源： 总结 本人第一次自己做东西也是第一次使用python，所以代码和项目写的都很粗糙，只是简单的识别数字控制直流电机。我也是四处借鉴修改后写下的大小，这篇文章主要是为了给那些像我一样的小白们提供一点帮助，减少大家查找资料的时间。模型的缺陷以及改进方法上述中已经说明，如果我有写错或者大家有更好的方法欢迎大家告诉我，大家一起进步！ 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_57100435/article/details/130740351。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...er函数向通道发送数据，而consumer函数从通道接收数据。用这种方法，咱们就能又优雅又稳妥地搞定多线程里的同步难题，还不用担心被死锁给缠上。 --- 3. 内存管理 GC的奥秘 接下来谈谈内存管理。Go的垃圾回收器（GC）是它的一大亮点。就像用老式工具编程一样，C/C++这种传统语言就得让程序员自己动手去清理内存，稍不留神，就可能搞出内存泄漏，或者戳到那些讨厌的野指针，简直让人头大！而Go则完全解放了我们的双手，它会自动帮你清理不再使用的内存。 不过，GC也不是万能的。有时候，如果你对性能要求特别高，可能会遇到GC停顿的问题。为了解决这个问题，Go团队一直在优化GC算法。最新版本中引入了分代GC（Generational GC），大幅降低了停顿时间。 那么，我们在实际开发中应该如何减少GC的压力呢？最直接的方法就是尽量避免频繁的小对象分配。比如，我们可以复用一些常见的结构体，而不是每次都新建它们： go type Buffer struct { data []byte } func NewBuffer(size int) Buffer { return &Buffer{data: make([]byte, size)} } func (b Buffer) Reset() { b.data = b.data[:0] } func main() { buf := NewBuffer(1024) for i := 0; i < 100; i++ { buf.Reset() // 使用buf... } } 在这个例子中，我们通过Reset()方法复用了同一个Buffer实例，而不是每次都调用make([]byte, size)重新创建一个新的切片。这样可以显著降低GC的压力。 --- 4. 网络优化 TCP/IP的实战 再来说说网络优化。Go的net包提供了强大的网络编程支持，无论是HTTP、WebSocket还是普通的TCP/UDP，都能轻松搞定。特别是对那些高性能服务器而言，怎么才能又快又稳地搞定海量连接，这简直就是一个绕不开的大难题啊！ 举个例子，假设我们要实现一个简单的HTTP长连接服务器。传统的做法可能是监听端口，然后逐个处理请求。但这种方式效率不高，特别是在高并发场景下。Go提供了一个更好的解决方案——使用net/http包的Serve方法： go package main import ( "log" "net/http" ) func handler(w http.ResponseWriter, r http.Request) { w.Write([]byte("Hello, World!")) } func main() { http.HandleFunc("/", handler) log.Fatal(http.ListenAndServe(":8080", nil)) } 这段代码看起来很简单，但它实际上已经具备了处理大量并发连接的能力。为啥呢？就是因为Go语言里的http.Server自带了一个超级能打的“工具箱”，里面有个高效的连接池和请求队列，遇到高并发的情况时，它就能像一个经验丰富的老司机一样，把各种请求安排得明明白白，妥妥地hold住场面！ 当然，如果你想要更底层的控制，也可以直接使用net包来编写TCP服务器。比如下面这个简单的TCP回显服务器： go package main import ( "bufio" "fmt" "net" ) func handleConnection(conn net.Conn) { defer conn.Close() reader := bufio.NewReader(conn) for { message, err := reader.ReadString('\n') if err != nil { fmt.Println("Error reading:", err) break } fmt.Print("Received:", message) conn.Write([]byte(message)) } } func main() { listener, err := net.Listen("tcp", ":8080") if err != nil { fmt.Println("Error listening:", err) return } defer listener.Close() fmt.Println("Listening on :8080...") for { conn, err := listener.Accept() if err != nil { fmt.Println("Error accepting:", err) continue } go handleConnection(conn) } } 在这个例子中，我们通过listener.Accept()不断接受客户端连接，并为每个连接启动一个协程来处理请求。这种模式非常适合处理大量短连接的场景。 --- 5. 代码结构 模块化与可扩展性 最后，我们来聊聊代码结构。一个高性能的服务器不仅仅依赖于语言特性，还需要良好的设计思路。Go语言特别推崇把程序分成小块儿来写，就像搭积木一样，每个功能都封装成独立的小模块或包。这样不仅修 bug 的时候方便找问题，写代码的时候也更容易看懂，以后想加新功能啥的也简单多了。 比如，假设我们要开发一个分布式任务调度系统，可以按照以下方式组织代码： go // tasks.go package task type Task struct { ID string Name string Param interface{} } func NewTask(id, name string, param interface{}) Task { return &Task{ ID: id, Name: name, Param: param, } } // scheduler.go package scheduler import "task" type Scheduler struct { tasks []task.Task } func NewScheduler() Scheduler { return &Scheduler{ tasks: make([]task.Task, 0), } } func (s Scheduler) AddTask(t task.Task) { s.tasks = append(s.tasks, t) } func (s Scheduler) Run() { for _, t := range s.tasks { fmt.Printf("Executing task %s\n", t.Name) // 执行任务逻辑... } } 通过这种方式，我们将任务管理和调度逻辑分离出来，使得代码更加清晰易懂。同时，这样的设计也方便未来扩展新的功能，比如添加日志记录、监控指标等功能。 --- 6. 总结与展望 好了，到这里咱们就差不多聊完了如何用Go语言进行高性能服务器开发。说实话，写着这篇文章的时候，我脑海里突然蹦出大学时那股子钻研劲儿，感觉就像重新回到那些熬夜敲代码的日子了，整个人都热血上头！Go这门语言真的太带感了，简单到没话说，效率还超高，稳定性又好得没话说，简直就是程序员的救星啊！ 不过，我也想提醒大家一句：技术再好，最终还是要服务于业务需求。不管你用啥法子、说啥话，老老实实问问自己：“这招到底管不管用？是不是真的解决问题了？”这才是真本事！ 希望这篇文章对你有所帮助，如果你有任何疑问或者想法，欢迎随时留言讨论！让我们一起继续探索Go的无限可能吧！

...了其他的UI库，为了兼容高清方案，你需要对该UI库里凡是应用px的地方做相应处理，即： a px => a0.02 rem (具体处理方式因人而异，有模块化开发经验的同学可使用类似的 px2rem 的插件去转化，也可以完全手动处理） （2017/9/9更新）然而真实情况往往更为复杂，比如，你引入了百度地图（N个样式需要处理转换）；或者你引入了一个 framework；又或者你使用了 video 标签，上面默认的尺寸样式很难处理。等等这些棘手问题 面对这些情况，此时我们的高清方案如果不再压缩页面，那么以上问题将迎刃而解。 基于这样的思路，笔者对高清方案的源码做了如下修改，即添加一个叫做 normal 的参数，由它来控制页面是否压缩。 在文章顶部代码的最后，你会看到 flex(false, 100, 1)，默认情况下页面是开启压缩的。 如果你需要禁止压缩，由于我们的源码执行后，直接将flex函数挂载到全局变量window上了，此时你直接在需要禁止压缩的页面执行 window.flex(true) 就可以了，而rem的用法保持不变。 有一点美中不足的是，如果禁止了页面压缩，高清屏的1像素就不能实现了，如果你必须要实现1像素，那么自行谷歌：css 0.5像素，有N多的解决方案，这里不再赘述。 5.问：有时候字体会不受控制的变大，怎么办？ 答：在X5新内核Blink中，在排版页面的时候，会主动对字体进行放大，会检测页面中的主字体，当某一块字体在我们的判定规则中，认为字号较小，并且是页面中的主要字体，就会采取主动放大的操作。然而这不是我们想要的，可以采取给最大高度解决 解决方案： , :before, :after { max-height: 100000px } 补充：有同学反映，在一些情况下 textarea 标签内的字体大小即便加上上面的方案，字体也会变大，无法控制。此时你需要给 textarea 的 display 设为 table 或者 inline-table 即可恢复正常。（感谢 程序媛喵喵 对此的补充！2017/7/7） 6.问：我在底部导航用的flex感觉更合适一些，请问这样子混着用可以吗？ 答：咱们的rem适合写固定尺寸。其余的根据需要换成flex或者百分比。源码示例中就有这三种的综合运用。 7.问：在高清方案下，一个标准的，较为理想的宽度为640的页面效果图应该是怎样的？ 点击浏览：一个标准的640手机页面设计稿参考（没错，在此方案中，你可以完全按照这张设计稿的尺寸写布局了。就是这么简单！） 8.问：用了这个方案如何使用媒体查询呢？ 一般来讲，使用了这个方案是没必要用媒体查询了，如果你必须要用，假设你要对 iphone5 （css像素宽度320px, 这里需要取其物理像素，也就是640）宽度下的类名做处理，你可以这样 @media screen and (max-width: 640px) {.yourLayout {width:100%;} } 9.问：可以提供下这个高清方案的源码吗？ 'use strict';/ @param {Boolean} [normal = false] - 默认开启页面压缩以使页面高清; @param {Number} [baseFontSize = 100] - 基础fontSize, 默认100px; @param {Number} [fontscale = 1] - 有的业务希望能放大一定比例的字体;/const win = window;export default win.flex = (normal, baseFontSize, fontscale) => {const _baseFontSize = baseFontSize || 100;const _fontscale = fontscale || 1;const doc = win.document;const ua = navigator.userAgent;const matches = ua.match(/Android[\S\s]+AppleWebkit\/(\d{3})/i);const UCversion = ua.match(/U3\/((\d+|\.){5,})/i);const isUCHd = UCversion && parseInt(UCversion[1].split('.').join(''), 10) >= 80;const isIos = navigator.appVersion.match(/(iphone|ipad|ipod)/gi);let dpr = win.devicePixelRatio || 1;if (!isIos && !(matches && matches[1] > 534) && !isUCHd) {// 如果非iOS, 非Android4.3以上, 非UC内核, 就不执行高清, dpr设为1;dpr = 1;}const scale = normal ? 1 : 1 / dpr;let metaEl = doc.querySelector('meta[name="viewport"]');if (!metaEl) {metaEl = doc.createElement('meta');metaEl.setAttribute('name', 'viewport');doc.head.appendChild(metaEl);}metaEl.setAttribute('content', width=device-width,user-scalable=no,initial-scale=${scale},maximum-scale=${scale},minimum-scale=${scale});doc.documentElement.style.fontSize = normal ? '50px' : ${_baseFontSize / 2 dpr _fontscale}px;}; 10.问：我在使用 rem 布局进阶方案的时候遇到了XXX的问题，如何解决？ 此方案久经考验，具有普遍适用性，自身出致命问题的情况很少，至少笔者是没遇到过。 绝大多数你遇到的问题，都是由于对rem布局理解不到位导致的。本文对rem布局做了大量的解释说明，配置了若干 demo，你可以把你遇到的问题放到demo里测试。遇到问题时，首先问自己，为什么这明显的错误大家没遇到就我遇到了？？ 如果你真的经过充分验证，比对，确实是rem布局自身出了问题，那么请私信我，把还原问题场景的 demo 或者文件发给我。谢谢！ 本篇文章为转载内容。原文链接：https://blog.csdn.net/hjhfreshman/article/details/88864894。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

Netty与大数据流处理平台的优化 1. Netty是什么？为什么它这么重要？ 嗨，大家好！我是你们的老朋友，今天我们要聊聊一个超级厉害的技术——Netty。嘿，要是你对分布式系统、高能网络编程或者大数据流处理这些酷炫的东西感兴趣，那Netty可就太值得一试了！它就像是个隐藏的宝藏，能让你在这些领域玩得更溜。 首先，Netty是什么？简单来说，Netty是一个基于Java的异步事件驱动网络应用框架。它可以帮助开发者快速构建可扩展的服务器端应用程序。想象一下，你正在开发一个需要处理海量数据的大数据流处理平台，这时候Netty就显得尤为重要了。它不仅能够帮助我们高效地管理网络连接，还能让我们轻松应对高并发场景。 我第一次接触Netty的时候，真的被它的灵活性震撼到了。哎，说到程序员的烦心事，那肯定得提一提怎么让程序在被成千上万的人同时戳的时候还能稳如老狗啊！这事儿真心让人头大，尤其是看着服务器指标噌噌往上涨，心里直打鼓，生怕哪一秒就崩了。而Netty通过非阻塞I/O模型，完美解决了这个问题。这就像是一个超级能干的服务员，能够在同一时间同时服务上万个客人，而且就算有个客人纠结半天点菜（也就是某个请求拖拉），也不会耽误其他客人的服务，更不会让整个餐厅都停下来等他。 举个栗子： java EventLoopGroup bossGroup = new NioEventLoopGroup(); // 主线程组 EventLoopGroup workerGroup = new NioEventLoopGroup(); // 工作线程组 try { ServerBootstrap b = new ServerBootstrap(); // 启动辅助类 b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) // 使用NIO通道 .childHandler(new ChannelInitializer() { // 子处理器 @Override protected void initChannel(SocketChannel ch) throws Exception { ch.pipeline().addLast(new StringDecoder()); // 解码器 ch.pipeline().addLast(new StringEncoder()); // 编码器 ch.pipeline().addLast(new SimpleChannelInboundHandler() { @Override protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception { System.out.println("Received message: " + msg); ctx.writeAndFlush("Echo: " + msg); // 回显消息 } }); } }); ChannelFuture f = b.bind(8080).sync(); // 绑定端口并同步等待完成 f.channel().closeFuture().sync(); // 等待服务关闭 } finally { workerGroup.shutdownGracefully(); bossGroup.shutdownGracefully(); } 这段代码展示了如何用Netty创建一个简单的TCP服务器。话说回来，Netty这家伙简直太贴心了，它的API设计得特别直观，想设置啥处理器或者监听事件都超简单，用起来完全没压力，感觉开发效率直接拉满！ 2. 大数据流处理平台中的挑战 接下来，我们聊聊大数据流处理平台面临的挑战。在这个领域，我们通常会遇到以下几个问题： - 高吞吐量：我们需要处理每秒数百万条甚至更多的数据记录。 - 低延迟：对于某些实时应用场景（如股票交易），毫秒级的延迟都是不可接受的。 - 可靠性：数据不能丢失，必须保证至少一次投递。 - 扩展性：随着业务增长，系统需要能够无缝扩容。 这些问题听起来是不是很让人头大？但别担心，Netty正是为此而生的！ 让我分享一个小故事吧。嘿，有次我正忙着弄个日志收集系统，结果一测试才发现，这传统的阻塞式I/O模型简直是“人形瓶颈”啊！流量一大就直接崩溃，完全hold不住那个高峰时刻，简直让人头大！于是，我开始研究Netty，并将其引入到项目中。哈哈，结果怎么样？系统的性能直接翻了三倍！这下我可真服了，选对工具真的太重要了，感觉像是找到了开挂的装备一样爽。 为了更好地理解这些挑战，我们可以看看下面这段代码，这是Netty中用来实现高性能读写的示例： java public class HighThroughputHandler extends ChannelInboundHandlerAdapter { private final ByteBuf buffer; public HighThroughputHandler() { buffer = Unpooled.buffer(1024); } @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { for (int i = 0; i < 1024; i++) { buffer.writeByte((byte) i); } ctx.writeAndFlush(buffer.retain()); } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { ctx.write(msg); } @Override public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { ctx.flush(); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { cause.printStackTrace(); ctx.close(); } } 在这段代码中，我们创建了一个自定义的处理器HighThroughputHandler，它能够在每次接收到数据后立即转发出去，从而实现高吞吐量的传输。 3. Netty如何优化大数据流处理平台？ 现在，让我们进入正题——Netty是如何具体优化大数据流处理平台的呢？ 3.1 异步非阻塞I/O Netty的核心优势在于其异步非阻塞I/O模型。这就相当于，当有请求进来的时候，Netty可不会给每个连接都专门安排一个“服务员”，而是让这些连接共用一个“服务团队”。这样既能节省人手，又能高效处理各种任务，多划算啊！这样做的好处是显著减少了内存占用和上下文切换开销。 假设你的大数据流处理平台每天要处理数十亿条数据记录，采用传统的阻塞式I/O模型，很可能早就崩溃了。而Netty则可以通过单线程处理数千个连接，极大地提高了资源利用率。 3.2 零拷贝技术 另一个让Netty脱颖而出的特点是零拷贝技术。嘿，咱们就拿快递打个比方吧！想象一下，你在家里等着收快递，但这个快递特别麻烦——它得先从仓库（相当于内核空间）送到快递员手里（用户空间），然后快递员再把东西送回到你家（又回到内核空间）。这就像是数据在网络通信里来回折腾了好几趟，一会儿在系统深处待着，一会儿又被搬出来给应用用，真是费劲啊！这种操作不仅耗时，还会消耗大量CPU资源。 Netty通过ZeroCopy机制，直接将数据从文件系统传递到网络套接字，避免了不必要的内存拷贝。这种做法不仅加快了数据传输速度，还降低了系统的整体负载。 这里有一个实际的例子： java FileRegion region = new DefaultFileRegion(fileChannel, 0, fileSize); ctx.write(region); 上述代码展示了如何利用Netty的零拷贝功能发送大文件，无需手动加载整个文件到内存中。 3.3 灵活的消息编解码 在大数据流处理平台中，数据格式多种多样，可能包括JSON、Protobuf、Avro等。Netty提供了一套强大的消息编解码框架，允许开发者根据需求自由定制解码逻辑。 例如，如果你的数据是以Protobuf格式传输的，可以这样做： java public class ProtobufDecoder extends MessageToMessageDecoder { @Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception { byte[] data = new byte[in.readableBytes()]; in.readBytes(data); MyProtoMessage message = MyProtoMessage.parseFrom(data); out.add(message); } } 通过这种方式，我们可以轻松解析复杂的数据结构，同时保持代码的整洁性和可维护性。 3.4 容错与重试机制 最后但同样重要的是，Netty内置了强大的容错与重试机制。在网上聊天或者传输文件的时候，有时候会出现消息没发出去、对方迟迟收不到的情况，就像快递丢了或者送慢了。Netty这个小助手可机灵了，它会赶紧发现这些问题，然后试着帮咱们把没送到的消息重新发一遍，就像是给快递员多派一个人手，保证咱们的信息能安全顺利地到达目的地。 java RetryHandler retryHandler = new RetryHandler(maxRetries); ctx.pipeline().addFirst(retryHandler); 上面这段代码展示了如何添加一个重试处理器到Netty的管道中，让它在遇到错误时自动重试。 4. 总结与展望 经过这一番探讨，相信大家已经对Netty及其在大数据流处理平台中的应用有了更深入的理解。Netty可不只是个工具库啊，它更像是个靠谱的小伙伴，陪着咱们一起在高性能网络编程的大海里劈波斩浪、寻宝探险！ 当然，Netty也有它的局限性。比如说啊，遇到那种超级复杂的业务场景，你可能就得绞尽脑汁写一堆专门定制的代码，不然根本搞不定。还有呢，这门技术的学习难度有点大，刚上手的小白很容易觉得晕头转向，不知道该怎么下手。但我相信，只要坚持实践，总有一天你会爱上它。 未来，随着5G、物联网等新技术的发展，大数据流处理的需求将会更加旺盛。而Netty凭借其卓越的性能和灵活性，必将在这一领域继续发光发热。所以，不妨大胆拥抱Netty吧，它会让你的开发之旅变得更加精彩！ 好了，今天的分享就到这里啦！如果你有任何疑问或者想法，欢迎随时交流。记住，编程之路没有终点，只有不断前进的脚步。加油，朋友们！

...包括：线代、概率论、数据结构、计网、计组、操作系统等(不用复习的特别深入)，有的学校有笔试，大多数在面试时会问到一些基础知识(如果老师问到的基础知识都答上来，老师对你的印象肯定会特别好！)。 信息搜集：各学校/学院官网(研招网)；学长学姐；保研论坛，微信公众号(后保研、保研人、保研论坛等)；QQ群等。同时也要多与同学交流，互相交换信息。 搜集你想去并且基本能去的学校的要求和特点(南京大学夏令营对机考特别看重，难度也比较大，可以在大三就多刷题好好准备)，进行一定的准备，可以在网上搜索相关的经验贴。 个人定位：了解你们学校学长学姐的保研去处，最好多跟本校已经保研的学长学姐交流，根据他们的经历以及自己的实力和研究生规划来对自己进行定位。 方向和选择： 人工智能？CV? NLP? 数据库？分布式系统？其他？ 硕士？直博？ 小老师？大牛老师？ 以上这些选择因人而异，最好自己多了解、多与老师学长学姐交流，根据自己的兴趣、目前的发展以及自己未来的规划进行抉择。 夏令营(4-7月)：从四月份开始就有的学校开始了夏令营申请，5-6月是夏令营申请的集中时间；参加夏令营基本都在6-7月份。夏令营的好处：老师名额多；时间比较充裕，可以较好的了解学校以及方向等；大多学校夏令营安排住宿。参加夏令营最重要的是专业排名(这是大多数学校初筛的最重要的依据，科研经历/比赛等都是次要的。当然顶会和ACM大牛除外)。 预推免(7-9月)：有的学校夏令营开始后马上就开始预推免的报名与进行(例如哈工大从7月份开始到9月份有四批预推免的面试)；大多数学校集中在9月中旬。如果夏令营已经有offer了可以在预推免时冲击更好的offer；如果夏令营没有拿到offer，建议此时以稳重为好。 九推：9月28号在推免系统正式填报推免志愿，录取。 个人简历：建议在寒假期间就把自己大学的经历都整理一遍，写好简历的初始版本；然后再找老师、学长学姐帮忙完善。 个人陈述：包括自己的情况介绍、科研经历、研究生期间的规划等，1000-1500字。网上有模板可以借鉴。 老师推荐信：基本都是自己写好找老师签字，如果老师能帮你手写的话，那太好不过了。 联系老师邮件：建议提前写好一个大概的模板，注意格式、内容以及邮件的标题等(例如XX大学-XXX-保研申请)。建议夏令营前或者初审过了及时联系自己喜欢的老师。 以上只是对各方面的简单介绍，每个方面详细的注意点网上好多资料，多多搜集就好。 PS：以上个人简历/个人陈述/老师推荐信模板如果有需要的私信我分享给你！ 建议把以上材料都提前收集整理好，保研结束后发现我的材料文件夹3个多G...... 一年多来整理的保研资料 四、上科大信息学院夏令营(7.3-7.6) 本来没有打算报名上科大，一个同学把上科大宣传单给了我一份，看后感觉上科大实力比较强(虽然不是982/211)就报名了。 校园环境 上科大3号报到，4号-6号有开营活动、参观、自己联系老师面试(后来才知道即使拿到优营九月份也要再来面试，也就是说上科大夏令营拿到优营只是免去了九月预推免面试的初审，但是如果你足够优秀，老师比较中意，九月份就是来走一下过场。) 我参加了三个老师的面试。YY老师只是简单问了几个问题，有点水；HXM老师有一轮笔试(考的概率论比较多，编译原理、操作系统、计网也有涉及)+面试；YJY老师的一轮面试是课题组的学长学姐面的(自我介绍+项目)，二轮面试和老师聊。 上科大给我的感觉就是学校小而精；老师比较好(比如YJY/GSH/TKW)、科研氛围浓厚、硬件设施完善(双人宿舍，独立卫浴，中央空调；学校地下全是停车场，下雨不用打伞可以直接走地下)，但是由于建立才几年的时间，知名度不高。 学生宿舍 五、北理计算机夏令营(7.8-7.10) 北理今年入营的基本都是985和顶尖211，夏令营去了基本都能拿到优营！入营290+，夏令营参营240+，优营220+。 在北理主楼俯瞰 8号报到，领取宿舍钥匙、校园卡(北理夏令营包括食宿，每人发了一张100元的校园卡，可以在食堂、超市消费)。北理校园比较小、路比较窄；研究生宿舍三栋高层，有电梯，四人间，宿舍空间小、比较挤，大多数宿舍有空调(据说是宿舍的同学自己买或者租的)，每一层有一个公共洗澡间。 9号上午宣讲，下午机试。机试两道题目难度不大，老师手动输入三个样例给分(4+3+3，每道题目满分10分)。下午机试结束我找到提前联系的LX老师聊了一个小时，老师人很nice，专心学术(据说她的研究生大都有一篇顶会论文)。 10号上午自己找老师面试。我又参加了院长实验室的面试，比较简单。下午正式面试，分了十多个组一起面试，总共四个小时。面试包括英文自我介绍、项目、研究生规划、是否打算读博、基础知识等，每人大概5-7分钟。面试结束就可以离校了。 六、北航计算机夏令营(7.11-7.14) 北航是不包含食宿的，所以入营人数较多，有600+。北航7.11上午报到+宣讲，下午机试分两组。北航机试类似CSP，可以多次提交，以最后一次为准，但是提交后不能实时出成绩。机试两个小时，包括两道题目，第一道题目比较简单，第二道题目稍微难一些，我第二道题目没有写完但是也过了机试，第二道题目即使没有写完也要能写多少写多少，把代码的思路写出来(有可能会人工判)。北航机试可以用CSP成绩代替，基本250分及以上就没问题，每年具体的情况不一样。11号晚上出机试通过名单(大概500+进340+)。 12号分组面试，每人20分钟，从上午八点一直面试到下午三点。面试包括抽取一道政治题谈看法、抽取一段英文读并翻译、基础知识(数学知识+计算机知识)、项目。政治题和英文翻译感觉大家都差不多(除非你英语特别差)，主要的是基础知识面试，北航比较爱问数学问题线代、概率论、离散、高数；如果你的项目比较好的话，老师会着重问你的项目。问到我的问题有梯度、可微和可导、大数定理+中心极限定理等。12号晚上出优营名单，大概340+进180。北航是根据夏令营面试排名来定学硕和专硕的，大概有40个学硕的名额，其他都是专硕，不过北航学硕和专硕培养方式没有区别。 这是在我前面面试同学被问到的部分问题 13号领导师意向表，找导师签字，如果没有找到暑假期间或者九月份也可以再联系老师。 14号校医院体检，夏令营结束。 七、计算所(7.13-7.16) 计算所入营还是比较有难度的，但是即使没入营也可以自己联系老师，如果老师同意可以来参加面试，只是夏令营包括食宿，没入营的不包括食宿。计算所是分实验室面试的，可以参加多个实验室的面试，我参加了网数和智信的笔试+机试+面试。 智信12号笔试，14号机试+面试。笔试包括英文论文理解翻译、概率论题、计算机基础知识题目(操作系统，计网等)、CV题目(智信主要是做CV)。机试五道题目，一个小时，题目代码已经写好了，只需你补全，类似LeetCode，在学长的电脑上完成，有C++和Python可选，两种编程语言题目不同。C++用的是VS2017，会由人给你记每道题目完成的时间，会让你演示调试，结束后打包发送到一个邮箱里。 网数只有机试和面试,13号上午机试，15号面试。机试一个小时七道题目，在自己电脑上写然后拷到老师的优盘上。考察了包括链表、二叉树、图等，偏向于工程，据说今年的题目是计算所一个工程博士出的。机试70人，进入面试60人。面试每人15分钟，包括自我介绍，专业知识，是否读博，项目等。 计算所环境 八、一些建议和感想 一些建议： 提前准备，给自己定位，有针对性的准备，多在网上找经验贴；多和本校保研的学长学姐交流，多和同学交流，多搜集信息； 4月份前把简历、推荐信、个人陈述等写好，再不断修改完善； 最好能提前联系一个老师，以免拿到优营而没有找到好老师； 准备好专业知识，线代、概率论、数据结构、计网、计组、操作系统等； 如果编程能力不是特别强，最好大三开始就刷题，LeetCode的中档题难度基本就够用了； 一些体会与感想： 机会是留给有准备的人的，越努力越幸运！ 做最坏的打算，做最好的准备。 保研是一场马拉松，坚持到底就是胜利。 遵道而行，但到半途需努力；会心不远，欲登绝顶莫辞劳。 也送给自己一句话：流年笑掷，未来可期！ 以上仅代表个人观点与感想，如果对你有帮助记得点赞哦~如有问题，可以关注我的公主号【驭风者小窝】，我会尽我最大的努力帮助你！ 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_28983299/article/details/118319985。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...提供的一种高性能网络数据路径。它允许网络包，在进入内核协议栈之前，就进行处理，也可以带来更高的性能。XDP 底层跟我们之前用到的 bcc-tools 一样，都是基于 Linux 内核的 eBPF 机制实现的。 XDP 的原理如下图所示： 你可以看到，XDP 对内核的要求比较高，需要的是 Linux 4.8 以上版本，并且它也不提供缓存队列。基于 XDP 的应用程序通常是专用的网络应用，常见的有 IDS（入侵检测系统）、DDoS 防御、 cilium 容器网络插件等。 总结 C10K 问题的根源，一方面在于系统有限的资源；另一方面，也是更重要的因素，是同步阻塞的 I/O 模型以及轮询的套接字接口，限制了网络事件的处理效率。Linux 2.6 中引入的 epoll ，完美解决了 C10K 的问题，现在的高性能网络方案都基于 epoll。 从 C10K 到 C100K ，可能只需要增加系统的物理资源就可以满足；但从 C100K 到 C1000K ，就不仅仅是增加物理资源就能解决的问题了。这时，就需要多方面的优化工作了，从硬件的中断处理和网络功能卸载、到网络协议栈的文件描述符数量、连接状态跟踪、缓存队列等内核的优化，再到应用程序的工作模型优化，都是考虑的重点。 再进一步，要实现 C10M ，就不只是增加物理资源，或者优化内核和应用程序可以解决的问题了。这时候，就需要用 XDP 的方式，在内核协议栈之前处理网络包；或者用 DPDK 直接跳过网络协议栈，在用户空间通过轮询的方式直接处理网络包。 当然了，实际上，在大多数场景中，我们并不需要单机并发 1000 万的请求。通过调整系统架构，把这些请求分发到多台服务器中来处理，通常是更简单和更容易扩展的方案。 本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_23864697/article/details/114626793。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...些取舍的原则，如： 数据一致性拥有最高优先级。 提前发布核心功能优于完整发布等。 非功能性需求决定架构 因为软件是为了满足客户的功能性需求的，所以很多设计人员可能会认为架构是由要实现的功能性需求决定的。但实际上真正决定软件架构的其实是非功能性需求。 架构师要更加关注非功能性需求，常见的非功能性包括：性能，伸缩性，扩展性和可维护性等，甚至还包括团队技术水平和发布时间要求。能实现功能的设计总是有很多，考虑了非功能性需求后才能筛选出最合适的设计。 以上架构模式来自《面向模式的软件架构》的第一卷，这套书多年来一直是架构师的必读经典。面向架构的模式就是为不同的非功能性需求提供了很好的参考和指导。图中的 Micro-Kernel 模式，更加关注可扩展性和可用性（错误隔离）。 “简单”并不“容易” 很多架构师都会常常提到保持简单，但是有时候我们会混淆简单和容易。简单和容易在英语里也是两个词“simple”和“easy”。 “Simple can be harder than complex: You have to work hard to get your thinking clean to make it simple. But it’s worth it in the end because once you get there, you can move mountains. To be truly simple, you have to go really deep.” –SteveJobs 真正的一些简单的方法其实来自于对问题和技术更深入的理解。这些方案往往不是容易获得的、表面上的方法。简单可以说蕴含着一种深入的技巧在其中。 下面我来举一个例子。 首先我们来回顾一下软件生命周期中各个阶段的成本消耗占比。以下是来一个知名统计机构的分析报告。我们可以看到占比最大的是维护部分，对于这一部分的简化将最具有全局意义。 我曾经开发过一个设备管理系统，移动运营商通过这个系统来管理移动设备，实现包括设备的自动注册、固件和软件的同步等管理功能。这些功能是通过一些管理系统与移动设备间的预定义的交互协议来完成的。 电信专家们会根据业务场景及需求来调整和新增这些交互协议。起初我们采用了一种容易实现的方式，即团队中的软件工程会根据电信专家的说明，将协议实现为对应代码。 之后我们很快发现这样的方式，让我们的工作变得没那么简单。 “I believe that the hardest part of software projects, the most common source of project failure, is communication with the customers and users of that software.” –Martin Fowler 正如软件开发大师 MartinFowler 提到的，“沟通”往往是导致软件项目失败的主要原因。前面这个项目最大的问题是在系统上线后的运行维护阶段，电信专家和开发工程师之间会不断就新的协议修改和增加进行持续的沟通，而他们的领域知识和词汇都有很大的差别，这会大大影响沟通的效率。因此这期间系统的运行维护（协议的修改）变得十分艰难，不仅协议更新上线时间慢，而且由于软件工程对于电信协议理解程度有限，很多问题都要在实际上线使用后才能被电信专家发现，导致了很多的交换和反复。 针对上面提到的问题，后来我们和电信专家一起设计了一种协议设计语言（并提供可视化的工具），这种设计语言使用的电信专家所熟悉的词汇。然后通过一个类似于编译器的程序将电信专家定义好的协议模型转换为内存中的 Java 结构。这样整个项目的运行和维护就变得简单高效了，省去了低效的交流和不准确人工转换。 我们可以看到一开始按电信专家的说明直接实现协议是更为容易的办法，但就整个软件生命周期来看却并不是一个简单高效的方法。 永远不要停止编码 架构师也是程序员，代码是软件的最终实现形态，停止编程会逐渐让你忘记作为程序员的感受，更重要的是忘记其中的“痛”，从而容易产生一些不切实际的设计。 大家可能听说过在 Amazon，高级副总裁级别的 Distinguish Engineer（如：James Gosling，Java 之父），他们每年的编码量也非常大，常在 10 万行以上。 风险优先 架构设计很重要的一点是识别可能存在的风险，尤其是非功能性需求实现的风险。因为这些风险往往没有功能性需求这么容易在初期被发现，但修正的代价通常要比修正功能性需求大非常多，甚至可能导致项目的失败，前面我们也提到了非功能性需求决定了架构，如数据一致性要求、响应延迟要求等。 我们应该通过原型或在早期的迭代中确认风险能够通过合理的架构得以解决。 绝对不要把风险放到最后，就算是一个项目要失败也要让它快速失败，这也是一种敏捷。 从“问题”开始，而不是“技术” 技术人员对于新技术的都有着一种与身俱来的激情，总是乐于去学习新技术，同时也更有激情去使用新技术。但是这也同样容易导致一个通病，就是“当我们有一个锤子的时候看什么都是钉子”，使用一些不适合的技术去解决手边的问题，常常会导致简单问题复杂化。 我曾经的一个团队维护过这样一个简单的服务，起初就是一个用 MySQL 作数据存储的简单服务，由团队的一个成员来开发和维护。后来，这位成员对当时新出的 DynamoDB 产生了兴趣，并学习了相关知识。 然后就发生下面这样的事： 用DynamoDB替换了MySQL。 很快发现DynamoDB并不能很好的支持事务特性，在当时只有一个性能极差的客户端类库来支持事物，由于采用客户端方式，引入了大量的额外交互，导致性能差别达7倍之多。这时候，这个同学就采用了当时在NoSQL领域广泛流行的最终一致技术，通过一个Pub-Sub消息队列来实现最终一致（即当某对象的值发生改变后会产生一个事件，然后关注这一改变的逻辑，就会订阅这个通知，并改变于其相关数据，从而实现不同数据的最终一致）。 接着由于DynamoDB无法提供SQL那样方便的查询机制，为了实现数据分析就又引入了EMR/MapReduceJob。 到此，大家可以看到实现一样的功能，但是复杂性大大增加，维护工作也由一个人变成了一个团队。 过度忙碌使你落后 对于 IT 人而言忙碌已成为了习惯，加班常挂在嘴边。“996”工作制似乎也变成了公司高效的标志。而事实上过度的忙碌使你落后。经常遇见一些朋友，在一个公司没日没夜的干了几年，没有留一点学习时间给自己。几年之后倒是对公司越来越“忠诚”了，但忙碌的工作同时也导致了没有时间更新知识，使得自己已经落后了，连跳槽的能力和勇气都失去了。 过度忙碌会导致没有时间学习和更新自己的知识，尤其在这个高速发展的时代。我在工作经历中发现过度繁忙通常会带来以下问题： 缺乏学习导致工作能力没有提升，而面对的问题却变得日益复杂。 技术和业务上没有更大的领先优势，只能被动紧紧追赶。试想一下，要是你都领先同行业五年了，还会在乎通过加班来早一个月发布吗？ 反过来上面这些问题会导致你更加繁忙，进而更没有时间提高自己的技术技能，很快就形成了一个恶性循环。 练过健身的朋友都知道，光靠锻炼是不行的，营养补充和锻炼同样重要。个人技术成长其实也一样，实践和学习是一样重要的，当你在一个领域工作了一段时间以后，工作对你而言就主要是实践了，随着你对该领域的熟悉，能学习的到技术会越来越少。所以每个技术人员都要保证充足的学习时间，否则很容易成为井底之蛙，从而陷入前面提到的恶性循环。 最后，以伟大诗人屈原的诗句和大家共勉：“路漫漫其修远兮，吾将上下而求索“。希望我们大家都可以不忘初心，保持匠心！ 作者简介： 蔡超，Mobvista 技术 VP 兼首席架构师，SpotMax 云服务创始人。拥有超过 15 年的软件开发经验，其中 9 年任世界级 IT 公司软件架构师/首席软件架构师。2017 年加入 Mobvista，任公司技术副总裁及首席架构师，领导公司的数字移动营销平台的开发，该平台完全建立于云计算技术之上，每天处理来自全球不同 region 的超过 600 亿次的请求。 在加入 Mobvista 之前，曾任亚马逊全球直运平台首席架构师，亚马逊（中国）首席架构师，曾领导了亚马逊的全球直运平台的开发，并领导中国团队通过 AI 及云计算技术为中国客户打造更好的本地体验；曾任 HP（中国）移动设备管理系统首席软件架构师，该系统曾是全球最大的无线设备管理系统（OMA DM）（客户包括中国移动，中国联通，中国电信等）；曾任北京天融信网络安全技术公司，首席软件架构师，领导开发的网络安全管理系统（TopAnalyzer）至今仍被政府重要部门及军队广为采用，该系统也曾成功应用于 2008 北京奥运，2010 上海世博等重要事件的网络安全防护。 本篇文章为转载内容。原文链接：https://blog.csdn.net/Honnyee/article/details/111896981。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...定一张 Mysql 数据库中的表，就可以自动生成 bootstrap 样式的管理后台界面。支持列表展示、搜索、删除、批量删除、文本框、时间控件等等一切基础功能。再以后涉及管理后台的功能，只需要在这个基础上改造就行了，人力投入降低了很多，风格也得到了统一。这个工具现在在我们团队内部仍然还在广泛地使用。 还有个故事我也讲过，就是老大分配给我一个图片下载的任务。我不局限于完成完成任务，而且还把文件系统、磁盘工作原理都深入整理了一遍，就是这篇《Linux文件系统十问》 03 转战搜狗 2013 下半年的时候，我第一次感受到了工作岗位的震荡。我还专注解决某一个 bug，花了不少精力都还没查到 bug 的原因。这时候，部门助理突然招呼我们所有人都下楼，在银科腾讯的 Image 印象店集合。在那里，见到了腾讯的总裁 Martin。这还是第一次离大老板只有一米远的距离。 所有人都是一脸困惑，突然把大家召集下来是干嘛呢。原来就在几个小时前，腾讯总办已经和搜狗达成了协议。腾讯收购搜狗的一部分股份，并把我们连人带业务一起注入到了搜狗。 没想到，是老板用一种更牛逼的方式帮我把 bug 给解决了。 14 年 1 月正式到了搜狗以后，我们没有继续做搜索了。而是内部 Transfer 到了另外一个部门。做起了搜狗网址导航、搜狗手机助手、搜狗浏览器等业务。我也是从那个时间点，开始带团队的，也是从那以后慢慢开始从个人贡献者到带团队集体输出的角色的转变。 在搜狗工作的这 7 年的时间里，我仍然也是延续之前的风格。不拘泥于完成工作中的产品需求，以及老大交付的任务。而是主动去探索各种项目中有价值的事情。 比如在手机助手的推广中，我琢磨了新用户的安装流程的各个环节后，找出影响用户安装率提升的关键因素。然后对新版本安装包采用了多种技术方案，将单用户获取成本削减了20%+，这一年下来就是千万级别的成本节约。 我们还主动在手机助手的搜索模块中应用了简单的学习算法。采用了用户协同，标签相似，点击反馈等方法将手机助手的搜索转化率提升了数个百分点。 除了用技术提升业务以外，我还结合工作中的问题进行了很多的深度技术思考。 如有一次我们自己维护了一个线上的redis（当时工程部还没有redis平台，redis服务要业务自己维护）。为了优化性能，我把后端的请求由短连接改成了长连接。虽然看效果性能确实是优化了，但是我的思考并没有停止。我们所有的后端机都会连接这个redis。这样在这个redis实例上可能得有6000多条并发连接存在。我就开始疑惑，Linux 最多能有多少个TCP连接呢，我这 6000 条长连接会不会把这个服务器玩坏？ 再比如，我们组的服务器遭遇过几次连接相关的线上问题。其中一次是因为端口紧张而导致 CPU 消耗飙升。后来我又深入研究了一下。 最近，由于 Docker 的广泛应用。底层的网络工作方式已经在悄悄地发生变化了。所以我又开辟了一个网络虚拟化的坑，来一点一点地填。 现在我们的「开发内功修炼」公众号和 Github 就是在作为一个我和大家分享我的技术思考的一个窗口。 04 重回腾讯 时隔 7 年，我又以一种奇特的方式变回了腾讯人的身份。 腾讯再一次收购了搜狗的股份，这一次不再是控股，而是全资。 在离开腾讯的这 7 年多的时间里，腾讯的内部技术工作方式已经发生了翻天覆地的变化。 所以在刚转回腾讯的这一段时间里，我花了大量的精力来熟悉腾讯基于 tRPC 的各种技术生态。除了工作日，也投入了不少周末的精力。 05 再叨叨几句 最后，水文里挤干货，通过我今天的文章我想给大家分享这么几点经验。 第一，是要学会抬头看路，选择一个好的赛道进去。我非常庆幸我当年从广电赛道切换到了互联网，获得了更大的舞台。不过其实我自己在这点上做的也不是特别好，2013年底入职搜狗前拒绝了字节大把期权的offer，要不然我我早就财务自由了。 第二，不要光被动接收领导的指令干活。要主动积极思考项目中哪些地方是待改进的，想到了你就去做。领导都非常喜欢积极主动的员工。我自己也是喜欢招一些能主动思考，积极推进的同学。这些人能创造意外的价值。 第三，工作中除了业务以外还要主动技术的深度思考。毕竟技术仍然是开发的立命之本。在晋升考核的时候，业务数据做的再好也代替不了技术实力的核心位置。把工作中的技术点总结一下，在公司内分享出来。不涉及机密的话在外网分享一下更好。对你自己，对你的团队，都是好事。 技术交流群 最近有很多人问，有没有读者交流群，想知道怎么加入。 最近我创建了一些群，大家可以加入。交流群都是免费的，只需要大家加入之后不要随便发广告，多多交流技术就好了。 目前创建了多个交流群，全国交流群、北上广杭深等各地区交流群、面试交流群、资源共享群等。 有兴趣入群的同学，可长按扫描下方二维码，一定要备注：全国 Or 城市 Or 面试 Or 资源，根据格式备注，可更快被通过且邀请进群。 ▲长按扫描 往期推荐 武大94年博士年薪201万入职华为！学霸日程表曝光，简直降维打击！ 腾讯三面：40亿个QQ号码如何去重？ 我被开除了。。只因为看了骂公司的帖子 如果你喜欢本文, 请长按二维码，关注 Hollis. 转发至朋友圈，是对我最大的支持。 点个 在看 喜欢是一种感觉 在看是一种支持 ↘↘↘ 本篇文章为转载内容。原文链接：https://blog.csdn.net/hollis_chuang/article/details/121738393。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...《中国劳动统计年鉴》数据显示，我国40-59岁劳动力人口占比逐年上升，他们在面临新兴技术冲击、行业变革的同时，还要应对来自年轻一代的竞争压力。 《人民日报》曾发表一篇深度报道，聚焦中年职场转型与再发展问题，报道指出，在数字化时代背景下，中年人应主动拥抱变化，通过不断学习新技术、新知识，更新自身技能树，并积极参与职业培训和继续教育，拓宽职业发展空间。 此外，据LinkedIn（领英）发布的《中国人才趋势报告》显示，企业对具备跨界能力、持续学习力以及深厚行业经验的中高级人才需求不减反增。这进一步印证了文章中的观点：无论年龄大小，职场人士都需要设立明确目标，增强执行力，并懂得投资自己，通过不断学习实现职业生涯的可持续发展。 同时，心理学专家也强调，保持积极心态是中年人应对职场挑战的关键要素之一。正如美国心理学家卡罗尔·德韦克提出的“成长思维模式”，鼓励人们以开放的态度看待困难和挑战，相信能力可以通过努力得以提升，这对于中年职场人士打破现状、激发潜力具有深远意义。 综上所述，面对日新月异的社会变迁和职场环境，中年群体需树立长期职业规划意识，提高实际行动力，强化个人核心竞争力，并始终保持与时俱进的学习态度和积极进取的心态，以此来应对职业道路上的各种挑战，实现职业生涯的二次腾飞。

...cad32：ODBC数据源管理器 64.OptionalFeatures：打开“打开或关闭Windows功能”对话框 65.osk：打开屏幕键盘 66.perfmon.msc：计算机性能监测器 67.perfmon：计算机性能监测器 68.PowerShell：提供强大远程处理能力 69.printmanagement.msc：打印管理 70.powercfg.cpl：电源选项 71.psr：问题步骤记录器 72.Rasphone：网络连接 73.Recdisc：创建系统修复光盘 74.Resmon：资源监视器 75.Rstrui：系统还原 76.regedit.exe：注册表 77.regedt32：注册表编辑器 78.rsop.msc：组策略结果集 79.sdclt：备份状态与配置，就是查看系统是否已备份 80.secpol.msc：本地安全策略 81.services.msc：本地服务设置 82.sfc /scannow：扫描错误并复原/windows文件保护 83.sfc.exe：系统文件检查器 84.shrpubw：创建共享文件夹 85.sigverif：文件签名验证程序 86.slui：Windows激活，查看系统激活信息 87.slmgr.vbs -dlv ：显示详细的许可证信息 88.snippingtool：截图工具，支持无规则截图 89.soundrecorder：录音机，没有录音时间的限制 90.StikyNot：便笺 91.sysdm.cpl：系统属性 92.sysedit：系统配置编辑器 93.syskey：系统加密，一旦加密就不能解开，保护系统的双重密码 94.taskmgr：任务管理器(旧版) 95.TM任务管理器(新版) 96.taskschd.msc：任务计划程序 97.timedate.cpl：日期和时间 98.UserAccountControlSettings用户账户控制设置 99.utilman：辅助工具管理器 100.wf.msc：高级安全Windows防火墙 101.WFS：Windows传真和扫描 102.wiaacmgr：扫描仪和照相机向导 103.winver：关于Windows 104.wmimgmt.msc：打开windows管理体系结构(WMI) 105.write：写字板 106.wscui.cpl：操作中心 107.wuapp：Windows更新 108.wscript：windows脚本宿主设置 六、小结 键盘快捷键会大大提高使用效率，让你在外行面前显得更酷。持续更新中…感谢点赞，评论与转发，谢谢！ 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_44168588/article/details/121208530。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。