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

Posted 乐舞歌不是可爱送

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了2017-2018-1 20155302 实验三 实时系统相关的知识,希望对你有一定的参考价值。

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

任务一

•学习使用Linux命令wc(1)

•基于Linux Socket程序设计实现wc(1)服务器(端口号是你学号的后6位)和客户端

•客户端传一个文本文件给服务器

•服务器返加文本文件中的单词数

man wc     指令来查询wc命令参数

客户端代码:

#include<netinet/in.h>  // sockaddr_in 
#include<sys/types.h>  // socket 
#include<sys/socket.h>  // socket 
#include<stdio.h>    // printf 
#include<stdlib.h>    // exit 
#include<string.h>    // 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 On Server:\\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("Receive File:\\t%s From Server IP Successful!\\n", file_name); 
  close(fp); 
  close(client_socket_fd);
  char *argv[]={"wc","-w",file_name,0};
  execvp("wc",argv);
  return 0; 
} 

服务器代码:

#include<netinet/in.h> // sockaddr_in 
#include<sys/types.h>  // socket 
#include<sys/socket.h> // socket 
#include<stdio.h>    // printf 
#include<stdlib.h>   // exit 
#include<string.h>   // bzero 
  
#define SERVER_PORT 8000 
#define LENGTH_OF_LISTEN_QUEUE 20 
#define BUFFER_SIZE 1024 
#define FILE_NAME_MAX_SIZE 512 
  
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); 
    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); 
      } 
  
      // 关闭文件 
      fclose(fp); 
      printf("File:%s Transfer Successful!\\n", file_name); 
    } 
    // 关闭与客户端的连接 
    close(new_server_socket_fd); 
  } 
  // 关闭监听用的socket 
  close(server_socket_fd); 
  return 0; 
} 

实验截图:

任务二

使用多线程实现wc服务器并使用同步互斥机制保证计数正确

上方提交代码

下方提交测试

对比单线程版本的性能,并分析原因

同步与互斥的相关概念:

线程的同步和互斥  
{   同步  
    {  
        同步:指的是多任务(线程)按照约定的顺序相互配合完成一件事情  
        同步机制基于信号量提出,信号量来决定线程是继续运行还是阻塞等待  
        P---V操作  
        信号量是一种受保护的变量(信号量的值是非负整数)  
        {  
            初始化  
            P操作(申请资源)// 信号量 - 1  
            V操作(释放资源)// 信号量 + 1  
        }  
    }  
    互斥  
    {  
        互斥:保证共享数据资源操作的完整性  
    }  
}  


线程间互斥  
{  
    互斥锁主要是用来保护临界资源(任何时候最多只能有一个线程能访问该资源)  
    #include<phtread.h>  
      
    int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr); // 初始化互斥锁  
    mutex:  互斥锁  
    attr:   互斥锁属性 // NULL表示缺省属性  
    返回值:成功: 0  
            出错:返回错误号  
      
    int pthread_mutex_lock(pthread_mutex_t *mutex);     // 申请互斥锁  
    mutex:  互斥锁  
    返回值:成功: 0  
            出错:-1  
      
    int pthread_mutex_unlock(pthread_mutex_t *mutex);   // 释放互斥锁  
    mutex:  互斥锁  
    返回值:成功: 0  
            出错:返回错误号  
      
      
              
}  

互斥锁:

互斥锁是一种通过简单的加锁的方法来控制对共享资源的存取,用于解决线程间资源访问的唯一性问题。互斥锁有上锁和解锁两种状态,在同一时刻只能有一个线程掌握某个互斥的锁,拥有上锁状态的线程可以对共享资源进行操作。若其他线程希望对一个已经上了锁的互斥锁上锁,则该线程会被挂起,直到上锁的线程释放掉互斥锁为止。 
操作互斥锁的基本函数有:1.pthread_mutex_init   ——互斥锁初始化;2.pthread_mutex_lock——互斥锁上锁(阻塞版);3.pthread_mutex_trtylock——互斥锁上锁(非阻塞版);4.pthread_mutex_unlock——互斥锁解锁;5.pthread_mutex_destory——消除互斥锁。 
线程互斥锁的数据类型是pthread_mutex_t,在使用前,要对其进行初始化,有以下两种方法: 
静态初始化:可以把常量PTHREAD_MUTEX_INITIALIZER赋给静态分配的互斥锁变量; 
动态初始化:在申请内存之后,通过pthread_mutex_init进行初始化,在释放内存前需要调用pthread_mutex_destroy。 

客户端代码:

char file_name[FILE_NAME_MAX_SIZE+1];
    bzero(file_name, FILE_NAME_MAX_SIZE+1);
    printf("Please Input File Name On Server:\\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中的数据
    send(client_socket,buffer,BUFFER_SIZE,0);

    FILE * fp = fopen(file_name,"r");
    if(NULL == fp )
    {
        printf("File:\\t%s Not Found\\n", file_name);
        exit(1);
    }
    else
    {
            bzero(buffer, BUFFER_SIZE);
            int file_block_length = 0;
            while( (file_block_length = fread(buffer,sizeof(char),BUFFER_SIZE, fp))>0)
            {
                //printf("file_block_length = %d\\n",file_block_length);
                //发送buffer中的字符串到服务器
                if(send(client_socket,buffer,file_block_length,0)<0)
                {
                    printf("Send File:\\t%s Failed\\n", file_name);
                    break;
                }
                bzero(buffer, BUFFER_SIZE);
            }
    }
    
    printf("Send File:\\t %s To Server[%s] Finished\\n",file_name, argv[1]);
    
    printf("The File has %d words.\\n", wc_func(file_name));
    fclose(fp);

服务器代码:

char file_name[FILE_NAME_MAX_SIZE+1];
    bzero(file_name, FILE_NAME_MAX_SIZE+1);
    char buffer[BUFFER_SIZE];
    bzero(buffer,BUFFER_SIZE);
    recv(new_server_socket,file_name,BUFFER_SIZE,0);
    
    
    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 len = 0;
    while( len = recv(new_server_socket,buffer,BUFFER_SIZE,0))
    {
        if(len < 0)
        {
            printf("Recieve Data From Client %s Failed!\\n", argv[1]);
            break;
        }

        int write_length = fwrite(buffer,sizeof(char),len,fp);
        if (write_length<len)
        {
            printf("File:\\t%s Write Failed\\n", file_name);
            break;
        }
        bzero(buffer,BUFFER_SIZE);    
    }
    printf("File:\\t%s Transfer Finished!\\n",file_name);
    
    fclose(fp);

实验截图:

实验感想:

单线程程序:只有一个线程,代码顺序执行,容易出现代码阻塞(页面假死)

多线程程序:有多个线程,线程间独立运行,能有效地避免代码阻塞,并且提高程序的运行性能

对于单核,除了可以避免假死,时间上不一定能节省,但对于多核cpu,可能就真的可以实现并行计算,那样效率就大大提高了。

以上是关于2017-2018-1 20155302 实验三 实时系统的主要内容,如果未能解决你的问题,请参考以下文章

2017-2018-1 20155302 实验五 通信协议设计

2017-2018-1 20155302 实验四 外设驱动程序设计

# 2017-2018-1 20155302 《信息安全系统设计基础》第9周学习总结

# 2017-2018-1 20155302 课下实践IPC

2017-2018-1 20155302 第十四周作业

2017-2018-1 20155302 第十三周作业