文本按行截取

学习委员

1.txt中有大量行数的文本
多线程中需要每次按设定数量，按顺序截取1.txt里面的文本，例如每次取出1000行。

有两个问题：
1.大文本取出较慢，比如这个文本有50M，每次现用现取就会有点慢。
2.按顺序取用，不能重复不能打乱顺序，比如我2线程跑的时候，第2个线程应该取出1001-2001的文本行。


我的想法是运行前读取成数组，发布时从数组里面取。或者用快速字节集取用。主要是发帖问一下各位前辈，推荐写法。
我会写，只是不知道哪种方式好，所以不用贴代码，分析一下优缺点，感谢！

斗战胜猴

无论你用 指针到文本 还是 计次=文本 都是最慢的。最好还是复制文本数组的指针，达到一次复制出1000行的文本。不知道什么原因，使用RtlMoveMemory复制指针运行完会报错，索性就不用了

  

子程序名	返回值类型	公开	备 注
数组分割_文本型
参数名	类 型	参考	可空	数组	备 注
参_数组	文本型
参_新数组长度	整数型
参_新数组	文本型
参_起始位置	整数型

变量名	类 型	静态	数组	备 注
局_新数组指针	整数型
局_数组指针	整数型
局_计次	整数型

重定义数组 (参_新数组, 假, 参_新数组长度)
局_新数组指针 ＝ PtrStrArray (参_新数组)
局_数组指针 ＝ PtrStrArray (参_数组)
计次循环首 (参_新数组长度, 局_计次)
参_新数组 [局_计次] ＝ 指针到文本 (PtrGetTableItem (局_数组指针, 局_计次 － 1 ＋ 参_新数组长度 × 参_起始位置))
计次循环尾 ()
' RtlMoveMemory_整数型 (PtrStrArray (参_新数组), PtrStrArray (参_数组) ＋ 参_新数组长度 × 参_起始位置 × 4, 参_新数组长度 × 4)

子程序名	返回值类型	公开	备 注
PtrGetTableItem	整数型
参数名	类 型	参考	可空	数组	备 注
参数_Table	整数型
参数_Index	整数型

置入代码 ({ 139, 69, 8, 139, 77, 12, 139, 4, 136, 201, 194, 8, 0 })
' mov eax,[ebp+08]
' mov ecx,[ebp+12]
' mov eax,[eax+ecx*4]
' leave
' retn 08
返回 (0)

子程序名	返回值类型	公开	备 注
PtrStrArray	整数型		取文本型数组内存指针，成功返回内存指针，失败返回#NULL
参数名	类 型	参考	可空	数组	备 注
StringArray	文本型				文本型数组

置入代码 ({ 139, 69, 8, 133, 192, 116, 5, 139, 0, 141, 64, 8, 137, 236, 93, 194, 4, 0 })
返回 (0)

DLL命令名	返回值类型	公开	备 注
RtlMoveMemory_整数型	整数型		拷贝来源内存到目标内存。无返回值。
DLL库文件名:
ntdll.dll
在DLL库中对应命令名:
RtlMoveMemory
参数名	类 型	传址	数组	备 注
lpDestination	整数型			指向目标内存的指针
lpSource	整数型			指向来源内存的指针
Length	整数型			拷贝的字节数。

.版本 2<br /> <br /> .子程序 数组分割_文本型, , 公开<br /> .参数 参_数组, 文本型, 数组<br /> .参数 参_新数组长度, 整数型<br /> .参数 参_新数组, 文本型, 参考 数组<br /> .参数 参_起始位置, 整数型, 可空<br /> .局部变量 局_新数组指针, 整数型<br /> .局部变量 局_数组指针, 整数型<br /> .局部变量 局_计次, 整数型<br /> <br /> 重定义数组 (参_新数组, 假, 参_新数组长度)<br /> 局_新数组指针 ＝ PtrStrArray (参_新数组)<br /> 局_数组指针 ＝ PtrStrArray (参_数组)<br /> .计次循环首 (参_新数组长度, 局_计次)<br />     参_新数组 [局_计次] ＝ 指针到文本 (PtrGetTableItem (局_数组指针, 局_计次 － 1 ＋ 参_新数组长度 × 参_起始位置))<br /> .计次循环尾 ()<br /> ' RtlMoveMemory_整数型 (PtrStrArray (参_新数组), PtrStrArray (参_数组) ＋ 参_新数组长度 × 参_起始位置 × 4, 参_新数组长度 × 4)<br /> <br /> .子程序 PtrGetTableItem, 整数型, 公开<br /> .参数 参数_Table, 整数型<br /> .参数 参数_Index, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 77, 12, 139, 4, 136, 201, 194, 8, 0 })<br /> ' mov eax,[ebp+08]<br /> ' mov ecx,[ebp+12]<br /> ' mov eax,[eax+ecx*4]<br /> ' leave<br /> ' retn 08<br /> 返回 (0)<br /> <br /> .子程序 PtrStrArray, 整数型, 公开, 取文本型数组内存指针，成功返回内存指针，失败返回#NULL<br /> .参数 StringArray, 文本型, 参考 数组, 文本型数组<br /> <br /> 置入代码 ({ 139, 69, 8, 133, 192, 116, 5, 139, 0, 141, 64, 8, 137, 236, 93, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> <br /> .版本 2<br /> <br /> .DLL命令 RtlMoveMemory_整数型, 整数型, "ntdll.dll", "RtlMoveMemory", 公开, 拷贝来源内存到目标内存。无返回值。<br />     .参数 lpDestination, 整数型, , 指向目标内存的指针<br />     .参数 lpSource, 整数型, , 指向来源内存的指针<br />     .参数 Length, 整数型, , 拷贝的字节数。

a4561482

用快速 字节吧  读成数组会更慢。

学习委员

a4561482 发表于 2025-7-6 00:34
用快速 字节吧  读成数组会更慢。

当真
   

hongqingfeng

觉得慢，你所有代码可以改成汇编模式，那速度嗖嗖的

笨来无一悟

慢就是数组导致的快速文本对象 寻找文本 重复若干次 就可以截取多少多少行的数据了 比分割更快

学习委员

笨来无一悟 发表于 2025-7-6 01:00
慢就是数组导致的快速文本对象 寻找文本 重复若干次 就可以截取多少多少行的数据了 比分割更快{:7 ...

我用快速字节集从文件读，然后用计次循环首拼接呢。寻找换行符也要拼接这一步的吧？

学习委员

hongqingfeng 发表于 2025-7-6 00:45
觉得慢，你所有代码可以改成汇编模式，那速度嗖嗖的

汇编我不会呀亲哥

冷冷的吹风

针对你的需求，以下是几种解决方案的分析及优缺点对比：

### 方案1：预加载整个文件到内存数组
**实现方式**：  
启动时一次性读取整个文本文件到内存中的数组（如Python的`list`），每个线程通过全局索引原子锁获取指定行范围。

**优点**：  
- **速度极快**：后续每次取文本都是内存操作（纳秒级响应）  
- **实现简单**：代码逻辑清晰（数组下标直接定位）  
- **线程安全易控**：通过原子锁（如`threading.Lock`）管理全局行索引

**缺点****：**  
- **内存占用高**：50MB文本加载到内存后，实际占用可能达100~200MB（取决于语言和编码）  
- **启动延迟**：初始化时需要完整读取文件（50MB文件约需0.5~2秒，取决于磁盘性能）

**适用场景**：  
- 内存资源充足（如服务器环境）  
- 文件大小可控（≤1GB）  
- 需要极致取用速度的场景

---

### 方案2：内存映射文件（Memory-Mapped File）
**实现方式**：  
使用`mmap`将文件映射到虚拟内存，线程通过共享映射区域按需读取。

**优点**：  
- **内存占用低**：操作系统按需加载物理页（4KB单位）  
- **零拷贝高效**：避免用户态与内核态数据复制  
- **启动瞬时完成**：映射建立即可开始操作

**缺点**：  
- **需要手动处理分行**：需解析`\n`位置（需额外记录行偏移索引）  
- **跨平台差异**：Windows/Linux的`mmap` API行为略有不同  
- **复杂度较高**：需处理字节边界和编码转换

**适用场景**：  
- 超大文件（>1GB）  
- 内存敏感环境（如嵌入式设备）  
- 允许额外开发成本

---

### 方案3：预读缓存分块
**实现方式**：  
启动时预读前N个块（如10×1000行）到队列，后台线程异步加载后续块。

**优点**：  
- **内存平衡**：动态加载，峰值内存可控  
- **减少等待**：线程从内存队列取块，与磁盘I/O解耦  
- **顺序保证**：队列自然维持顺序

**缺点**：  
- **逻辑复杂**：需实现生产-消费者模型  
- **突发延迟风险**：若消费速度 > 加载速度可能阻塞

**适用场景**：  
- 内存有限但磁盘IO较快（如SSD）  
- 允许轻微启动延迟的场景

---

### 多线程分配策略推荐
```python
# 伪代码示例（原子计数分配）
global_next_index = 0  # 原子变量（如AtomicLong）
lock = threading.Lock()

def thread_worker():
    while True:
        with lock:
            start_line = global_next_index
            end_line = start_line + 1000
            global_next_index = end_line
        # 从数据结构中提取[start_line:end_line]行
        process_chunk(get_lines(start_line, end_line))
```

---

### 终极建议
1. **50MB文件首选预加载数组**  
   - 现代服务器内存轻松支撑，代码简单性能高  
   - Python示例：  
     ```python
     with open("1.txt", "r") as f:
         lines = f.readlines()  # 一次性加载
     # 线程通过lines[start:end]取块
     ```

2. **超大规模(>10GB)考虑内存映射**  
   - 使用`mmap` + 行偏移索引表（启动时构建）

3. **避免：实时按需读取**  
   ```python
   # 不推荐！每次磁盘IO导致性能瓶颈
   def slow_get_lines(start, end):
       with open("1.txt") as f:
           return [line for i,line in enumerate(f) if start<=i<end]
   ```

### 性能对比
| 方案                | 初始化时间 | 单次取块耗时 | 内存开销 | 实现复杂度 |
|---------------------|------------|--------------|----------|------------|
| 预加载数组          | 中         | **★ 0.1ms**  | 高       | 低         |
| 内存映射文件        | **★ 低**   | 1~10ms       | 极低     | 中高       |
| 预读缓存分块        | 低         | 0.1ms        | 中       | 中         |
| 实时读取（对比组）  | 无         | 50~500ms     | 低       | 低         |

> **结论**：你的预加载思路完全正确，50MB文件大胆用方案1，百行代码内即可高效解决。

冰蓝茉莉

.版本 2
.支持库 commobj
.支持库 spec

.局部变量 每行字节数组, 字节集, , "0"
.局部变量 ksz, 快速字节集对象

ksz.从文件读 (文件地址)
每行字节数组 ＝ 分割字节集 (ksz.取字节集 (, ), { 13, 10 }, )
文件总行数 ＝ 取数组成员数 (每行字节数组)
调试输出 (“文件总行数:” ＋ 到文本 (文件总行数))



试试看我这个代码吧