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

于 2017-11-17 21:44:00 发布
阅读量78 收藏
点赞数
文章标签： 操作系统
原文链接：http://www.cnblogs.com/fixedl/p/7853641.html
版权

实验三 并发程序

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

要求：

  • 1.基于Linux Socket程序设计实现wc（1）服务器(端口号是你学号的后6位)和客户端
  • 2.客户端传一个文本文件给服务器
  • 3.服务器返加文本文件中的单词数

实验过程

  • 首先是用man wc命令学习wc的用法

1071523-20171117212427156-86508509.png

wc命令参数：

(1)-c：统计字节数。

(2)-l：统计行数。

(3)-m：统计字符数。这个标志不能与 -c 标志一起使用。

(4)-w：统计字数。一个字被定义为由空白、跳格或换行字符分隔的字符串。

(5)-L：打印最长行的长度。

(6)-help：显示帮助信息

(7)--version：显示版本信息

  • 然后是编写客户端和服务器代码

server.c:

#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 155323 
#define LENGTH_OF_LISTEN_QUEUE 20  
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512  
#define BEGIN 1; 

int main(void)  
{  

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);  

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));  

if(-1 == (bind(server_socket_fd, (struct sockaddr*)&server_addr, sizeof(server_addr))))  
{  
    perror("Server Bind Failed:");  
    exit(1);  
}  
    
if(-1 == (listen(server_socket_fd, LENGTH_OF_LISTEN_QUEUE)))  
{  
    perror("Server Listen Failed:");  
    exit(1);  
}  

while(1)  
{  
    struct sockaddr_in client_addr;  
    socklen_t client_addr_length = sizeof(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;  
    }  


    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;  
    }  


    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, "w");  
    if(NULL == fp)  
    {  
        printf("File:\t%s Can Not Open To Write\n", file_name);  
        exit(1);  
    }  


    bzero(buffer, BUFFER_SIZE);  
    int length = 0;  
    while((length = recv(new_server_socket_fd, buffer, BUFFER_SIZE, 0)) > 0)  
    {  
    if(strcmp(buffer,"OK")==0) break;
        if(fwrite(buffer, sizeof(char), length, fp) < length)  
        {  
            printf("File:\t%s Write Failed\n", file_name);  
            break;  
        }  
        bzero(buffer, BUFFER_SIZE);  
    }  

    printf("Receive File:\t%s From Client IP Successful!\n", file_name);  
    fclose(fp);

int words=0;
char s[100];
FILE *fp2;
if((fp2=fopen(file_name,"r"))==NULL){
    printf("ERROR!\n");
    exit(0);
}
while(fscanf(fp2,"%s",s)!=EOF)
    words++;
fclose(fp2);
printf("%d words.\n",words);

char sendbuf[50];
sprintf(sendbuf,"%d",words);

send(new_server_socket_fd,sendbuf,50,0);

    close(new_server_socket_fd);  
}  

close(server_socket_fd);  
return 0;  
}

client.c:

#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 155323  
#define BUFFER_SIZE 1024  
#define FILE_NAME_MAX_SIZE 512  
#define BEGIN 1;

int main()  
{  

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);  

int client_socket_fd = socket(AF_INET, SOCK_STREAM, 0);  
if(client_socket_fd < 0)  
{  
    perror("Create Socket Failed:");  
    exit(1);  
}  

if(-1 == (bind(client_socket_fd, (struct sockaddr*)&client_addr, sizeof(client_addr))))  
{  
    perror("Client Bind Failed:");  
    exit(1);  
}  

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);  

if(connect(client_socket_fd, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
{  
    perror("Can Not Connect To Server IP:");  
    exit(0);  
}  

char file_name[FILE_NAME_MAX_SIZE+1];  
bzero(file_name, FILE_NAME_MAX_SIZE+1);  

printf("Please Input File Name On Client:\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));  
  
if(send(client_socket_fd, buffer, BUFFER_SIZE, 0) < 0)  
{  
    perror("Send File Name Failed:");  
    exit(1);  
}  

    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(client_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);  
    }  

char s[50];
scanf("%s",s);
send(client_socket_fd,"OK",50,0);

char recvdata[sizeof(int)+1];
recv(client_socket_fd,recvdata,sizeof(int),0);
recvdata[sizeof(int)]='\0';
int words=atoi(recvdata);
close(client_socket_fd);  
return 0;  
}
  • 下一步编译客户端和服务器的代码生成可执行文件，先打开服务器，再打开客户端。然后用客户端向服务器传文件，最后再用wc -t命令检验统计字符数是否正确。

1071523-20171117211911624-567400395.png

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

要求：

  • 1.上方提交代码
  • 2.下方提交测试
  • 3.对比单线程版本的性能，并分析原因

实验过程：

  • 首先是对pthread库的理解

1071523-20171118232043843-292466059.png

1071523-20171118232137765-1704576207.png

1071523-20171118232157499-1924043003.png

  • 然后重新编写一个多线程服务器代码
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <pthread.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#define PORT  8888
#define BACKLOG 10
#define MAXCONN 100
#define BUFFSIZE 1024
typedef unsigned char BYTE;
typedef struct ClientInfo
{
struct sockaddr_in addr;
int clientfd;
int isConn;
int index;
} ClientInfo;
pthread_mutex_t activeConnMutex;
pthread_mutex_t clientsMutex[MAXCONN];
pthread_cond_t connDis;
pthread_t threadID[MAXCONN];
pthread_t serverManagerID;
ClientInfo clients[MAXCONN];
int serverExit = 0;

void tolowerString(char *s)
{
int i=0;
while(i < strlen(s))
{
    s[i] = tolower(s[i]);
    ++i;
} 
}
void listAll(char *all)
{
int i=0, len = 0;
len += sprintf(all+len, "Index   \t\tIP Address   \t\tPort\n");
for(;i<MAXCONN;++i)
{
    pthread_mutex_lock(&clientsMutex[i]);
    if(clients[i].isConn)
        len += sprintf(all+len, "%.8d\t\t%s\t\t%d\n",clients[i].index, inet_ntoa(clients[i].addr.sin_addr), clients[i].addr.sin_port);
    pthread_mutex_unlock(&clientsMutex[i]);
}
}
void clientManager(void* argv)
{
ClientInfo *client = (ClientInfo *)(argv);

BYTE buff[BUFFSIZE];
int recvbytes;

int i=0;
int clientfd = client->clientfd;
struct sockaddr_in addr = client->addr;
int isConn = client->isConn;
int clientIndex = client->index;

while((recvbytes = recv(clientfd, buff, BUFFSIZE, 0)) != -1)
{
 
    tolowerString(buff);    
    
    char cmd[100];
    if((sscanf(buff, "%s", cmd)) == -1)    
    { 
       char err[100];         
       if(send(clientfd, err, strlen(err)+1, 0) == -1)
       {
           strcpy(err, "Error command and please enter again!\n");
           fprintf(stdout, "%d sends an eroor command\n", clientfd);
           break;
       }
    }
    else    
    {
        char msg[BUFFSIZE]; 
        int dest = clientIndex; 
        int isMsg = 0;             
        if(strcmp(cmd, "disconn") == 0)
        {   
            pthread_cond_signal(&connDis); 
            break;
        }
        else if(strcmp(cmd, "time") == 0)
        {
            time_t now;
            struct tm *timenow;
            time(&now);
            timenow = localtime(&now);
            strcpy(msg, asctime(timenow));
            isMsg = 1;
        }
        else if(strcmp(cmd, "name") == 0)
        {
            strcpy(msg, "MACHINE NAME");
            isMsg = 1;
        }
        else if(strcmp(cmd, "list") == 0)
        {                            
            listAll(msg);
            isMsg = 1;
        }
        else if(strcmp(cmd, "send") == 0)
        {   
                
            if(sscanf(buff+strlen(cmd)+1, "%d%s", &dest, msg)==-1 || dest >= MAXCONN)
            {
                char err[100];
                strcpy(err, "Destination ID error and please use list to check and enter again!\n");
                fprintf(stderr, "Close %d client eroor: %s(errno: %d)\n", clientfd, strerror(errno), errno);
                break;
            }
            fprintf(stdout, "%d %s\n", dest, msg);   
            isMsg = 1;
        }
        else
        {
            char err[100];
            strcpy(err, "Unknown command and please enter again!\n");
            fprintf(stderr, "Send to %d message eroor: %s(errno: %d)\n", clientfd, strerror(errno), errno);
            break;
        }
        
        
        if(isMsg)
        {
            pthread_mutex_lock(&clientsMutex[dest]);
            if(clients[dest].isConn == 0)
            {
                sprintf(msg, "The destination is disconneted!");
                dest = clientIndex; 
            } 
                        
            if(send(clients[dest].clientfd, msg, strlen(msg)+1, 0) == -1)
            {
                fprintf(stderr, "Send to %d message eroor: %s(errno: %d)\n", clientfd, strerror(errno), errno);
                pthread_mutex_unlock(&clientsMutex[dest]); 
                break;
            }
            printf("send successfully!\n");
            pthread_mutex_unlock(&clientsMutex[dest]); 
        }
    }      
}  

pthread_mutex_lock(&clientsMutex[clientIndex]);
client->isConn = 0;
pthread_mutex_unlock(&clientsMutex[clientIndex]);

if(close(clientfd) == -1)
    fprintf(stderr, "Close %d client eroor: %s(errno: %d)\n", clientfd, strerror(errno), errno);
fprintf(stderr, "Client %d connetion is closed\n", clientfd);

pthread_exit(NULL);
}
void serverManager(void* argv)
{
while(1)
{
    char cmd[100];
    scanf("%s", cmd);
    tolowerString(cmd);
    if(strcmp(cmd, "exit") == 0)
        serverExit = 1;
    else if(strcmp(cmd, "list") == 0)
    {
        char buff[BUFFSIZE];
        listAll(buff);
        fprintf(stdout, "%s", buff);
    }
    else if(strcmp(cmd, "kill") == 0)
    {
        int clientIndex;
        scanf("%d", &clientIndex);
        if(clientIndex >= MAXCONN)
        {
            fprintf(stderr, "Unkown client!\n");
            continue;
        }
        pthread_mutex_lock(&clientsMutex[clientIndex]);
        if(clients[clientIndex].isConn)
        {
            if(close(clients[clientIndex].clientfd) == -1)
                fprintf(stderr, "Close %d client eroor: %s(errno: %d)\n", clients[clientIndex].clientfd, strerror(errno), errno);
        }
        else
        {
            fprintf(stderr, "Unknown client!\n");
        }
        pthread_mutex_unlock(&clientsMutex[clientIndex]);
        pthread_cancel(threadID[clientIndex]);
            
    }
    else
    {
        fprintf(stderr, "Unknown command!\n");
    }
}
}
int main()
{
        int activeConn = 0;

    pthread_mutex_init(&activeConnMutex, NULL);   
   pthread_cond_init(&connDis, NULL);
   int i=0;
    for(;i<MAXCONN;++i)
   pthread_mutex_init(&clientsMutex[i], NULL); 

   for(i=0;i<MAXCONN;++i)
   clients[i].isConn = 0; 
   

   pthread_create(&serverManagerID, NULL, (void *)(serverManager), NULL);


   int listenfd;
   struct sockaddr_in  servaddr;


   if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
   {
   fprintf(stderr, "Create socket error: %s(errno: %d)\n", strerror(errno), errno);
   exit(0);
   }
   else
   fprintf(stdout, "Create a socket successfully\n");

   fcntl(listenfd, F_SETFL, O_NONBLOCK);       

   memset(&servaddr, 0, sizeof(servaddr));  
   servaddr.sin_family = AF_INET;           
   servaddr.sin_addr.s_addr = htonl(INADDR_ANY);    
   servaddr.sin_port = htons(PORT);           


   if(bind(listenfd, (struct sockaddr*)(&servaddr), sizeof(servaddr)) == -1)
   {
    fprintf(stderr, "Bind socket error: %s(errno: %d)\n", strerror(errno), errno);
    exit(0);
   }
   else
   fprintf(stdout, "Bind socket successfully\n");


   if(listen(listenfd, BACKLOG) == -1)
   {
   fprintf(stderr, "Listen socket error: %s(errno: %d)\n", strerror(errno), errno);
   exit(0);
}
   else
   fprintf(stdout, "Listen socket successfully\n");


   while(1)
   {
   if(serverExit)
   {
       for(i=0;i<MAXCONN;++i)
       {
           if(clients[i].isConn)
           {
               if(close(clients[i].clientfd) == -1)         
                   fprintf(stderr, "Close %d client eroor: %s(errno: %d)\n", clients[i].clientfd, strerror(errno), errno);
               if(pthread_cancel(threadID[i]) != 0)         
                    fprintf(stderr, "Cancel %d thread eroor: %s(errno: %d)\n", (int)(threadID[i]), strerror(errno), errno);
           }
       }
       return 0;   
   }
   
   pthread_mutex_lock(&activeConnMutex);
   if(activeConn >= MAXCONN)
        pthread_cond_wait(&connDis, &activeConnMutex);
   pthread_mutex_unlock(&activeConnMutex);
       
   
   int i=0;
   while(i<MAXCONN)
   {
       pthread_mutex_lock(&clientsMutex[i]);
       if(!clients[i].isConn)
       {
           pthread_mutex_unlock(&clientsMutex[i]);
           break;
       }
       pthread_mutex_unlock(&clientsMutex[i]);
       ++i;           
   }   
   

   struct sockaddr_in addr;
   int clientfd;
   int sin_size = sizeof(struct sockaddr_in);
   if((clientfd = accept(listenfd, (struct sockaddr*)(&addr), &sin_size)) == -1)
   {   
       sleep(1);        
       
       continue;
       
   }
   else
       fprintf(stdout, "Accept socket successfully\n");
   
   pthread_mutex_lock(&clientsMutex[i]);
   clients[i].clientfd = clientfd;
   clients[i].addr = addr;
   clients[i].isConn = 1;
   clients[i].index = i;
   pthread_mutex_unlock(&clientsMutex[i]);
   
   //create a thread for a client
   pthread_create(&threadID[i], NULL, (void *)clientManager, &clients[i]);     
   
   }    //end-while
}
  • 编译后打开服务器，再照上一题的步骤分别打开两个客户端传文件

1071523-20171118231255562-1927759197.png

  • 多线程的优点：

(1)多线程技术使程序的响应速度更快 ,因为用户界面可以在进行其它工作的同时一直处于活动状态;

(2)当前没有进行处理的任务时可以将处理器时间让给其它任务;

(3)占用大量处理时间的任务可以定期将处理器时间让给其它任务;

(4)可以随时停止任务;

(5)可以分别设置各个任务的优先级以优化性能。

  • 是否需要创建多个线程取决于各种因素。在以下情况下,最适合采用多线程处理:

(1)耗时或大量占用处理器的任务阻塞用户界面操作;

(2)各个任务必须等待外部资源 (如远程文件或 Internet连接)。

多线程的优缺点

转载于:https://www.cnblogs.com/fixedl/p/7853641.html

diaoshen0161
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值