Linux I/O 系统调用完整对比分析

1. 概述

Linux 提供了丰富的 I/O 系统调用，每种都有其特定的用途和优势。本文将详细分析这些系统调用的特点、使用场景和性能特征。

2. 系统调用详细对比

2.1 基本读写函数

pread/pwrite
#include <unistd.h>// 位置指定读取/写入
ssize_t pread(int fd, void *buf, size_t count, off_t offset);
ssize_t pwrite(int int fd, const void *buf, size_t count, off_t offset);

特点：

  • 原子操作（读取/写入 + 位置指定）
  • 不改变文件描述符的当前位置
  • 线程安全
read/write
#include <unistd.h>// 基本读取/写入
ssize_t read(int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);

特点：

  • 最基本的 I/O 操作
  • 会改变文件描述符的当前位置
  • 相对简单但功能有限

2.2 分散/聚集 I/O 函数

preadv/pwritev
#include <sys/uio.h>// 位置指定的分散读取/聚集写入
ssize_t preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset);
ssize_t pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset);
preadv2/pwritev2
#define _GNU_SOURCE
#include <sys/uio.h>// 带标志的增强版分散/聚集 I/O
ssize_t preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);

2.3 资源限制函数

prlimit64
#include <sys/resource.h>// 获取/设置进程资源限制
int prlimit64(pid_t pid, int resource, const struct rlimit64 *new_limit, struct rlimit64 *old_limit);

3. 功能对比表

函数位置指定分散/聚集标志控制原子性跨平台
read/write❌❌❌⚠️✅
pread/pwrite✅❌❌✅✅
readv/writev❌✅❌⚠️✅
preadv/pwritev✅✅❌✅✅
preadv2/pwritev2✅✅✅✅❌
prlimit64❌❌❌❌✅

4. 实际示例代码

4.1 基础读写对比

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/uio.h>
#include <string.h>
#include <errno.h>
#include <time.h>// 创建测试文件
void create_test_file(const char *filename) {int fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0644);if (fd == -1) {perror("创建文件失败");return;}const char *content = "Line 1: This is the first line of test data.\n""Line 2: This is the second line of test data.\n""Line 3: This is the third line of test data.\n""Line 4: This is the fourth line of test data.\n""Line 5: This is the fifth and final line.\n";write(fd, content, strlen(content));close(fd);printf("创建测试文件: %s\n", filename);
}// read/pread 性能对比
void compare_basic_io(const char *filename) {int fd = open(filename, O_RDONLY);if (fd == -1) {perror("打开文件失败");return;}char buffer[100];ssize_t bytes_read;struct timespec start, end;printf("\n=== 基础 I/O 对比 ===\n");// 使用 read (会改变文件位置)printf("1. read 测试:\n");clock_gettime(CLOCK_MONOTONIC, &start);bytes_read = read(fd, buffer, 50);clock_gettime(CLOCK_MONOTONIC, &end);buffer[bytes_read] = '\0';printf("   读取 %zd 字节: %.30s...\n", bytes_read, buffer);printf("   当前文件位置: %ld\n", (long)lseek(fd, 0, SEEK_CUR));// 使用 pread (不改变文件位置)printf("2. pread 测试:\n");clock_gettime(CLOCK_MONOTONIC, &start);bytes_read = pread(fd, buffer, 50, 0);  // 从开头读取clock_gettime(CLOCK_MONOTONIC, &end);buffer[bytes_read] = '\0';printf("   读取 %zd 字节: %.30s...\n", bytes_read, buffer);printf("   文件位置仍为: %ld\n", (long)lseek(fd, 0, SEEK_CUR));close(fd);
}// 分散/聚集 I/O 示例
void demonstrate_vector_io(const char *filename) {int fd = open(filename, O_RDONLY);if (fd == -1) {perror("打开文件失败");return;}printf("\n=== 分散/聚集 I/O 示例 ===\n");// 设置分散读取缓冲区char buffer1[20], buffer2[30], buffer3[25];struct iovec iov[3];iov[0].iov_base = buffer1;iov[0].iov_len = sizeof(buffer1) - 1;iov[1].iov_base = buffer2;iov[1].iov_len = sizeof(buffer2) - 1;iov[2].iov_base = buffer3;iov[2].iov_len = sizeof(buffer3) - 1;printf("分散读取设置:\n");printf("  缓冲区1: %zu 字节\n", iov[0].iov_len);printf("  缓冲区2: %zu 字节\n", iov[1].iov_len);printf("  缓冲区3: %zu 字节\n", iov[2].iov_len);// 使用 preadv 一次性读取到多个缓冲区ssize_t total_bytes = preadv(fd, iov, 3, 0);  // 从文件开头开始读取printf("总共读取: %zd 字节\n", total_bytes);if (total_bytes > 0) {buffer1[iov[0].iov_len] = '\0';buffer2[iov[1].iov_len] = '\0';buffer3[iov[2].iov_len] = '\0';printf("读取结果:\n");printf("  缓冲区1: %s\n", buffer1);printf("  缓冲区2: %s\n", buffer2);printf("  缓冲区3: %s\n", buffer3);}close(fd);
}// 资源限制示例
void demonstrate_resource_limits() {printf("\n=== 资源限制示例 ===\n");struct rlimit64 limit;// 获取当前进程的文件大小限制if (prlimit64(0, RLIMIT_FSIZE, NULL, &limit) == 0) {printf("文件大小限制:\n");printf("  软限制: %lld\n", (long long)limit.rlim_cur);printf("  硬限制: %lld\n", (long long)limit.rlim_max);}// 获取内存限制if (prlimit64(0, RLIMIT_AS, NULL, &limit) == 0) {printf("虚拟内存限制:\n");if (limit.rlim_cur == RLIM64_INFINITY) {printf("  软限制: 无限制\n");} else {printf("  软限制: %lld 字节 (%.2f MB)\n", (long long)limit.rlim_cur,(double)limit.rlim_cur / (1024 * 1024));}if (limit.rlim_max == RLIM64_INFINITY) {printf("  硬限制: 无限制\n");} else {printf("  硬限制: %lld 字节 (%.2f MB)\n", (long long)limit.rlim_max,(double)limit.rlim_max / (1024 * 1024));}}// 获取打开文件数限制if (prlimit64(0, RLIMIT_NOFILE, NULL, &limit) == 0) {printf("文件描述符限制:\n");printf("  软限制: %lld\n", (long long)limit.rlim_cur);printf("  硬限制: %lld\n", (long long)limit.rlim_max);}
}int main() {const char *test_file = "io_test_file.txt";printf("=== Linux I/O 系统调用对比分析 ===\n");// 创建测试文件create_test_file(test_file);// 基础 I/O 对比compare_basic_io(test_file);// 分散/聚集 I/O 示例demonstrate_vector_io(test_file);// 资源限制示例demonstrate_resource_limits();// 清理unlink(test_file);printf("\n=== 使用建议 ===\n");printf("选择指南:\n");printf("1. 简单读写: 使用 read/write\n");printf("2. 需要指定位置: 使用 pread/pwrite\n");printf("3. 多缓冲区操作: 使用 preadv/pwritev\n");printf("4. 需要高级控制: 使用 preadv2/pwritev2\n");printf("5. 资源限制管理: 使用 prlimit64\n");return 0;
}

4.2 性能基准测试

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/uio.h>
#include <time.h>
#include <string.h>#define ITERATIONS 10000
#define BUFFER_SIZE 1024// 性能测试结构体
struct performance_test {const char *name;double (*test_func)(int fd, const char *filename);
};// read 性能测试
double test_read_performance(int fd, const char *filename) {char buffer[BUFFER_SIZE];struct timespec start, end;clock_gettime(CLOCK_MONOTONIC, &start);for (int i = 0; i < ITERATIONS; i++) {lseek(fd, 0, SEEK_SET);  // 重置到文件开头read(fd, buffer, sizeof(buffer));}clock_gettime(CLOCK_MONOTONIC, &end);return (end.tv_sec - start.tv_sec) * 1000000.0 + (end.tv_nsec - start.tv_nsec) / 1000.0;  // 微秒
}// pread 性能测试
double test_pread_performance(int fd, const char *filename) {char buffer[BUFFER_SIZE];struct timespec start, end;clock_gettime(CLOCK_MONOTONIC, &start);for (int i = 0; i < ITERATIONS; i++) {pread(fd, buffer, sizeof(buffer), 0);  // 始终从位置0读取}clock_gettime(CLOCK_MONOTONIC, &end);return (end.tv_sec - start.tv_sec) * 1000000.0 + (end.tv_nsec - start.tv_nsec) / 1000.0;  // 微秒
}// readv 性能测试
double test_readv_performance(int fd, const char *filename) {char buffer1[256], buffer2[256], buffer3[256], buffer4[256];struct iovec iov[4];struct timespec start, end;// 设置分散读取iov[0].iov_base = buffer1;iov[0].iov_len = sizeof(buffer1);iov[1].iov_base = buffer2;iov[1].iov_len = sizeof(buffer2);iov[2].iov_base = buffer3;iov[2].iov_len = sizeof(buffer3);iov[3].iov_base = buffer4;iov[3].iov_len = sizeof(buffer4);clock_gettime(CLOCK_MONOTONIC, &start);for (int i = 0; i < ITERATIONS; i++) {lseek(fd, 0, SEEK_SET);readv(fd, iov, 4);}clock_gettime(CLOCK_MONOTONIC, &end);return (end.tv_sec - start.tv_sec) * 1000000.0 + (end.tv_nsec - start.tv_nsec) / 1000.0;  // 微秒
}// preadv 性能测试
double test_preadv_performance(int fd, const char *filename) {char buffer1[256], buffer2[256], buffer3[256], buffer4[256];struct iovec iov[4];struct timespec start, end;// 设置分散读取iov[0].iov_base = buffer1;iov[0].iov_len = sizeof(buffer1);iov[1].iov_base = buffer2;iov[1].iov_len = sizeof(buffer2);iov[2].iov_base = buffer3;iov[2].iov_len = sizeof(buffer3);iov[3].iov_base = buffer4;iov[3].iov_len = sizeof(buffer4);clock_gettime(CLOCK_MONOTONIC, &start);for (int i = 0; i < ITERATIONS; i++) {preadv(fd, iov, 4, 0);  // 始终从位置0读取}clock_gettime(CLOCK_MONOTONIC, &end);return (end.tv_sec - start.tv_sec) * 1000000.0 + (end.tv_nsec - start.tv_nsec) / 1000.0;  // 微秒
}void run_performance_benchmark() {const char *test_file = "benchmark_test.dat";int fd;printf("=== I/O 性能基准测试 ===\n");// 创建大测试文件fd = open(test_file, O_CREAT | O_WRONLY | O_TRUNC, 0644);if (fd != -1) {char *buffer = malloc(1024 * 1024);  // 1MB 缓冲区if (buffer) {for (int i = 0; i < 10; i++) {  // 创建 10MB 文件write(fd, buffer, 1024 * 1024);}free(buffer);}close(fd);}// 打开文件进行读取测试fd = open(test_file, O_RDONLY);if (fd == -1) {perror("打开测试文件失败");return;}struct performance_test tests[] = {{"read", test_read_performance},{"pread", test_pread_performance},{"readv", test_readv_performance},{"preadv", test_preadv_performance},{NULL, NULL}};printf("%-10s %-15s %-15s\n", "函数", "耗时(微秒)", "平均耗时(纳秒)");printf("%-10s %-15s %-15s\n", "----", "----------", "--------------");for (int i = 0; tests[i].name; i++) {double total_time = tests[i].test_func(fd, test_file);double avg_time = total_time * 1000.0 / ITERATIONS;printf("%-10s %-15.2f %-15.2f\n", tests[i].name, total_time, avg_time);}close(fd);unlink(test_file);printf("\n性能分析:\n");printf("1. pread 比 read 略慢 (位置指定开销)\n");printf("2. readv/preadv 在多缓冲区场景下更高效\n");printf("3. preadv2/pwritev2 提供更多控制选项\n");printf("4. 选择应基于具体使用场景\n");
}int main() {printf("=== Linux I/O 系统调用完整对比分析 ===\n\n");// 运行性能基准测试run_performance_benchmark();printf("\n=== 详细功能对比 ===\n");printf("pread vs read:\n");printf("  • pread: 指定位置读取，不改变文件位置\n");printf("  • read: 顺序读取，会改变文件位置\n");printf("\n");printf("preadv vs pread:\n");printf("  • preadv: 分散读取到多个缓冲区\n");printf("  • pread: 读取到单个缓冲区\n");printf("\n");printf("preadv2 vs preadv:\n");printf("  • preadv2: 支持额外标志控制\n");printf("  • preadv: 基本的分散读取功能\n");printf("\n");printf("prlimit64:\n");printf("  • 用于获取和设置进程资源限制\n");printf("  • 支持 64 位资源限制值\n");printf("  • 可以操作其他进程的资源限制\n");printf("\n=== 实际应用建议 ===\n");printf("1. 日志文件读写: 使用 pread/pwrite\n");printf("2. 数据库存储引擎: 使用 preadv/pwritev\n");printf("3. 高性能网络服务: 使用 preadv2/pwritev2\n");printf("4. 系统资源管理: 使用 prlimit64\n");printf("5. 简单文件操作: 使用 read/write\n");return 0;
}

4.3 实际应用场景演示

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/uio.h>
#include <string.h>
#include <errno.h>
#include <sys/resource.h>// 日志文件读取示例
void log_file_reader_example() {printf("=== 日志文件读取场景 ===\n");// 创建模拟日志文件const char *log_file = "application.log";int fd = open(log_file, O_CREAT | O_WRONLY | O_TRUNC, 0644);if (fd != -1) {const char *log_entries[] = {"2023-01-01 10:00:00 INFO Application started\n","2023-01-01 10:00:01 DEBUG Loading configuration\n","2023-01-01 10:00:02 WARN Low memory warning\n","2023-01-01 10:00:03 ERROR Database connection failed\n","2023-01-01 10:00:04 INFO Recovery attempt started\n"};for (int i = 0; i < 5; i++) {write(fd, log_entries[i], strlen(log_entries[i]));}close(fd);}// 使用 pread 读取特定时间段的日志fd = open(log_file, O_RDONLY);if (fd != -1) {char buffer[256];printf("读取最后一条日志记录:\n");// 从文件末尾附近读取ssize_t bytes_read = pread(fd, buffer, sizeof(buffer) - 1, 150);if (bytes_read > 0) {buffer[bytes_read] = '\0';printf("  %s", buffer);}close(fd);}unlink(log_file);
}// 数据库页读取示例
void database_page_reader_example() {printf("\n=== 数据库页读取场景 ===\n");const char *db_file = "database_pages.dat";int fd = open(db_file, O_CREAT | O_WRONLY | O_TRUNC, 0644);if (fd != -1) {// 创建模拟的数据库页char page_data[4096];for (int page = 0; page < 10; page++) {snprintf(page_data, sizeof(page_data), "Page %d: Database page content with ID=%d and timestamp=%ld\n",page, page * 1000, time(NULL));write(fd, page_data, strlen(page_data));}close(fd);}// 使用 preadv 读取多个数据库页fd = open(db_file, O_RDONLY);if (fd != -1) {char page1[1024], page2[1024], page3[1024];struct iovec iov[3];// 设置分散读取iov[0].iov_base = page1;iov[0].iov_len = sizeof(page1) - 1;iov[1].iov_base = page2;iov[1].iov_len = sizeof(page2) - 1;iov[2].iov_base = page3;iov[2].iov_len = sizeof(page3) - 1;printf("使用 preadv 读取多个数据库页:\n");ssize_t total_bytes = preadv(fd, iov, 3, 0);  // 从开头读取printf("  总共读取: %zd 字节\n", total_bytes);if (total_bytes > 0) {page1[iov[0].iov_len] = '\0';page2[iov[1].iov_len] = '\0';page3[iov[2].iov_len] = '\0';printf("  页1: %.50s...\n", page1);printf("  页2: %.50s...\n", page2);printf("  页3: %.50s...\n", page3);}close(fd);}unlink(db_file);
}// 网络数据包处理示例
void network_packet_processor_example() {printf("\n=== 网络数据包处理场景 ===\n");// 模拟网络数据包结构struct packet_header {uint32_t magic;uint16_t version;uint16_t type;uint32_t length;uint32_t checksum;} __attribute__((packed));struct packet_payload {char data[1024];};// 创建测试数据包文件const char *packet_file = "network_packets.dat";int fd = open(packet_file, O_CREAT | O_WRONLY | O_TRUNC, 0644);if (fd != -1) {// 写入多个数据包for (int i = 0; i < 3; i++) {struct packet_header header = {.magic = 0x12345678,.version = 1,.type = i,.length = 100,.checksum = 0xABCDEF00 + i};char payload[1024];snprintf(payload, sizeof(payload), "Packet %d payload data with timestamp %ld", i, time(NULL));write(fd, &header, sizeof(header));write(fd, payload, strlen(payload) + 1);}close(fd);}// 使用 preadv2 读取数据包（如果支持）fd = open(packet_file, O_RDONLY);if (fd != -1) {struct packet_header headers[3];char payloads[3][256];struct iovec iov[6];  // 3个头部 + 3个载荷// 设置分散读取结构for (int i = 0; i < 3; i++) {iov[i*2].iov_base = &headers[i];iov[i*2].iov_len = sizeof(struct packet_header);iov[i*2+1].iov_base = payloads[i];iov[i*2+1].iov_len = sizeof(payloads[i]) - 1;}printf("使用分散读取处理网络数据包:\n");ssize_t bytes_read = preadv(fd, iov, 6, 0);printf("  读取字节数: %zd\n", bytes_read);if (bytes_read > 0) {for (int i = 0; i < 3; i++) {printf("  数据包 %d:\n", i);printf("    魔数: 0x%08X\n", headers[i].magic);printf("    版本: %d\n", headers[i].version);printf("    类型: %d\n", headers[i].type);printf("    长度: %d\n", headers[i].length);printf("    校验: 0x%08X\n", headers[i].checksum);payloads[i][iov[i*2+1].iov_len] = '\0';printf("    载荷: %.50s...\n", payloads[i]);printf("\n");}}close(fd);}unlink(packet_file);
}// 资源限制管理示例
void resource_limit_management_example() {printf("\n=== 资源限制管理场景 ===\n");struct rlimit64 old_limit, new_limit;// 获取当前文件大小限制if (prlimit64(0, RLIMIT_FSIZE, NULL, &old_limit) == 0) {printf("当前文件大小限制:\n");if (old_limit.rlim_cur == RLIM64_INFINITY) {printf("  软限制: 无限制\n");} else {printf("  软限制: %lld 字节 (%.2f GB)\n", (long long)old_limit.rlim_cur,(double)old_limit.rlim_cur / (1024 * 1024 * 1024));}}// 获取打开文件数限制if (prlimit64(0, RLIMIT_NOFILE, NULL, &old_limit) == 0) {printf("当前文件描述符限制:\n");printf("  软限制: %lld\n", (long long)old_limit.rlim_cur);printf("  硬限制: %lld\n", (long long)old_limit.rlim_max);}// 获取内存限制if (prlimit64(0, RLIMIT_AS, NULL, &old_limit) == 0) {printf("当前虚拟内存限制:\n");if (old_limit.rlim_cur == RLIM64_INFINITY) {printf("  软限制: 无限制\n");} else {printf("  软限制: %lld 字节 (%.2f GB)\n", (long long)old_limit.rlim_cur,(double)old_limit.rlim_cur / (1024 * 1024 * 1024));}}printf("\n资源限制管理最佳实践:\n");printf("1. 合理设置文件大小限制防止磁盘填满\n");printf("2. 适当增加文件描述符限制支持高并发\n");printf("3. 监控内存使用防止内存泄漏\n");printf("4. 使用 prlimit64 动态调整资源限制\n");
}int main() {printf("=== Linux I/O 系统调用应用场景演示 ===\n\n");// 日志文件读取场景log_file_reader_example();// 数据库页读取场景database_page_reader_example();// 网络数据包处理场景network_packet_processor_example();// 资源限制管理场景resource_limit_management_example();printf("\n=== 总结 ===\n");printf("I/O 系统调用选择指南:\n");printf("\n");printf("┌─────────────┬────────────────────────────────────┐\n");printf("│ 场景        │ 推荐函数                              │\n");printf("├─────────────┼────────────────────────────────────┤\n");printf("│ 简单读写    │ read/write                            │\n");printf("│ 位置指定    │ pread/pwrite                          │\n");printf("│ 多缓冲区    │ readv/writev                          │\n");printf("│ 位置+多缓冲 │ preadv/pwritev                        │\n");printf("│ 高级控制    │ preadv2/pwritev2                      │\n");printf("│ 资源限制    │ prlimit64                             │\n");printf("└─────────────┴────────────────────────────────────┘\n");printf("\n");printf("性能优化建议:\n");printf("1. 批量操作减少系统调用次数\n");printf("2. 合理选择缓冲区大小\n");printf("3. 使用位置指定避免文件位置移动\n");printf("4. 分散/聚集 I/O 减少内存拷贝\n");printf("5. 合理设置资源限制防止系统过载\n");return 0;
}

5. 编译和运行说明

# 编译示例程序
gcc -o io_comparison_example1 example1.c
gcc -o io_comparison_example2 example2.c
gcc -o io_comparison_example3 example3.c# 运行示例
./io_comparison_example1
./io_comparison_example2
./io_comparison_example3

6. 系统要求检查

# 检查内核版本
uname -r# 检查 glibc 版本
ldd --version# 检查系统调用支持
grep -E "(pread|pwrite|prlimit)" /usr/include/asm/unistd_64.h# 查看文件系统性能
hdparm -Tt /dev/sda  # 硬盘性能测试

7. 重要注意事项

  1. 原子性: pread/pwrite 操作是原子的
  2. 位置独立: 不改变文件描述符的当前位置
  3. 错误处理: 始终检查返回值和 errno
  4. 内存对齐: 在某些架构上有对齐要求
  5. 权限检查: 确保有足够的权限进行操作
  6. 资源清理: 及时关闭文件描述符

8. 最佳实践总结

// 安全的 I/O 操作封装
ssize_t safe_pread(int fd, void *buf, size_t count, off_t offset) {if (fd < 0 || !buf || count == 0) {errno = EINVAL;return -1;}ssize_t result;do {result = pread(fd, buf, count, offset);} while (result == -1 && errno == EINTR);return result;
}// 安全的分散读取封装
ssize_t safe_preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset) {if (fd < 0 || !iov || iovcnt <= 0 || iovcnt > IOV_MAX) {errno = EINVAL;return -1;}ssize_t result;do {result = preadv(fd, iov, iovcnt, offset);} while (result == -1 && errno == EINTR);return result;
}// 资源限制检查
int check_resource_limits() {struct rlimit64 limit;// 检查文件大小限制if (prlimit64(0, RLIMIT_FSIZE, NULL, &limit) == 0) {if (limit.rlim_cur != RLIM64_INFINITY && limit.rlim_cur < 1024 * 1024) {printf("警告: 文件大小限制过小 (%lld 字节)\n", (long long)limit.rlim_cur);}}// 检查文件描述符限制if (prlimit64(0, RLIMIT_NOFILE, NULL, &limit) == 0) {if (limit.rlim_cur < 1024) {printf("警告: 文件描述符限制过小 (%lld)\n", (long long)limit.rlim_cur);}}return 0;
}

这些示例全面展示了 Linux I/O 系统调用的功能特点、使用方法和实际应用场景，帮助开发者根据具体需求选择合适的 I/O 操作方式

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.pswp.cn/web/91643.shtml
繁体地址，请注明出处：http://hk.pswp.cn/web/91643.shtml
英文地址，请注明出处：http://en.pswp.cn/web/91643.shtml

如若内容造成侵权/违法违规/事实不符，请联系英文站点网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

TiDB集群部署

TiDB集群部署

架构&#xff1a; tidb–3台&#xff0c;pd–3台&#xff0c;tikv–3台 8c16g200g 1x2.2x.2x7.124 1x2.2x.2x7.148 1x2.2x.2x7.87 1x2.2x.2x7.93 1x2.2x.2x7.127 1x2.2x.2x7.104 pd-3台 4c8g100g 1x2.2x.2x7.143 1x2.2x.2x7.132 1x2.2x.2x7.91 1、下载安装包 #注&#xff1a;我…
阅读更多...
C#中对于List的多种排序方式

C#中对于List的多种排序方式

在 C# 中给 List<AI> 排序&#xff0c;只要 明确排序规则&#xff08;比如按某个字段、某几个字段、或外部规则&#xff09;&#xff0c;就能用下面几种常见写法。下面全部基于这个示例类&#xff1a;public class AI {public int country; // 国家编号public int pr…
阅读更多...
Spring框架中Bean的生命周期：源码解析与最佳实践

Spring框架中Bean的生命周期：源码解析与最佳实践

第1章&#xff1a;Spring Bean生命周期概述1.1 什么是Spring Bean生命周期&#xff1f;定义&#xff1a;Spring Bean生命周期是指从Bean的创建、初始化、使用到销毁的完整过程&#xff0c;由Spring容器严格管理 。核心思想是Spring容器通过IoC&#xff08;控制反转&#xff09;…
阅读更多...
【51单片机6位数码管密码锁】2022-10-15

【51单片机6位数码管密码锁】2022-10-15

缘由六位密码器设计连接LED-嵌入式-CSDN问答 矩阵51单片机密码锁,回复:https://bbs.csdn.net/topics/392713242_智者知已应修善业的博客-CSDN博客 #include "REG52.h" unsigned char code smgduan[]{0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x…
阅读更多...
‌我的第一个开源项目：跃动的心

‌我的第一个开源项目：跃动的心

还是一个编程初学者时&#xff0c;我怀着激动的心情完成了人生第一个开源项目——一个用HTML5 Canvas制作的动态跳动爱心效果。这个项目虽然简单&#xff0c;却让我深刻体会到了开源分享的快乐和技术创造的魅力。 壹、项目灵感 这个项目的灵感来源于浏览网页时&#xff0c;被各…
阅读更多...
技术演进中的开发沉思-53 DELPHI VCL系列：windows的消息（下）：TApplication窗体

技术演进中的开发沉思-53 DELPHI VCL系列：windows的消息（下）：TApplication窗体

今天我们梳理下关于TApplication的窗体消息下半部分的内容。前面也说过&#xff0c;在 Delphi 的世界里&#xff0c;TApplication 就像一位经验丰富的总工程师&#xff0c;而主窗体则是它倾注心血打造的核心建筑。如果你第一次在实验室里敲出 Delphi 代码时&#xff0c;屏幕上弹…
阅读更多...
cesium FBO（四）自定义相机渲染到Canvas（离屏渲染）

cesium FBO（四）自定义相机渲染到Canvas（离屏渲染）

前面几节的例子是将Cesium默认的相机渲染到纹理&#xff08;RTT&#xff09;或Canvas&#xff0c;这片文章讲解如何将自定义的一个camera的画面渲染到Canvas上&#xff0c;有了前面几篇的基础了&#xff0c;也能将自定义的画面渲染纹理、也可以灰度处理&#xff0c;原理是一样的…
阅读更多...
双机并联无功环流抑制虚拟阻抗VSG控制【simulink仿真模型实现】

双机并联无功环流抑制虚拟阻抗VSG控制【simulink仿真模型实现】

双机并联虚拟同步发电机&#xff08;VSG&#xff09;系统中&#xff0c;因线路阻抗不匹配及参数差异&#xff0c;易引发无功环流。本方案在传统VSG控制基础上&#xff0c;引入自适应虚拟阻抗环节。其核心在于&#xff1a;实时检测两机间无功环流分量&#xff0c;据此动态调节各…
阅读更多...
python测试总结

python测试总结

测试题的基础知识点总结 1.循环求和 for循环步长&#xff08;range(2,101,2)&#xff09; while循环条件判断&#xff08;i%20&#xff09; 生成器表达式&#xff08;sum(i for i in range )&#xff09; 所以&#xff1a;sum(range(1,101,2))&#xff08;奇数和&#xff09;和…
阅读更多...
识别和分类恶意软件样本的工具YARA

识别和分类恶意软件样本的工具YARA

YARA 是一个用于识别和分类恶意软件样本的工具，广泛应用于恶意软件分析、威胁情报、入侵检测等领域。它通过编写规则（YARA Rules）来匹配文件中的特定字符串、十六进制模式、正则表达式等特征。 一、YARA 的基本使用方法 1. 安装 YARA Linux（Ubuntu/Debian） sudo apt-ge…
阅读更多...
GaussDB 约束的语法

GaussDB 约束的语法

1 约束的作用约束是作用于数据表中列上的规则&#xff0c;用于限制表中数据的类型。约束的存在保证了数据库中数据的精确性和可靠性。约束有列级和表级之分&#xff0c;列级约束作用于单一的列&#xff0c;而表级约束作用于整张数据表。下面是 GaussDB SQL 中常用的约束。NOT …
阅读更多...
SecurityContextHolder 管理安全上下文的核心组件详解

SecurityContextHolder 管理安全上下文的核心组件详解

SecurityContextHolder 管理安全上下文的核心组件详解在 Spring Security 中&#xff0c;SecurityContextHolder 是​​安全上下文&#xff08;Security Context&#xff09;的核心存储容器​​&#xff0c;其核心作用是​​在当前线程中保存当前用户的认证信息&#xff08;如用…
阅读更多...
c++详解系列（引用指针）

c++详解系列（引用指针）

目录 1.什么是引用 2.引用的定义 3.引用的特性 4.引用的使用 4.1引用传参 4.2传引用返回 5.const引用&#xff08;在引用的定义前用const修饰&#xff09; 5.1对于引用 5.2对于指针 6.引用&指针 总结 1.什么是引用 引用就是给变量起别名&#xff0c;一个变量可以…
阅读更多...
深度学习loss总结（二）

深度学习loss总结（二）

对于目前深度学习主流任务学习，loss的设置至关重要。下面就不同任务的loss设置进行如下总结： （1）目标检测 2D/3D目标检测中的 Loss（损失函数）是训练模型时优化目标的核心，通常包括位置、类别、尺寸、方向等多个方面。以下是目前 常见的 2D 和 3D 目标检测 Loss 分类与…
阅读更多...
【Linux网络】netstat 的 -anptu 各个参数各自表示什么意思？

【Linux网络】netstat 的 -anptu 各个参数各自表示什么意思？

netstat 是一个网络统计工具&#xff0c;它可以显示网络连接、路由表、接口统计、伪装连接和多播成员资格。在 netstat 命令中&#xff0c;不同的参数可以用来定制输出的内容。 你提到的 -anptu 参数组合各自的功能如下&#xff1a; -a (all): 显示所有活动的连接和监听端口。它…
阅读更多...
[硬件电路-115]：模拟电路 - 信号处理电路 - 功能放大器工作分类、工作原理、常见芯片

[硬件电路-115]：模拟电路 - 信号处理电路 - 功能放大器工作分类、工作原理、常见芯片

功能放大器是以特定功能为核心的集成化放大电路&#xff0c;通过将运算放大器与外围电阻、电容等元件集成在单一芯片中&#xff0c;实现标准化、高性能的信号放大功能。其核心优势在于简化设计流程、提升系统稳定性&#xff0c;并针对特定应用场景优化性能参数。以下从定义、分…
阅读更多...
双网卡UDP广播通信机制详解

双网卡UDP广播通信机制详解

UDP广播通信机制详解 一、通信流程分析 发送阶段 通过Client.Bind(192.168.0.3, 60000)将UDP套接字绑定到指定网卡和端口设置RemoteHost "255.255.255.255"实现全网段广播数据流向&#xff1a;192.168.0.3:60000 → 255.255.255.255:50000 接收阶段 设备响应数据应返…
阅读更多...
从遮挡难题到精准测量：激光频率梳技术如何实现深孔 3D 轮廓的 2um 级重复精度？

从遮挡难题到精准测量：激光频率梳技术如何实现深孔 3D 轮廓的 2um 级重复精度？

一、深孔 3D 轮廓测量的遮挡困境深孔结构&#xff08;如航空发动机燃油喷嘴孔、模具冷却孔&#xff09;因孔深大&#xff08;常超 100mm&#xff09;、深径比高&#xff08;&#xff1e;10:1&#xff09;&#xff0c;其 3D 轮廓测量长期受限于光学遮挡难题。传统光学测量技术&a…
阅读更多...
.NET 依赖注入(DI)全面解析

.NET 依赖注入(DI)全面解析

文章目录一、依赖注入核心原理1. 控制反转(IoC)与DI关系2. .NET DI核心组件二、服务生命周期1. 三种生命周期类型三、DI容器实现原理1. 服务注册流程2. 服务解析流程四、高级实现方法1. 工厂模式注册2. 泛型服务注册3. 多实现解决方案五、ASP.NET Core中的DI集成1. 控制器注入2…
阅读更多...
K8S部署ELK（二）：部署Kafka消息队列

K8S部署ELK（二）：部署Kafka消息队列

目录 1. Kafka 简介 1.1 Kafka 核心概念 &#xff08;1&#xff09;消息系统 vs. 流处理平台 &#xff08;2&#xff09;核心组件 1.2 Kafka 核心特性 &#xff08;1&#xff09;高吞吐 & 低延迟 &#xff08;2&#xff09;持久化存储 &#xff08;3&#xff09;分…
阅读更多...
最新文章

Copyright @ 2022~2023