20160229.CCPP体系详解(0039天)
程序片段(01):大文本数据切割与合并.c
内容概要:文本文件切割与合并
#define _CRT_SECURE_NO_WARNINGS
#include 程序片段(02):01.多线程检索内存.c+02.多线程多文件处理.c
内容概要:多线程处理数据
///01.多线程检索内存.c
#define _CRT_SECURE_NO_WARNINGS
#include
#include
char *path = "D:\\TestData\\DB\\DangDang.txt";
#define N 13180820
char **g_pp;//1.二级指针,存储一级指针数组首地址,因为一级指针数组首地址作为函数参数的时候会转化为二级指针以作处理[存储的是字符数组首地址所组成的一级指针数组首地址]
struct threads *pthread;//2.完成多线程内存检索之后方便于释放操作[统一管理]
//01构建内存数据库模型
void init(char *path)
{//(1)初始化路径
printf("init start!");
g_pp = malloc(sizeof(char*)*N);//(2)开辟一个一级指针数组,然后一样一行的进行数据读取并加载进堆内存结构体,形成内存数据库模型
memset(g_pp, '\0', sizeof(char*)*N);//(3)使用malloc();函数开辟的堆内存空间,可能存在垃圾地址,需要手动进行堆内存清理动作
FILE *pfr = fopen(path, "r");
if (pfr==NULL)
{
printf("init fail!!!");
}
else
{
for (int i = 0; i < N; i++)
{
char str[1024] = { 0 };//(4)缓冲区编程:采用自定义内存栈内存缓冲区进行数据临时汇集操作
fgets(str, 1023, pfr);//读取
int length = strlen(str);//长度
if (length>=1)
{//(5)有的时候会获取数据失败,这里是为了保证安全而进行的操作,可能存在空行等因素
g_pp[i] = malloc(sizeof(char)*length + 1);//(6)+1是为了考虑字符串结尾'\0'的操作
memset(g_pp[i], '\0', length + 1);//清空堆内存创建时期产生的垃圾内容
if (g_pp[i]!=NULL)
{//(7)填充堆内存内容,实现堆内存数据库模型单行字符串数据创建
strcpy(g_pp[i], str);
}
}
}
fclose(pfr);
}
printf("init end!");
}
//02执行内存数据库检索功能
void search(char *str)
{//(1)查找需要进行两步运算动作
for (int i = 0; i < N; i++)
{//(2)循环遍历内存数据库模型,字符串数据行
if (g_pp[i]!=NULL)
{
char *p = strstr(g_pp[i], str);
if (p!=NULL)
{//(3)检索到指定数据
printf("%s\n", g_pp[i]);
}
}
}
}
//03单条线程处理内存数据库的信息[线程+处理信息]
struct threads
{//(1)为单条线程检索信息创建辅助信息结构体
//(2)获取地址:内存数据库模型-->指针数组-->获取字符串地址,访问内存数据库当中的字符串
// 指针数组的地址是一个二级指针-->指针数组在作为函数参数的时候回自动提升为二级指针
char **ppstart;//1)指针数组的起始地址
int length;//2)往前读取多少个元素[字符串个数]
int id;//3)单条处理线程的编号
//(3)在字符串数组里边儿查找一个字符串
char *pstr;
};
//04单条线程处理内存数据库的操作
void searchthread(void *p)
{
struct threads *pinfo = p;//(1)自动类型转换,明确的指针类型决定了该指针指向内容的解析方式,用于解析结构体
for (int i = 0; i < pinfo->length; i++)
{
if (pinfo->ppstart[i]!=NULL)
{//(2)数据安全检查,防止访问到无效数据,造成异常
char *p = strstr(pinfo->ppstart[i], pinfo->pstr);//(3)对内存数据库模型当中的每一行字符串进行检索功能
if (p!=NULL)
{
printf("线程%d找到%s字符串!\n", pinfo->id, pinfo->ppstart[i]);
}
}
}
}
//05采用多线程进行数据检索动作
void searchwiththread(char *str)
{//(1)多线程检索大数据
//(2)需要进行分段儿,切割为多个线程进行数据处理[处理动作,采用指针指向的方式为内存数据库进行切割分段儿让各个线程进行分块儿处理]
//(3)多线程个数制定:一般情况下建议是CPU的逻辑内核倍数-->为了让CPU的多个逻辑内核实现负载均衡-->这里还是非理想情况之下的数据
int num = 23;
pthread = malloc(sizeof(struct threads) * 23);
memset(pthread, '\0', sizeof(struct threads) * 23);
//(4)为了管理线程的操作需要使用HANDLE
HANDLE **phd = malloc(sizeof(HANDLE) * 23);
if (N%num==0)
{//(5)每一个线程分享一个数组信息
//(6)开辟堆内存的原因是为了防止内存的自动回收释放,丢失threass
// 销毁之后,线程访问函数的内容就会发生巨大变化,也就会出错,所以必须要在堆内存上面开辟
for (int i = 0; i < num; i++)
{
pthread[i].id = i;
pthread[i].pstr = str;
pthread[i].length = N / num;//100/5=20个
pthread[i].ppstart = g_pp + i*(N / num);//起始地址-->字符串个数的划分
phd[i] = _beginthread(searchthread, 0, &pthread[i]);//创建线程,开始进行检索动作
}
}
else
{//100-->9份-->[8]100/(9-1)=12...4---[1]100%(9-1)=4-->前8线程个数:12线程处理的字符串个数+后1个线程:4处理的字符串个数
for (int i = 0; i < num-1; i++)
{
pthread[i].id = i;
pthread[i].pstr = str;
pthread[i].length = N / (num - 1);
pthread[i].ppstart = g_pp + i*(N / num - 1);
phd[i] = _beginthread(searchthread, 0, &pthread[i]);//创建线程并执行
}
{
int i = num - 1;
pthread[i].id = i;
pthread[i].pstr = str;
pthread[i].length = N % (num - 1);
pthread[i].ppstart = g_pp + i*(N / num + 1);
phd[i] = _beginthread(searchthread, 0, &pthread[i]);
}
}
WaitForMultipleObjects(num, phd, TRUE, INFINITE);
}
void main01()
{
init(path);
while (1)
{//(1)处理大数据需要逻辑严谨
char str[128] = { 0 };
scanf("%s", str);
//search(str);
searchwiththread(str);
}
system("pause");
}
//01.多线程检索:分为多少步骤进行解决?
// 1.内存检索:
// 读取并加载DangDang.txt这个文本文件数据,形成内存数据库模型
// 2.文件检索:
// 将DangDang.txt这个文本文件分成22个文本文件,让单条线程处理
// 单个文本文件,采用缓冲区编程模式,对每个文本文件当中的每行数据
// 进行字符串检索动作
//02.多线程检索[内存+文件]+CGI=完整项目:
// 多线程检索文本文件-->一条线程处理一个文本文件
//03.多线程检索内存-->多线程检索文件:
// 1.形成内存数据库-->DangDang网数据全部入进堆内存
// 2.然后挨个挨个进行多线程并发访问堆内存当中每一段儿
// 微型的项目模块儿
// 3.多线程并发处理大数据的检索功能
//04.内存数据库模型:
// 1.获取文本文件的总行数
// 2.将文本文件当中的每一行字符串载入进堆内存,形成内存数据库模型
// 1)二级指针用于存储指针数组的首地址[存储指针]
// 2)对指针数组当中的每一个指针分配一块儿堆内存,[存储字符串]
// 3.多线程并发运行,各自检索各自区间当中的数据:
// 每条线程从分块儿部分开头进行逐步检索动作
// 4.多线程加速访问,充分利用CPU资源
//05.解决内存加载慢一级不够的情况:
// 1.采用多条线程分步进行文件数据加载进堆内存的动作
// 2.检索动作一旦完成就进行对堆内存的手动释放动作
// 3.最后再汇总多条线程的检索结果-->节约内存
//06.大数据处理过程当中经常出现的问题:
// 1.分配内存的同时需要进行清空动作
// 因为malloc();函数在进行堆内开辟的过程当中
// 会产生一些垃圾数据,然而并没有进行自动垃圾处理动作
// 2.最好使用calloc();会自动进行清空动作
// 指针内存的清空动作,防止垃圾地址保留
//07.多线程处理大数据:
// 单线程检索技术含量并不高-->多线程检索技术含量更高一些,效率也更高一些
//08.相当于一条线程处理一个文件:多线程检索文件&多线程检索内存的原理
// 线程与文件绑定在一起进行数据处理
//09.多线程加速检索数据:
// 1.加速处理方案-->效率非常的高
// 2.临界区-->信号量[可以解决同时操作一个文件的特点,但是不会同时处理一个数据]///02.多线程多文件处理.c
#define _CRT_SECURE_NO_WARNINGS
#include 程序片段(03):块读写.c
内容概要:freadfwrite
#define _CRT_SECURE_NO_WARNINGS
#include 程序片段(04):01.排序.c+02.排序.c
内容概要:文件排序以及二分查找法
///01.排序.c
#define _CRT_SECURE_NO_WARNINGS
#include //(4)这里是先读取缓冲区当中的数据,然后经过排序操作,输入到另外一个文件当中去[没有对内存缓冲区当中的内容直接进行操作]
fseek(pf, sizeof(int)*(j + 1), SEEK_SET);
fwrite(&dataj, 4, 1, pf);
fseek(pf, sizeof(int)*j, SEEK_SET);
fwrite(&dataj1, 4, 1, pf);
}
}
}
showfile();//(5)内存不够的情况下下,总文件大小10G
//现有内存1G,怎么办?-->直接采用文件排序
//-->将文件当做内存进行处理
//-->内存映射文件的原理fread();&&fwrite();
// 内存缓冲区<----->文件
//-->CPU&内存-->fseek();&fread();-->指针移动&数据操作
fclose(pf);
}
//五.二进制文件二分查找法:
//01.文件排序:在哪里进行文件排序?
// 1.直接在文件当中完成排序动作
// 2.原理:
// (1).将原始文件当中的数据映射进自定义内存缓冲区当中
// (2).对内存缓冲区当中的数进行排序动作
// (3).然后将内存缓冲区当中排好序的数据写入到文件当中
//02.文本文件和二进制文件的区别?
// 直接操作文件读取情况之下:
// 1.文本文件的每一行长度都不一样:
// fseek();可以随机移动到某个指针位置,但是不能够确定
// 该指针到底移动到了哪一行数据,不能够确定,因为每一行
// 的数据都是不等长的
// 2.二进制文件的fread();&fwrite();特点:
// 共同特点:
// 每移动4个字节,就等同于移动了1个int元素
// 每移动8个字节,就等同于移动了2个int元素
// 每移动12个字节,就等同于移动了3个int元素
// 3.总结特点:直接操作文本文件[将文本文件当做内存进行操作的前提情况之下]
// 对于文本文件的随机读写动作无法确定操作的是具体的哪一行?
// 但是对于二进制文件的话,就可以随机读写,并进行二进制排序操作
// -->任意读取元素的操作:
// 任意读取元素之后-->进行排序操作
// 排序完成之后-->直接将数据写入到新文件当中
// 再直接对新文件当中的数据进行二分查找法的使用
//03.随机读写任意位置的数据:
// 1.二进制数据-->fseek(pf,0,SEEK_SET);-->偏移量决定
// 2.fseek(pf,sizeof(int)*i,SEEK_SET);-->读取任意位置的元素
// 根据字节偏移量进行数据的读取操作-->内存获取下标的方式
// 文件排序-->随机读写-->内存获取下标[冒泡排序-->快速排序]
// 文件排序-->一次读取一个,将其中的数据读取出来[插入排序]
//六.二进制数据内存排序:
//01.大数据处理流程:
// 1.将大数据信息逐个按行封装为结构体,组装成为结构体数组
// 2.在内存当中对结构体数组当中的每一个结构器进行排序操作
// 3.然后在内存当中对数据进行检索操作
// 4.再将结构体数组写入到一个二进制文件当中[后续操作]
// 以便于后期直接对文件的检索操作
//02.10G-->0.1秒的查询方式:
// 1.1000次-->二分查找法需要10次
// 2.内存映射文件:
// 二进制文件-->映射到内存当中
// 然后对内存当中的随机进行随机访问操作-->通过fseek();实现随机访问操作
// 文件的冒泡排序[从左往右,从右往左]
//03.大数据相关数据:
// CSDN-->600万行-->排序之后再进行查询操作 ///02.排序.c
#include
#include
#include 程序片段(05):CSDN.c
内容概要:大数据线性处理
#define _CRT_SECURE_NO_WARNINGS
#include char *pstr1 = str + strlen(str) + 1;
int max2 = strlen(pstr1);
if (passmaxchar *pstr2 = pstr1 + strlen(pstr1) + 1;
int max3 = strlen(pstr2);
if (emailmax//03读取并加载文本文件
void readfiletxt()
{//(1)获取每一行的最大值
FILE *pfr = fopen("D:\\TestData\\DB\\CSDN.txt", "r");
//(2)将文本文件转化到一个二进制文件再进行操作
// 先以文本模式进行源文件数据读取,
// 再以二进制模式进行数据写入新文件
FILE *pfw = fopen("D:\\TestData\\CSDN.bin", "wb");
if (pfr==NULL)
{
return;
}
else
{
while (!feof(pfr))
{
char str[256] = { 0 };
fgets(str, 255, pfr);
//getmax(str);//(3)这里是考虑最快的情况,获取每行的字符串数据信息,进行统计说明
struct csdn csdn1;
init(&csdn1, str);//(4)初始化每一个CSDN结构体数据,直到数据操作完毕再结束
//(5)将内存当中以文本文件模式读取到的数据以二进制的形式写入进指定的新文件当中
fwrite(&csdn1, sizeof(struct csdn), 1, pfw);
//(6)经过这个操作之后,文件大大的变大了
// 因为结构体为了进行对齐,会占用到很多空位
// 所以导致文件占用字节数据变大[结构体空字节占用特点,为了结构体对齐]
}
fclose(pfr);
fclose(pfw);
}
}
//04.统计文件占用字节大小
int getfilesize(char *path)
{
FILE *pfr = fopen(path, "rb");
if (pfr==NULL)
{
return -1;
}
else
{
fseek(pfr, 0, SEEK_END);//(1)直接将指针移动到文件末尾
int length = ftell(pfr);//(2)注意ftell以二进制模式打开文件进行字节占用大小的求取才准确,以文本模式打开的情况下,字节数目统计不会正确
fclose(pfr);
return length;
}
}
void main()
{
//(1)为单行数据构建堆内存结构体
/*struct csdn csdn1;
char str[100] = "bamy1 # 7618595 # [email protected]";
init(&csdn1, str);*/
//(2)统计字符串当中指定字段的最大长度
/*getmax();
printf("%d,%d,%d", namemax, passmax, emailmax);*/
//(3)获取文件的最大字节数[二进制读取的时候,是按照字节为单位进行统计的]
// 最快的获取文件占用字节大小方式
/*printf("%d", getfilesize("D:\\TestData\\DB\\CSDN.txt"));
int size = getfilesize("D:\\TestData\\DB\\CSDN.txt");*/
//(4)通过获取结构体的长度,来统计字符串的有效行数
//printf("\n%d", size / sizeof(struct csdn));
//(5)将文本文件当中的数据转存为二进制文件数据
//readfiletxt();
FILE *pfr = fopen("D:\\TestData\\CSDN.bin", "rb");
while (1)
{
printf("请输入您要读取的第N个元素:");
int N;
scanf("%d", &N);
struct csdn csdn1 = { 0 };
//1)第N个元素的索引为N-1
//2)这中间不管文件有多大,我们想读哪儿就读哪儿-->而且不会过度占用内存
//3)因为所有的结构体大小都一样,所以读取的时候非常整齐
fseek(pfr, sizeof(struct csdn)*(N - 1), SEEK_SET);//移动到指定位置进行二进制数据操作-->直接操作二进制文件
fread(&csdn1, sizeof(struct csdn), 1, pfr);
printf("\n%s,%s,%s", csdn1.name, csdn1.password, csdn1.email);
}
fclose(pfr);
system("pause");
}
//八.CSDN数据&二进制数据&随机读写文件:
//01.大数据排序操作:
// 1.数据可随机读写的前提条件:二进制数据
// 2.文本文件-->转存-->二进制文件
// 3.在数据转存过程当中:
// (1)交换-->排序:大量的数据移动操作
// (2)中间:文件在内存当中都是完整排列的
// (3)原因:文本文件当中的数据是长短不一
// (4)数据对调太过麻烦-->累死人-->索引机制
// 索引价值没有按照二进制数据的访问访问方式快
// 但是索引机制可以表面过度的数据排序,调换动作
//02.索引机制&二进制机制:优劣对比
// 索引机制:
// 优点:
// 避免调换数据动作
// 缺点:
// 创建索引过程比较慢,间接访问
// 二进制机制:优势要相比索引机制高一些
// 优点:
// 内存&文件映射,直接访问
// 缺点:
// 排序,调换位置麻烦
//03.采用一个二进制数据进行标记:
// 索引机制:记录每行的元素个数
// 1--5-->索引对应关系:获取第N行数据
// 2--6-->必须知道前面数据的大小,才能够进行索引的区间划分
// 3--7-->这中间的效率类似于链表[层级关系,一级一级的,只不过无需记录地址]
// ---->索引操作原理
//04.简单做法:
// 1.先将每行的数据对应的封装到每个结构体当中,形成结构体[数据行]数组
// 2.每个结构体的大小都是一样的,所以随机访问很方便
// 3.文件当中实现快速查找方案[索引对应于文件]
// 4.快排-->堆排-->全部用上-->索引排序
//05.大数据线性处理:
// 1.处理CSDN的Data数据
// 2.面试老前辈都有CSDN账户[数据广播]
//06.CSDN大数据处理流程:
// 1.对文本文件的数据进行按行读取
// 逐行生成结构体-->结构体数组-->存入文件
// 2.分离一行数据,进行数据测试:
// (1)先完成单行字符串的测试,在进行多行字符串的测试
// (2)先完成局部测试,在完成全局拆封是
//07.读取的最终长度统计为:正确的长度统计方式
// namemax=21-->考虑到尾部还有结尾福的情况
// passmax=42--->总结:22--43--52
// emailmax=51
//08.挨个进行数据读取:
// getmax();获取单行每列分字段最大长度-->最终进行统计
//09.载入内存再进行查询:
// 1.读取一个结构体,解析一个结构体,再进行查询动作
// 2.获取多大[总尺寸]-->判定行数
//10.存放到结构体当中还是可以进行排序:
// 这儿需要进行随机读写操作
//11.想获取那个就获取那个,想写那个就写那个:
// 如果已经排序之后,二分查找法更快
// 实现:二分查找+排序=717M-->简单 程序片段(06):索引.c
内容概要:索引与文本文件
#define _CRT_SECURE_NO_WARNINGS
#include 程序片段(07):大数据索引.c
内容概要:大数据索引
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include 程序片段(08):main.c
内容概要:大文本数据排序二分查找
#define _CRT_SECURE_NO_WARNINGS
#include