2017-2018-1 20155227 实验三 实时系统

2017-2018-1 20155227 实验三 实时系统

实验目的,实验步骤

实验过程如下。

实验三-并发程序-1

学习使用Linux命令wc(1)
基于Linux Socket程序设计实现wc(1)服务器(端口号是你学号的后6位)和客户端
客户端传一个文本文件给服务器
服务器返加文本文件中的单词数

上方提交代码
附件提交测试截图,至少要测试附件中的两个文件

使用man wc命令查看wc命令基本用法。

2017-2018-1 20155227 实验三 实时系统_第1张图片

wc命令的实现:

#include  
#include  
#include  
#include  
struct message{  
        int lines;  
        int words;  
        int max_line_length;  
        int size;  
        int chars;  
}info;  
void error_print(char str[]){  
        printf("Error:%s",str);  
}  
void init(char filename[]){  
        struct stat get_message = {};  
        FILE *fp;  
        int ret_stat = stat(filename,&get_message);/*用stat函数读取filenmae文件的信息,并将结果写到get_message结构体中*/  
        if(ret_stat == -1){//stat函数不出错则进行信息输出  
                error_print(filename);  
                return ;  
        }  
        mode_t mode = get_message.st_mode;      //接收文件信息,用于下面判断是不是目录  
        int length = 0;  
        if(S_ISDIR(mode))   //如果是目录,输出错误  
               printf("Error %s is dir\n0\t0\t0\t%s",filename,filename);  
        else{  
                info.size = get_message.st_size;    //文件字节大小 wc -c  
                fp = fopen(filename,"r");   //以只读方式打开指定文件  
                char ch;  
                int flag = 0;  
                while((ch = fgetc(fp))!=EOF){   //一直读到文件尾  
                        info.chars++;       //字符数加1 wc -m  
  
                        if(ch != '\n'){  
  
                                length++;   //记录当前行的长度 wc -L  
                        }  
                        if(ch == '\n'){  
                                info.lines ++;  //行数加1 wc -l  
                                if(length>info.max_line_length)  
                                        info.max_line_length = length;  //更新最大长度  
                                length = 0;  
                        }  
                        if(ch == '\t' || ch == ' ' || ch == '\n'){  
                                flag = 0;       //计算单词数 wc -w  
                                continue;  
                        }  
                        else{  
  
                                if(flag == 0){  
                                        info.words++;   //计算单词数 wc -w  
                                        flag = 1;  
                                }  
                        }  
                }  
                fclose(fp);  
        }  
  
}  
//计算键盘输入内容的相关信息,即参数中没有指定要打开的文件  
void EmptyFile(){  
        char ch;  
        int flag = 0;  
        int length = 0;  
  
        while((ch = getchar())!=EOF){  
               info.chars++;  
                info.size += sizeof(ch);    //字节累加  
                if(ch != '\n'){  
                        length++;  
               }  
               if(ch == '\n'){  
                        info.lines ++;  
                        if(length>info.max_line_length)  
                                info.max_line_length = length;  
                        length = 0;  
                }  
                if(ch == '\t' || ch == ' ' || ch == '\n'){  
                        flag = 0;  
                        continue;  
                }  
                else{  
  
                        if(flag == 0){  
                                info.words++;  
                               flag = 1;  
                        }  
                }  
  
        }  
}  
int main(int argc,char *argv[]){  
  
        if(argc == 2){  
                if(argv[1][0] != '-'){  
                       init(argv[1]);  
                       printf("%d %d %d %s\n",info.lines,info.words,info.size,argv[1]);  
                       return 0;  
                }  
                else{   //未指定打开文件,类似 wc -lmwcL  
                       EmptyFile();  
  
                }  
        }  
        else if(argc == 1){     //未指定打开文件和要输出的参数,(默认输出 -lwc)  
                EmptyFile();  
                printf("%d\t%d\t%d\n",info.lines,info.words,info.size);  
                return 0;  
        }  
        else if(argc == 3){  
                init(argv[2]);  
        }  
        int num;  
        while((num = getopt(argc,argv,"lwmcL"))!=-1){  
                switch(num){  
                        case 'l':  
                                printf("%d\t",info.lines);  
                                break;  
                        case 'w':  
                                printf("%d\t",info.words);  
                                break;  
                        case 'm':  
                                printf("%d\t",info.chars);  
                                break;  
                        case 'c':  
                                printf("%d\t",info.size);  
                                break;  
                        case 'L':  
                                printf("%d\t",info.max_line_length);  
                                break;  
                }  
        }  
        if(argc != 2 && argv[1][0] != '-')  //一定要判断,否则会越界  
                printf("%s\n",argv[2]);  
  
  
        return 0;  
}  

运行截图:

2017-2018-1 20155227 实验三 实时系统_第2张图片

client.c:

    #include   // sockaddr_in  
    #include    // socket  
    #include   // socket  
    #include        // printf  
    #include       // exit  
    #include       // bzero  
      
    #define SERVER_PORT 8000  
    #define BUFFER_SIZE 1024  
    #define FILE_NAME_MAX_SIZE 512  
      
    int main()  
    {  
        // 声明并初始化一个客户端的socket地址结构  
        struct sockaddr_in client_addr;  
        bzero(&client_addr, sizeof(client_addr));  
        client_addr.sin_family = AF_INET;  
        client_addr.sin_addr.s_addr = htons(INADDR_ANY);  
        client_addr.sin_port = htons(0);  
      
        // 创建socket,若成功,返回socket描述符  
        int client_socket_fd = socket(AF_INET, SOCK_STREAM, 0);  
        if(client_socket_fd < 0)  
        {  
            perror("Create Socket Failed:");  
            exit(1);  
        }  
      
        // 绑定客户端的socket和客户端的socket地址结构 非必需  
        if(-1 == (bind(client_socket_fd, (struct sockaddr*)&client_addr, sizeof(client_addr))))  
        {  
            perror("Client Bind Failed:");  
            exit(1);  
        }  
      
        // 声明一个服务器端的socket地址结构,并用服务器那边的IP地址及端口对其进行初始化,用于后面的连接  
        struct sockaddr_in server_addr;  
        bzero(&server_addr, sizeof(server_addr));  
        server_addr.sin_family = AF_INET;  
        if(inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr) == 0)  
        {  
            perror("Server IP Address Error:");  
            exit(1);  
        }  
        server_addr.sin_port = htons(SERVER_PORT);  
        socklen_t server_addr_length = sizeof(server_addr);  
      
        // 向服务器发起连接,连接成功后client_socket_fd代表了客户端和服务器的一个socket连接  
        if(connect(client_socket_fd, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
        {  
            perror("Can Not Connect To Server IP:");  
            exit(0);  
        }  
      
        // 输入文件名 并放到缓冲区buffer中等待发送  
        char file_name[FILE_NAME_MAX_SIZE+1];  
        bzero(file_name, FILE_NAME_MAX_SIZE+1);  
        printf("Please Input File Name :\t");  
        scanf("%s", file_name);  
      
        char buffer[BUFFER_SIZE];  
        bzero(buffer, BUFFER_SIZE);  
        strncpy(buffer, file_name, strlen(file_name)>BUFFER_SIZE?BUFFER_SIZE:strlen(file_name));  
          
        // 向服务器发送buffer中的数据  
        if(send(client_socket_fd, buffer, BUFFER_SIZE, 0) < 0)  
        {  
            perror("Send File Name Failed:");  
            exit(1);  
        }  
      
     
        FILE *fp = fopen(file_name, "w");  
        if(NULL == fp)  
        {  
            printf("File:\t%s Can Not Open To Write\n", file_name);  
            exit(1);  
        }  
      
        // 从服务器接收数据到buffer中  
        // 每接收一段数据,便将其写入文件中,循环直到文件接收完并写完为止  
        bzero(buffer, BUFFER_SIZE);  
        int length = 0;  
        while((length = recv(client_socket_fd, buffer, BUFFER_SIZE, 0)) > 0)  
        {  
            if(fwrite(buffer, sizeof(char), length, fp) < length)  
            {  
                printf("File:\t%s Write Failed\n", file_name);  
                break;  
            }  
            bzero(buffer, BUFFER_SIZE);  
        }  
      
        // 接收成功后,关闭文件,关闭socket  
        printf("Send File:\t%s  Successful!\n", file_name);  
        close(fp);  
        close(client_socket_fd);  
        return 0;  
    }  


server.c:

#include  // sockaddr_in  

#include   // socket  

#include  // socket  

#include       // printf  

#include      // exit  

#include      // bzero  

  

#define SERVER_PORT 8000  

#define LENGTH_OF_LISTEN_QUEUE 20  

#define BUFFER_SIZE 1024  

#define FILE_NAME_MAX_SIZE 512  





int countChar(char input[]){

    int p_input = 0;

    int count = 0;

    int word = 0;

    char ch;



    while(p_input < strlen(input)){

        ch = input[p_input];

        if(ch==' '){

            if(word){ //读取到空字符,而之前是非空字符,则说明读完了一个单词

                count++;

                word = 0;

            }

        }else{ //读取到第一个非空字符,说明是单词的开始

            word = 1;

        }

        p_input++;

    }

    return count;

}



int main(void)  

{  

    // 声明并初始化一个服务器端的socket地址结构  

    struct sockaddr_in server_addr;  

    bzero(&server_addr, sizeof(server_addr));  

    server_addr.sin_family = AF_INET;  

    server_addr.sin_addr.s_addr = htons(INADDR_ANY);  

    server_addr.sin_port = htons(SERVER_PORT);  

  

    // 创建socket,若成功,返回socket描述符  

    int server_socket_fd = socket(PF_INET, SOCK_STREAM, 0);  

    if(server_socket_fd < 0)  

    {  

        perror("Create Socket Failed:");  

        exit(1);  

    }  

    int opt = 1;  

    setsockopt(server_socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));  

  

    // 绑定socket和socket地址结构  

    if(-1 == (bind(server_socket_fd, (struct sockaddr*)&server_addr, sizeof(server_addr))))  

    {  

        perror("Server Bind Failed:");  

        exit(1);  

    }  

      

    // socket监听  

    if(-1 == (listen(server_socket_fd, LENGTH_OF_LISTEN_QUEUE)))  

    {  

        perror("Server Listen Failed:");  

        exit(1);  

    }  

  

    while(1)  

    {  

        // 定义客户端的socket地址结构  

        struct sockaddr_in client_addr;  

        socklen_t client_addr_length = sizeof(client_addr);  

  

        // 接受连接请求,返回一个新的socket(描述符),这个新socket用于同连接的客户端通信  

        // accept函数会把连接到的客户端信息写到client_addr中  

        int new_server_socket_fd = accept(server_socket_fd, (struct sockaddr*)&client_addr, &client_addr_length); 

        char ch; 

        if(new_server_socket_fd < 0)  

        {  

            perror("Server Accept Failed:");  

            break;  

        }  

  

        // recv函数接收数据到缓冲区buffer中  

        char buffer[BUFFER_SIZE];  

        bzero(buffer, BUFFER_SIZE);  

        if(recv(new_server_socket_fd, buffer, BUFFER_SIZE, 0) < 0)  

        {  

            perror("Server Recieve Data Failed:");  

            break;  

        }  

  

        // 然后从buffer(缓冲区)拷贝到file_name中  

        char file_name[FILE_NAME_MAX_SIZE+1];  

        bzero(file_name, FILE_NAME_MAX_SIZE+1);  

        strncpy(file_name, buffer, strlen(buffer)>FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(buffer));  

        printf("%s\n", file_name);  

  

        FILE *fp = fopen(file_name, "r");  

        if(NULL == fp)  

        {  

            printf("File:%s Not Found\n", file_name);  

        }  

        else  

        {  

            bzero(buffer, BUFFER_SIZE);  

            int length = 0;  

            

            while((length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)  

            {  

                if(send(new_server_socket_fd, buffer, length, 0) < 0)  

                {  

                    printf("Send File:%s Failed./n", file_name);  

                    break;  

                }  

                bzero(buffer, BUFFER_SIZE);  

            }  

  

    

     

    char input[256];

    int p_input = 0;

    int count = 0;

fgets(input,256,fp);

// 关闭文件  

            fclose(fp);  

            printf("File:%s Recieve Successful!\n", file_name); 

     count = countChar(input);

    printf("Your words count:\n%d\n",count);



        }  

        // 关闭与客户端的连接  

        close(new_server_socket_fd);  

    }  

    // 关闭监听用的socket  

    close(server_socket_fd);  

    return 0;  

}  

运行截图:

2017-2018-1 20155227 实验三 实时系统_第3张图片

2017-2018-1 20155227 实验三 实时系统_第4张图片

实验三-并发程序-2

使用多线程实现wc服务器并使用同步互斥机制保证计数正确
上方提交代码
下方提交测试
对比单线程版本的性能,并分析原因

通过man -k命令查看与创建进程相关的函数:

2017-2018-1 20155227 实验三 实时系统_第5张图片

多线程编程时要调用pthread_create()函数创建新的进程,在运行时要使用-lpthread链接库函数。

核心代码为:

pthread_t pid;
        if(pthread_create(&pid, NULL, process_client, &client_sock) < 0){
            printf("pthread_create error\n");

运行结果:

2017-2018-1 20155227 实验三 实时系统_第6张图片

实验三-并发程序-3

交叉编译多线程版本服务器并部署到实验箱中
PC机作客户端测试wc服务器
提交测试截图

由于时间原因并没有做。

实验中的问题和解决过程

实验过程的一些思考

什么是多线程?

多线程编程的目的,就是"最大限度地利用CPU资源",当某一线程的处理不需要占用CPU而只和I/O,OEMBIOS等资源打交道时,让需要占用CPU资源的其它线程有机会获得CPU资源。每个程序执行时都会产生一个进程,而每一个进程至少要有一个主线程。多线程就是在一个进程内有多个线程。从而使一个应用程序有了多任务的功能。

wc命令
wc -c filename:显示一个文件的字节数

  wc -m filename:显示一个文件的字符数

  wc -l filename:显示一个文件的行数

  wc -L filename:显示一个文件中的最长行的长度

  wc -w filename:显示一个文件的字数

新学到的知识点

  • wc命令
  • 多线程编程

代码托管

实验体会

本次实验的实验内容虽然不多,但实现起来很复杂,虽然课前已经花时间做了一点,但是课上的时间内还是没有完成。

参考资料

  • Linux下C编写基本的多线程socket服务器

转载于:https://www.cnblogs.com/guyanlin/p/7840768.html

你可能感兴趣的:(2017-2018-1 20155227 实验三 实时系统)