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

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

实验三-并发程序-1

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

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

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main(int argc, char *argv[])
{
	int server_sockfd;//服务器端套接字
	int client_sockfd;//客户端套接字
	int len;
	struct sockaddr_in my_addr;   //服务器网络地址结构体
	struct sockaddr_in remote_addr; //客户端网络地址结构体
	int sin_size;
	char buf[BUFSIZ];  //数据传送的缓冲区
	memset(&my_addr,0,sizeof(my_addr)); //数据初始化--清零
	my_addr.sin_family=AF_INET; //设置为IP通信
	my_addr.sin_addr.s_addr=INADDR_ANY;//服务器IP地址--允许连接到所有本地地址上
	my_addr.sin_port=htons(8000); //服务器端口号
	
	/*创建服务器端套接字--IPv4协议，面向连接通信，TCP协议*/
	if((server_sockfd=socket(PF_INET,SOCK_STREAM,0))<0)
	{  
		perror("socket");
		return 1;
	}
 
        /*将套接字绑定到服务器的网络地址上*/
	if (bind(server_sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))<0)
	{
		perror("bind");
		return 1;
	}
	
	/*监听连接请求--监听队列长度为5*/
	listen(server_sockfd,5);
	
	sin_size=sizeof(struct sockaddr_in);
	
	/*等待客户端连接请求到达*/
	if((client_sockfd=accept(server_sockfd,(struct sockaddr *)&remote_addr,&sin_size))<0)
	{
		perror("accept");
		return 1;
	}
	printf("accept client %s/n",inet_ntoa(remote_addr.sin_addr));
	len=send(client_sockfd,"Welcome to my server/n",21,0);//发送欢迎信息
	
	/*接收客户端的数据并将其发送给客户端--recv返回接收到的字节数，send返回发送的字节数*/
	while((len=recv(client_sockfd,buf,BUFSIZ,0))>0))
	{
		buf[len]='/0';
		printf("%s/n",buf);
		if(send(client_sockfd,buf,len,0)<0)
		{
			perror("write");
			return 1;
		}
	}
	close(client_sockfd);
	close(server_sockfd);
        return 0;
}

client:

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 :	");  
        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:	%s Can Not Open To Write
", 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:	%s Write Failed
", file_name);  
                break;  
            }  
            bzero(buffer, BUFFER_SIZE);  
        }  
      
        // 接收成功后，关闭文件，关闭socket  
        printf("Send File:	%s  Successful!
", file_name);  
        close(fp);  
        close(client_socket_fd);  
        return 0;  
    }  

测试结果截图：

实验三-并发程序-2

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

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <pthread.h>  
#include <errno.h>  
#include <error.h>  
#include <semaphore.h>  
  
#define PRODUCER_NUM 10  
#define CONSUMER_MUM 8  
#define BUFFER_SIZE 20  
#define SLEEP_TIME 1  
#define error_exit( _msg_ ) error(EXIT_FAILURE, errno, _msg_)  
  
int print();  
void *consumer_thread(void *args);  
void *producer_thread(void *args);  
  
sem_t can_produce;  
sem_t can_consume;  
pthread_mutex_t mutex;  
int produce_index = 0;  
int consume_index = 0;  
int producer_id = 0;  
int consumer_id = 0;  
int buffer[BUFFER_SIZE] = {0};  
int main()  
{  
    int i;  
    pthread_t producer[PRODUCER_NUM];  
    pthread_t consumer[CONSUMER_MUM];  
    int sinit1 = sem_init(&can_produce, 0, BUFFER_SIZE);  
    int sinit2 = sem_init(&can_consume, 0, 0);  
    if(sinit1 || sinit2)  
        error_exit("sem_init");  
    if(pthread_mutex_init(&mutex, NULL))  
        error_exit("pthread_mutex_init");  
    for(i=0; i<PRODUCER_NUM; i++)  
        if(pthread_create(&producer[i], NULL, producer_thread, NULL))  
            error_exit("pthread_create");  
    for(i=0; i<CONSUMER_MUM; i++)  
        if(pthread_create(&consumer[i], NULL, consumer_thread, NULL))  
            error_exit("pthread_create");  
    for(i=0; i<PRODUCER_NUM; i++)  
        pthread_join(producer[i], NULL);  
    for(i=0; i<CONSUMER_MUM; i++)  
        pthread_join(consumer[i], NULL);  
}  
void *producer_thread(void *args)  
{  
    int id = producer_id++;  
    while(1){  
        sleep(SLEEP_TIME);  
        pthread_mutex_lock(&mutex);  
        sem_wait(&can_produce);  
        printf("Producer id %d in %d.
", id, produce_index);  
        buffer[produce_index] = 1;  
        produce_index = (produce_index + 1) % BUFFER_SIZE;  
        print();  
        sem_post(&can_consume);  
        pthread_mutex_unlock(&mutex);  
    }  
    return NULL;  
}  
void *consumer_thread(void *args)  
{  
    int id = consumer_id++;  
    while(1){  
        sleep(SLEEP_TIME);  
        pthread_mutex_lock(&mutex);  
        sem_wait(&can_consume);  
        printf("Consumer id %d in %d.
", id, consume_index);  
        buffer[consume_index] = 0;  
        consume_index = (consume_index + 1) % BUFFER_SIZE;  
        print();  
        sem_post(&can_produce);  
        pthread_mutex_unlock(&mutex);  
    }  
    return NULL;  
}  
int print()  
{  
    int i;  
    printf("Buffer:
");  
    for(i = 0; i < BUFFER_SIZE; i++)  
        printf("___");  
    printf("
");  
    for(i = 0; i < BUFFER_SIZE; i++)  
        printf("|%d|", buffer[i]);  
    printf("
");  
    for(i = 0; i < BUFFER_SIZE; i++)  
        printf("___");  
    printf("
");  
    return 0;  
}

测试如图所示：

实验过程中遇到的问题

• 对于多线程的认识和理解
• 当一个程序运行在多线程下，就好像有多个CPU在同时执行该程序。
  多线程比多任务更加有挑战。多线程是在同一个程序内部并行执行，因此会对相同的内存空间进行并发读写操作。这可能是在单线程程序中从来不会遇到的问题。其中的一些错误也未必会在单CPU机器上出现，因为两个线程从来不会得到真正的并行执行。然而，更现代的计算机伴随着多核CPU的出现，也就意味着不同的线程能被不同的CPU核得到真正意义的并行执行。
  如果一个线程在读一个内存时，另一个线程正向该内存进行写操作，那进行读操作的那个线程将获得什么结果呢？是写操作之前旧的值？还是写操作成功之后的新值？或是一半新一半旧的值？或者，如果是两个线程同时写同一个内存，在操作完成后将会是什么结果呢？是第一个线程写入的值？还是第二个线程写入的值？还是两个线程写入的一个混合值？因此如没有合适的预防措施，任何结果都是可能的。而且这种行为的发生甚至不能预测，所以结果也是不确定性的。

实验体会

此次实验在Linux下实现了客户端与服务器传送文本文件，并模拟wc命令统计文本文件中的单词数。但一次只能为一个客户端提供服务是不现实的，因此，在任务二中创建了一个并发服务器，它为每一个客户端创建一个单独的逻辑流。这就允许服务器同时为多个客户端服务，提高了效率和应用。