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 :\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;
}
测试结果截图：
实验三-并发程序-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.\n", 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.\n", 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:\n");
for(i = 0; i < BUFFER_SIZE; i++)
printf("___");
printf("\n");
for(i = 0; i < BUFFER_SIZE; i++)
printf("|%d|", buffer[i]);
printf("\n");
for(i = 0; i < BUFFER_SIZE; i++)
printf("___");
printf("\n");
return 0;
}
测试如图所示：
实验过程中遇到的问题
- 对于多线程的认识和理解
- 当一个程序运行在多线程下，就好像有多个CPU在同时执行该程序。
多线程比多任务更加有挑战。多线程是在同一个程序内部并行执行，因此会对相同的内存空间进行并发读写操作。这可能是在单线程程序中从来不会遇到的问题。其中的一些错误也未必会在单CPU机器上出现，因为两个线程从来不会得到真正的并行执行。然而，更现代的计算机伴随着多核CPU的出现，也就意味着不同的线程能被不同的CPU核得到真正意义的并行执行。
如果一个线程在读一个内存时，另一个线程正向该内存进行写操作，那进行读操作的那个线程将获得什么结果呢？是写操作之前旧的值？还是写操作成功之后的新值？或是一半新一半旧的值？或者，如果是两个线程同时写同一个内存，在操作完成后将会是什么结果呢？是第一个线程写入的值？还是第二个线程写入的值？还是两个线程写入的一个混合值？因此如没有合适的预防措施，任何结果都是可能的。而且这种行为的发生甚至不能预测，所以结果也是不确定性的。
实验体会
此次实验在Linux下实现了客户端与服务器传送文本文件，并模拟wc命令统计文本文件中的单词数。但一次只能为一个客户端提供服务是不现实的，因此，在任务二中创建了一个并发服务器，它为每一个客户端创建一个单独的逻辑流。这就允许服务器同时为多个客户端服务，提高了效率和应用。
