67.文件映射为内存进行操作与多线程 以及 文件映射到内存根据索引进行内存来实现读取多线程操作...

最新推荐文章于 2024-06-18 16:15:35 发布
最新推荐文章于 2024-06-18 16:15:35 发布
阅读量139 收藏 1
点赞数
原文链接：http://www.cnblogs.com/xiaochi/p/8443477.html
版权

问题引出:

//有限的额内存情况怎么干活
//索引载入内存，多线程
//索引映射为内存

 

一.载入内存,按行读取进行多线程

  • 定义路径以及其他信息 
    1 char path[256] = "kaifangX.txt";
2 char indexpath[256] = "indexkf.txt";
3 #define  N 20151574

     

  • 创建索引
    1 struct index
2 {
3     int *pindex;//地址
4     int length;
5 }allindex = {0};

     

  • 读取文件到内存 
     1 void readmem()
 2 {
 3     allindex.length = N;
 4     allindex.pindex = calloc(N, sizeof(int));
 5 
 6 
 7     FILE *pfw = fopen(indexpath, "rb");
 8     fread(allindex.pindex, sizeof(int),N,pfw);
 9     fclose(pfw);
10 }

     

  • 创建索引的线程结构体,每一个线程读取length的长度的行数 
     1 void readmem()
 2 {
 3     allindex.length = N;
 4     allindex.pindex = calloc(N, sizeof(int));
 5 
 6 
 7     FILE *pfw = fopen(indexpath, "rb");
 8     fread(allindex.pindex, sizeof(int),N,pfw);
 9     fclose(pfw);
10 }

     

  • 多线程函数 
     1 void run(void *p)
 2 {
 3     struct info *pi = p;//参数
 4     for (int  i = 0; i < pi->length-1; i++)//限定
 5     {
 6         //起始地址到结束地址之间是一个字符串,可以读取出来
 7         char *start = infoall.pfilestart + pi->pstart[i];//起始地址
 8         char *end = infoall.pfilestart + pi->pstart[i + 1];//结束地址
 9 
10 
11 
12         char *str = calloc(500, 1);//分配内存用于拷贝字符串，文件整块，没有/0,有/n
13         if (str != NULL)//分配成功
14         {
15             strncpy(str, start, pi->pstart[i + 1] - pi->pstart[i ]);//拷贝字符串
16             if (str != NULL)
17             {
18                 char *ps = strstr(str, pi->findstr);//检索
19                 if (ps != NULL)
20                 {
21                     printf("%s", str);
22                 }
23             }    
24         
25         }
26         free(str);//释放
27     }
28 }

     

  • 载入到内存进行多线程检索 
     1 //根据内存进行多线程索引
 2 void test1()
 3 {
 4     printf("please input");
 5     char str[100];
 6     scanf("%s", str);
 7 #define nthread 100
 8     struct info pthread[nthread] = {0};
 9     HANDLE hd[nthread] = { 0 };//线程参数，线程句柄
10     if (N%nthread==0)
11     {
12         for (int i = 0; i < nthread; i++)
13         {
14             pthread[i].id = i;
15             pthread[i].length = N / nthread;
16             pthread[i].pstart = allindex.pindex + i*(N / nthread);
17             strcpy(pthread[i].findstr,str );
18             _beginthread(run, 0, &pthread[i]);
19         }
20     }
21     else
22     {
23         for (int i = 0; i < nthread-1; i++)
24         {
25             pthread[i].id = i;
26             pthread[i].length = N / (nthread - 1);
27             pthread[i].pstart = allindex.pindex + i*(N / (nthread - 1));
28             strcpy(pthread[i].findstr, str);
29             _beginthread(run, 0, &pthread[i]);
30         }
31         int i = nthread - 1;
32         pthread[i].id = i;
33         pthread[i].length = N % (nthread - 1);
34         pthread[i].pstart = allindex.pindex + i*(N / (nthread - 1));
35         strcpy(pthread[i].findstr, str);
36         _beginthread(run, 0, &pthread[i]);
37 
38     }
39     WaitForMultipleObjects(nthread, hd, TRUE, INFINITE);//等待
40 
41 
42     system("pause");
43 
44 }

     

二.内存映射进行多线程检索

  • 创建文件映射内存的首地址和尾地址 
     1 struct
 2 {
 3     //文本文件首尾地址
 4     char *pfilestart;
 5     char *pfileend;
 6     //索引文件首尾地址
 7     char *pindexfilestart;
 8     char *pindexfileend;
 9 
10 }infoall = {0};

     

  • 映射文本文件到内存，文件是独家享有 
     1 void map1()
 2 {
 3     //打开一个文件
 4     HANDLE hfile = CreateFileA(path, GENERIC_READ | GENERIC_WRITE, 0, NULL,
 5         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 6 
 7     if (hfile == INVALID_HANDLE_VALUE)
 8     {
 9         printf("打开文件失败");
10         system("pause");
11     }
12     //获取文件大小
13     printf("\n%d", GetFileSize(hfile, NULL));
14 
15     HANDLE hmap = CreateFileMappingA(hfile,
16         NULL, PAGE_READWRITE | SEC_COMMIT,//读写
17         0,
18         GetFileSize(hfile, NULL) + 1,//大小
19         NULL);
20 
21     if (hmap == NULL)
22     {
23         printf("映射失败");
24         CloseHandle(hfile);
25         system("pause");
26     }
27 
28     //创建一个指针，存储映射以后的首地址
29     PVOID pvfile = MapViewOfFile(hmap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
30     
31     if (pvfile == NULL)
32     {
33         printf("指针映射失败");
34         CloseHandle(hfile);
35         CloseHandle(hmap);
36         system("pause");
37 
38     }
39     puts("映射成功");
40     char *pstart = pvfile;//首地址
41     char *pend = pstart + GetFileSize(hfile, NULL);//结束地址
42     infoall.pfileend = pend;//保存地址
43     infoall.pfilestart = pstart;
44 }

     

  • 映射索引文件 
     1 void map2()
 2 {
 3     HANDLE hfile = CreateFileA(indexpath, GENERIC_READ | GENERIC_WRITE, 0, NULL,
 4         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);//打开一个文件
 5 
 6     if (hfile == INVALID_HANDLE_VALUE)
 7     {
 8         printf("打开文件失败");
 9         system("pause");
10     }
11     printf("\n%d", GetFileSize(hfile, NULL));//获取文件大小
12     HANDLE hmap = CreateFileMappingA(hfile,
13         NULL, PAGE_READWRITE | SEC_COMMIT,//读写
14         0,
15         GetFileSize(hfile, NULL) + 1,//大小
16         NULL);
17     if (hmap == NULL)
18     {
19         printf("映射失败");
20         CloseHandle(hfile);
21         system("pause");
22     }
23     PVOID pvfile = MapViewOfFile(hmap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
24     //创建一个指针，存储映射以后的首地址
25     if (pvfile == NULL)
26     {
27         printf("指针映射失败");
28         CloseHandle(hfile);
29         CloseHandle(hmap);
30         system("pause");
31 
32     }
33     puts("映射成功");
34     char *pstart = pvfile;//首地址
35     char *pend = pstart + GetFileSize(hfile, NULL);//结束地址
36     infoall.pindexfileend = pend;//保存地址
37     infoall.pindexfilestart = pstart;
38 }

     

  • 内存映射多线程结构体 
    1 struct minfo
2 {
3     int*pstart;
4     int length;//0   9 10
5     int id;
6     char findstr[20];
7 };
  • 内存映射多线程函数 
     1 void mrun(void *p)
 2 {
 3     struct minfo *pi = p;
 4     for (int i = 0; i < pi->length - 1; i++)
 5     {
 6         char *start = infoall.pfilestart + pi->pstart[i];//起始地址
 7         char *end = infoall.pfilestart + pi->pstart[i + 1];//结束地址
 8         char *str = calloc(500, 1);//分配内存用于拷贝字符串
 9         if (str != NULL)//分配成功
10         {
11             strncpy(str, start, pi->pstart[i + 1] - pi->pstart[i]);//拷贝字符串
12             if (str != NULL)
13             {
14                 char *ps = strstr(str, pi->findstr);
15                 if (ps != NULL)
16                 {
17                     printf("%s", str);
18                 }
19             }
20 
21         }
22         free(str);//释放
23 
24 
25     }
26 }

     

  • 创建多线程 
     1 void test2()
 2 {
 3     printf("please input");
 4     char str[100];
 5     scanf("%s", str);
 6 #define nthread 100
 7     struct minfo pthread[nthread] = { 0 };
 8     HANDLE hd[nthread] = { 0 };//线程参数，线程句柄
 9     if (N%nthread == 0)
10     {
11         for (int i = 0; i < nthread; i++)
12         {
13             pthread[i].id = i;
14             pthread[i].length = N / nthread;
15             pthread[i].pstart =   ((int*)infoall.pindexfilestart) + i*(N / nthread);
16             strcpy(pthread[i].findstr, str);
17             _beginthread(mrun, 0, &pthread[i]);
18         }
19 
20 
21     }
22     else
23     {
24         for (int i = 0; i < nthread - 1; i++)
25         {
26             pthread[i].id = i;
27             pthread[i].length = N / (nthread - 1);
    　　           //索引对应的位置信息
    28             pthread[i].pstart = ((int*)infoall.pindexfilestart) + i*(N / (nthread - 1));
29             strcpy(pthread[i].findstr, str);
30             _beginthread(mrun, 0, &pthread[i]);
31         }
32         int i = nthread - 1;
33         pthread[i].id = i;
34         pthread[i].length = N % (nthread - 1);
35         pthread[i].pstart = ((int*)infoall.pindexfilestart) + i*(N / (nthread - 1));
36         strcpy(pthread[i].findstr, str);
37         _beginthread(mrun, 0, &pthread[i]);
38 
39     }
40     WaitForMultipleObjects(nthread, hd, TRUE, INFINITE);
41 
42 
43     system("pause");
44 
45 }

     

完整代码:

  1 #define _CRT_SECURE_NO_WARNINGS
  2 #include<stdio.h>
  3 #include<stdlib.h>
  4 #include<Windows.h>
  5 #include<process.h>
  6 //有限的额内存情况怎么干活
  7 //索引载入内存，多线程
  8 //索引映射为内存
  9 
 10 
 11 char path[256] = "kaifangX.txt";
 12 char indexpath[256] = "indexkf.txt";
 13 #define  N 20151574
 14 
 15 //创建文件映射内存的首地址和尾地址
 16 struct
 17 {
 18     //文本文件首尾地址
 19     char *pfilestart;
 20     char *pfileend;
 21     //索引文件首尾地址
 22     char *pindexfilestart;
 23     char *pindexfileend;
 24 
 25 }infoall = {0};
 26 
 27 
 28 //映射文本文件到内存，文件是独家享有
 29 void map1()
 30 {
 31     //打开一个文件
 32     HANDLE hfile = CreateFileA(path, GENERIC_READ | GENERIC_WRITE, 0, NULL,
 33         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 34 
 35     if (hfile == INVALID_HANDLE_VALUE)
 36     {
 37         printf("打开文件失败");
 38         system("pause");
 39     }
 40     //获取文件大小
 41     printf("\n%d", GetFileSize(hfile, NULL));
 42 
 43     HANDLE hmap = CreateFileMappingA(hfile,
 44         NULL, PAGE_READWRITE | SEC_COMMIT,//读写
 45         0,
 46         GetFileSize(hfile, NULL) + 1,//大小
 47         NULL);
 48 
 49     if (hmap == NULL)
 50     {
 51         printf("映射失败");
 52         CloseHandle(hfile);
 53         system("pause");
 54     }
 55 
 56     //创建一个指针，存储映射以后的首地址
 57     PVOID pvfile = MapViewOfFile(hmap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
 58     
 59     if (pvfile == NULL)
 60     {
 61         printf("指针映射失败");
 62         CloseHandle(hfile);
 63         CloseHandle(hmap);
 64         system("pause");
 65 
 66     }
 67     puts("映射成功");
 68     char *pstart = pvfile;//首地址
 69     char *pend = pstart + GetFileSize(hfile, NULL);//结束地址
 70     infoall.pfileend = pend;//保存地址
 71     infoall.pfilestart = pstart;
 72 }
 73 
 74 //映射索引文件到内存
 75 void map2()
 76 {
 77     HANDLE hfile = CreateFileA(indexpath, GENERIC_READ | GENERIC_WRITE, 0, NULL,
 78         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);//打开一个文件
 79 
 80     if (hfile == INVALID_HANDLE_VALUE)
 81     {
 82         printf("打开文件失败");
 83         system("pause");
 84     }
 85     printf("\n%d", GetFileSize(hfile, NULL));//获取文件大小
 86     HANDLE hmap = CreateFileMappingA(hfile,
 87         NULL, PAGE_READWRITE | SEC_COMMIT,//读写
 88         0,
 89         GetFileSize(hfile, NULL) + 1,//大小
 90         NULL);
 91     if (hmap == NULL)
 92     {
 93         printf("映射失败");
 94         CloseHandle(hfile);
 95         system("pause");
 96     }
 97     PVOID pvfile = MapViewOfFile(hmap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
 98     //创建一个指针，存储映射以后的首地址
 99     if (pvfile == NULL)
100     {
101         printf("指针映射失败");
102         CloseHandle(hfile);
103         CloseHandle(hmap);
104         system("pause");
105 
106     }
107     puts("映射成功");
108     char *pstart = pvfile;//首地址
109     char *pend = pstart + GetFileSize(hfile, NULL);//结束地址
110     infoall.pindexfileend = pend;//保存地址
111     infoall.pindexfilestart = pstart;
112 }
113 
114 //读取索引到内存
115 struct index
116 {
117     int *pindex;//地址
118     int length;
119 }allindex = {0};
120 
121 //读取文件到内存
122 void readmem()
123 {
124     allindex.length = N;
125     allindex.pindex = calloc(N, sizeof(int));
126 
127 
128     FILE *pfw = fopen(indexpath, "rb");
129     fread(allindex.pindex, sizeof(int),N,pfw);
130     fclose(pfw);
131 }
132 
133 //创建索引的线程结构体,每一个线程读取length的长度的行数
134 struct info
135 {
136     int*pstart;//索引的收地址
137     int length;//长度
138     int id;//编号
139     char findstr[20];//查找的字符串
140 };
141 
142 //多线程函数
143 void run(void *p)
144 {
145     struct info *pi = p;//参数
146     for (int  i = 0; i < pi->length-1; i++)//限定
147     {
148         //起始地址到结束地址之间是一个字符串,可以读取出来
149         char *start = infoall.pfilestart + pi->pstart[i];//起始地址
150         char *end = infoall.pfilestart + pi->pstart[i + 1];//结束地址
151 
152 
153 
154         char *str = calloc(500, 1);//分配内存用于拷贝字符串，文件整块，没有/0,有/n
155         if (str != NULL)//分配成功
156         {
157             strncpy(str, start, pi->pstart[i + 1] - pi->pstart[i ]);//拷贝字符串
158             if (str != NULL)
159             {
160                 char *ps = strstr(str, pi->findstr);//检索
161                 if (ps != NULL)
162                 {
163                     printf("%s", str);
164                 }
165             }    
166         
167         }
168         free(str);//释放
169     }
170 }
171 
172 //根据内存进行多线程索引
173 void test1()
174 {
175     printf("please input");
176     char str[100];
177     scanf("%s", str);
178 #define nthread 100
179     struct info pthread[nthread] = {0};
180     HANDLE hd[nthread] = { 0 };//线程参数，线程句柄
181     if (N%nthread==0)
182     {
183         for (int i = 0; i < nthread; i++)
184         {
185             pthread[i].id = i;
186             pthread[i].length = N / nthread;
187             pthread[i].pstart = allindex.pindex + i*(N / nthread);
188             strcpy(pthread[i].findstr,str );
189             _beginthread(run, 0, &pthread[i]);
190         }
191     }
192     else
193     {
194         for (int i = 0; i < nthread-1; i++)
195         {
196             pthread[i].id = i;
197             pthread[i].length = N / (nthread - 1);
198             pthread[i].pstart = allindex.pindex + i*(N / (nthread - 1));
199             strcpy(pthread[i].findstr, str);
200             _beginthread(run, 0, &pthread[i]);
201         }
202         int i = nthread - 1;
203         pthread[i].id = i;
204         pthread[i].length = N % (nthread - 1);
205         pthread[i].pstart = allindex.pindex + i*(N / (nthread - 1));
206         strcpy(pthread[i].findstr, str);
207         _beginthread(run, 0, &pthread[i]);
208 
209     }
210     WaitForMultipleObjects(nthread, hd, TRUE, INFINITE);//等待
211 
212 
213     system("pause");
214 
215 }
216 
217 
218 //内存映射结构体
219 struct minfo
220 {
221     int*pstart;
222     int length;//0   9 10
223     int id;
224     char findstr[20];
225 };
226 
227 void mrun(void *p)
228 {
229     struct minfo *pi = p;
230     for (int i = 0; i < pi->length - 1; i++)
231     {
232         char *start = infoall.pfilestart + pi->pstart[i];//起始地址
233         char *end = infoall.pfilestart + pi->pstart[i + 1];//结束地址
234         char *str = calloc(500, 1);//分配内存用于拷贝字符串
235         if (str != NULL)//分配成功
236         {
237             strncpy(str, start, pi->pstart[i + 1] - pi->pstart[i]);//拷贝字符串
238             if (str != NULL)
239             {
240                 char *ps = strstr(str, pi->findstr);
241                 if (ps != NULL)
242                 {
243                     printf("%s", str);
244                 }
245             }
246 
247         }
248         free(str);//释放
249 
250 
251     }
252 }
253 
254 //根据内存映射进行多线程索引
255 void test2()
256 {
257     printf("please input");
258     char str[100];
259     scanf("%s", str);
260 #define nthread 100
261     struct minfo pthread[nthread] = { 0 };
262     HANDLE hd[nthread] = { 0 };//线程参数，线程句柄
263     if (N%nthread == 0)
264     {
265         for (int i = 0; i < nthread; i++)
266         {
267             pthread[i].id = i;
268             pthread[i].length = N / nthread;
269             pthread[i].pstart =   ((int*)infoall.pindexfilestart) + i*(N / nthread);
270             strcpy(pthread[i].findstr, str);
271             _beginthread(mrun, 0, &pthread[i]);
272         }
273 
274 
275     }
276     else
277     {
278         for (int i = 0; i < nthread - 1; i++)
279         {
280             pthread[i].id = i;
281             pthread[i].length = N / (nthread - 1);
282             pthread[i].pstart = ((int*)infoall.pindexfilestart) + i*(N / (nthread - 1));
283             strcpy(pthread[i].findstr, str);
284             _beginthread(mrun, 0, &pthread[i]);
285         }
286         int i = nthread - 1;
287         pthread[i].id = i;
288         pthread[i].length = N % (nthread - 1);
289         pthread[i].pstart = ((int*)infoall.pindexfilestart) + i*(N / (nthread - 1));
290         strcpy(pthread[i].findstr, str);
291         _beginthread(mrun, 0, &pthread[i]);
292 
293     }
294     WaitForMultipleObjects(nthread, hd, TRUE, INFINITE);
295 
296 
297     system("pause");
298 
299 }
300 
301 void main()
302 {
303     //readmem();
304     map1();//一旦被映射，文件被锁定
305     map2();
306     //test1();
307     test2();
308     getchar();
309 }

 

转载于:https://www.cnblogs.com/xiaochi/p/8443477.html

weixin_30721077
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MappedTensor：Matlab中更好的内存映射文件
02-03
它利用内存映射（memory-mapping）技术，使得大型数据文件能够像数组一样被操作，而无需一次性加载到内存中，从而降低了对内存的需求，提高了程序运行效率。这种技术在大数据分析、机器学习和深度学习等领域具有广泛...
基于MIT6.S081的《操作系统》实验报告共5个实验.zip
04-21
你还将学习到分页和分段的区别，以及如何通过页表来实现内存保护。 4. **陷阱处理（traps.md）** 陷阱，也称为中断，是硬件对异常或特殊请求的响应。在实验中，你将学习如何设置陷阱处理程序，处理硬件中断、软件...
c程序代码的内存布局（学好C的基础)
bangju6321的博客
05-21 137
一个程序本质上都是由 BSS 段、data段、text段三个组成的。这样的概念在当前的计算机程序设计中是很重要的一个基本概念，而且在嵌入式系统的设计中也非常重要，牵涉到嵌入式系统运行时的内存大小分配，存储单元占用空间大小的问题。 BSS段：在采用段式内存管理的架构中，BSS段（bss segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block S...
内存映射文件
sunning9001的专栏
03-22 615
The primary benefit of memory mapping a file is increasing I/O performance, especially when used on large files.  memery mapped file 主要的优势是提供I/O的效率，尤其在处理大文件上面。 Most modern operating system
搜索引擎之内存映射快速索引文件
yoki2009的专栏
07-01 1739
搜索引擎之利用内存映射快速索引文件  用户在通过关键字检索信息时,如果反馈的内容在3S之内是适度范围,如果10s了一般用户就会感觉难以忍受了,所以如何提高对用户的反馈速度就成了搜索引擎技术中一个瓶颈. 每天都会有成千上万的网页产生并且背爬虫程序下载到服务器中存储起来,并建立了反向索引,可以想象这个索引表是一个多么大的数据文件,用户查询时,对这么大的一个文件做搜索,并且同时可能还有N
64.文件载入内存进行多线程以及根据索引文件进行多线程索引
weixin_30378311的博客
02-10 84
一.文件载入内存进行多线程检索 获取并定义行数以及定义索引和文本的路径 1 char path[256] = "kaifangX.txt"; 2 char indexpath[256] = "indexkaifangX.txt"; 3 #define N 20151574 索引的结构体 1 //索引内存结构体 2 struct index 3 { 4...
.NET 4.0 中使用内存映射文件（二）
weixin_30394633的博客
08-03 116
在前面，你已经看到如何使用内存映射文件来轻松访问一个文件的内容，通过一些简单的内存操作。接下来的步骤就是学习如何使用这个知识在你的应用程序中和程序间分享内存。　　当映射一个文件内容到内存中的时候，除了其他事情外，你需要指定在哪个磁盘上放文件和你想要映射文件的哪个部分。这个很简单，但是也有不是显而易见的，就是你要多次映射相同的文件，即使映射区是相同的或是重叠的(图2)。 　　 　　图2. 文...
基于Matlab内存映射文件案例（源码+数据+使用说明）.rar
05-27
在Matlab环境中，它允许用户将大文件的部分或全部内容映射到内存中，这样可以像操作数组一样操作文件，而无需一次性加载整个文件，从而节省内存并提高处理速度。本案例将详细介绍如何在Matlab中使用内存映射文件，并...
计算机软件-商业源码-利用内存映射文件作快速的全文检索.zip
05-23
在利用内存映射文件进行全文检索时，首先会将大文件（如文档库）映射到内存，这样可以避免频繁的磁盘I/O操作，提高检索速度。这是因为磁盘I/O是系统中最慢的部分，而内存访问则快得多。通过内存映射，文件的读取和...
精选_内存映射文件_源码打包
03-06
内存映射文件（Memory-Mapped File）是一种在操作系统层面实现高效数据访问的技术，它允许将文件直接映射到进程的虚拟地址空间中，使得程序可以像操作内存一样操作文件，无需通过传统的I/O函数进行读写。这种方式...
内存映射文件原理
qq_14989227的博客
02-15 2615
一直都对内存映射文件这个概念很模糊，不知道它和虚拟内存有什么区别，而且映射这个词也很让人迷茫，今天终于搞清楚了。。。下面，我先解释一下我对映射这个词的理解，再区分一下几个容易混淆的概念，之后，什么是内存映射就很明朗了。 原理首先，“映射”这个词，就和数学课上说的“一一映射”是一个意思，就是建立一种一一对应关系，在这里主要是只 硬盘上文件 的位置与进程 逻辑地址空间中 一块大小相同的区域之间的一一对...
多线程之间、使用共享内存、实现图片的数据通信：包括POSIX共享内存（shm_open 和 mmap虚拟内存）、系统调用（shmat物理存储器）、内存映射文件等方法
最新发布
Hali_Botebie的博客
06-18 730
共享内存是进程间通信（IPC）的重要方式之一，可以让多个进程访问相同的内存区域，从而实现数据共享。
linux学习之旅（22）----内存空间映射（多进程、多线程拷贝）
孔晨瑞的博客
03-22 1473
mmap()函数用来将文件或者设备空间映射到内存中，这样对文件的读写就可以直接通过指针来操作，而不需要read/write函数。这样就会加快文件操作的速度。 void *mmap(void *addr,size_t length,int prot,int flags,int fd,off_t offset); 函数功能： 将文件或者设备空间映射到内存中。 参数说明： （1）addr：文...
Java中用内存映射处理大文件
weixin_30800807的博客
09-16 60
　　在处理大文件时，如果利用普通的FileInputStream 或者FileOutputStream 抑或RandomAccessFile 来进行频繁的读写操作，都将导致进程因频繁读写外存而降低速度.如下为一个对比实验。 package test; import java.io.BufferedInputStream; import java.io.FileInputStream;...
1) 设计一个文件系统的索引结构，描述逻辑结构与物理索引结构之间的关系； 2) 设计文件目录，描述文件名与文件物理结构之中的映射关系； 3) 定义作业； 4) 设计文件建立； 5）设计文件系统的其它功能；
06-04
2) 文件目录（File Directory）是文件系统中用于存储文件名与文件物理结构之间映射关系的数据结构。通常包括文件名、文件属性、文件大小、文件创建日期等字段，以及一个指向FAT或DAT的指针，用于记录文件的逻辑结构...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值