网编(18)：多线程服务器端的实现

多进程模型的缺点：

创建进程的过程会带来一定的开销。
为了完成进程间数据交换，需要特殊的IPC技术。
每秒少则数十次、多则数千次的｀上下文切换'(Context Switching ) 是创建进程时最大的开销。”

上下文切换：

运行程序前需要将相应进程信息读入内存，如果运行进程A后需要紧接着运行进程B, 就应该将进程A相关信息移出内存，并读入进程B相关信息。这就是上下文切换。但此时进程A的数据将被移动到硬盘，所以上下文切换需要很长时间。即使通过优化加快速度，也会存在一定的局限。

线程优点：

线程的创建和上下文切换比进程的创建和上下文切换更快。
线程间交换数据时无需特殊技术。

线程的创建

#include <pthread.h>
int pthread_create( pthread_t            * thread, 
                    canst pthread_attr_t * attr,
                    void                 *(* start_routine)(void *), 
					void                 * arg);
//成功时返回0, 失败时返回其他值。
#thread        保存新创建线程ID 的变量地址值。线程与进程相同，也需要用于区分不同线程的ID 。
#attr          用于传递线程属性的参数，传递N ULL时，创建默认属性的线程。
#start_routine 相当于线程main 函数的、在单独执行流中执行的函数地址值（函数指针） 。
#arg           通过第三个参数传递调用函数时包含传递参数信息的变量地址值。

线程的回收

include <pthread.h>
int pthread_join(pthread_t thread, void** status);
//成功时返回0, 失败时返回其他值。

#thread 该参数值ID 的线程终止后才会从该函数返回。
#status 保存线程的main 函数返回值的指针变量地址值。

当进程结束时，所有线程也会结束，如下图：

通过使用pthread_join可以等待线程结束。

可在临界区内调用的函数

线程的运行需要考虑“多个线程同时调用函数时（执行时）可能产生问题” 。这类函数内部存在临界区( Critical Section ) , 也就是说，多个线程同时执行这部分代码时，可能引起问题。临界区中至少存在1条这类代码。

扫描二维码关注公众号，回复： 5788365 查看本文章

根据临界区是否引起问题，函数可分为以下2类。

线程安全函数( Thread-safe function)
非线程安全函数(Thread-unsafe function )

线程安全函数被多个线程同时调用时也不会引发问题。反之，非线程安全函数被同时调用时会引发问题。但这并非关于有无临界区的讨论，线程安全的函数中同样可能存在临界区。只是在线程安全函数中，同时被多个线程调用时可通过一些措施避免问题。

线程安全函数的名称后缀通常为_r (这与Windows平台不同）。

临界区位置

临界区定义：
＂函数内同时运行多个线程时引起问题的多条语句构成的代码块。”

全局变量num是否应该视为临界区？不是！因为它不是引起问题的语句。该变量并非同时运行的语句，只是代表内存区域的声明而已。临界区通常位于由线程运行的函数内部。

void* thread_inc(void * arg)
{
	int i;
	for(i = 0; i < 50000000; i++)
		num += 1; // 临界区
	return NULL;
}

void* thread_inc(void * arg)
{
	int i;
	for(i = 0; i < 50000000; i++)
		num -= 1; // 临界区
	return NULL;
}

线程同步

线程同步用于解决线程访问顺序引发的问题。需要同步的情况可以从如下两方面考虑。

同时访问同一内存空间时。
需要指定访问同一内存空间的线程执行顺序。

互斥，同步总结

互斥锁————————————————————————————

创建和销毁：

#include <pthread.h>
int pthread_mutex_init (pthread_mutex_t * mutex, canst pthread_ mutexattr_t * attr);
int pthread_mutex_destroy(pt hread_mutex_t * mutex) ;
//成功时返回0, 失败时返回其他值。

上锁和解锁：

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t * mutex);
int pthread_mutex_unlock(pthread_mutex_t * mutex);
//成功时返回0, 失败时返回其他值。

信号量——————————————————————

参考：

Linux信号量详解

信号量由很多种：下面是一种

创建和销毁：

#include <semaphore.h>
int sem_init(sem_t * sem, int pshared, unsigned int value);
int sem_destroy(sem_t * sem);
//成功时返回0, 失败时返回其他值。
#sem      创建信号量时传递保存信号量的变量地址值，销毁时传递需要销毁的信号量变量地址值。
#pshared  传递其他值时，创建可由多个进程共享的信号量； 传递0时，创建只允许1 个进程内部使用的信号量。我们需要完成同一进程内的
          线程同步，故传递0 。
#value    指定新创建的信号量初始值。

解锁和上锁：

#include <semaphore.h>
int sem_post(sem_t * sem);
int sem_wait(sem_t * sem);
//成功时返回0, 失败时返回其他值。
#sem 传递保存信号量读取值的变量地址值，传递给sem_post时信号量增1，传递给sem_wait时信号量减1 。

线程的销毁

调用pthreadjoin函数。
调用pthread_ detach 函数。

第一种：由主进程销毁。

第二种：由线程自己销毁。

#include <pthread.h>
int pthread_detach(pthread_t thread);
//成功时返回0, 失败时返回其他值。

#thread 终止的同时需要销毁的线程ID。

使用方法：一般再线程函数第一句添加下面的代码。

pthread_detach(pthread_self());

服务器：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>

#define BUF_SIZE 100
#define MAX_CLNT 256

void * handle_clnt(void * arg);
void send_msg(char * msg, int len);
void error_handling(char * msg);

int clnt_cnt=0;
int clnt_socks[MAX_CLNT];
pthread_mutex_t mutx;

int main(int argc, char *argv[])
{
	int serv_sock, clnt_sock;
	struct sockaddr_in serv_adr, clnt_adr;
	int clnt_adr_sz;
	pthread_t t_id;
	if(argc!=2) {
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}
  
	pthread_mutex_init(&mutx, NULL);
	serv_sock=socket(PF_INET, SOCK_STREAM, 0);

	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family=AF_INET; 
	serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
	serv_adr.sin_port=htons(atoi(argv[1]));
	
	if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1)
		error_handling("bind() error");
	if(listen(serv_sock, 5)==-1)
		error_handling("listen() error");
	
	while(1)
	{
		clnt_adr_sz=sizeof(clnt_adr);
		clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr,&clnt_adr_sz);
		
		pthread_mutex_lock(&mutx);
		clnt_socks[clnt_cnt++]=clnt_sock;
		pthread_mutex_unlock(&mutx);
	
		pthread_create(&t_id, NULL, handle_clnt, (void*)&clnt_sock);
		pthread_detach(t_id);
		printf("Connected client IP: %s \n", inet_ntoa(clnt_adr.sin_addr));
	}
	close(serv_sock);
	return 0;
}
	
void * handle_clnt(void * arg)
{
	int clnt_sock=*((int*)arg);
	int str_len=0, i;
	char msg[BUF_SIZE];
	
	while((str_len=read(clnt_sock, msg, sizeof(msg)))!=0)
		send_msg(msg, str_len);
	
	pthread_mutex_lock(&mutx);
	for(i=0; i<clnt_cnt; i++)   // remove disconnected client
	{
		if(clnt_sock==clnt_socks[i])
		{
			while(i++<clnt_cnt-1)
				clnt_socks[i]=clnt_socks[i+1];
			break;
		}
	}
	clnt_cnt--;
	pthread_mutex_unlock(&mutx);
	close(clnt_sock);
	return NULL;
}
void send_msg(char * msg, int len)   // send to all
{
	int i;
	pthread_mutex_lock(&mutx);
	for(i=0; i<clnt_cnt; i++)
		write(clnt_socks[i], msg, len);
	pthread_mutex_unlock(&mutx);
}
void error_handling(char * msg)
{
	fputs(msg, stderr);
	fputc('\n', stderr);
	exit(1);
}

客户端：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> 
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <pthread.h>
	
#define BUF_SIZE 100
#define NAME_SIZE 20
	
void * send_msg(void * arg);
void * recv_msg(void * arg);
void error_handling(char * msg);
	
char name[NAME_SIZE]="[DEFAULT]";
char msg[BUF_SIZE];
	
int main(int argc, char *argv[])
{
	int sock;
	struct sockaddr_in serv_addr;
	pthread_t snd_thread, rcv_thread;
	void * thread_return;
	if(argc!=4) {
		printf("Usage : %s <IP> <port> <name>\n", argv[0]);
		exit(1);
	 }
	
	sprintf(name, "[%s]", argv[3]);
	sock=socket(PF_INET, SOCK_STREAM, 0);
	
	memset(&serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family=AF_INET;
	serv_addr.sin_addr.s_addr=inet_addr(argv[1]);
	serv_addr.sin_port=htons(atoi(argv[2]));
	  
	if(connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr))==-1)
		error_handling("connect() error");
	
	pthread_create(&snd_thread, NULL, send_msg, (void*)&sock);
	pthread_create(&rcv_thread, NULL, recv_msg, (void*)&sock);
	pthread_join(snd_thread, &thread_return);
	pthread_join(rcv_thread, &thread_return);
	close(sock);  
	return 0;
}
	
void * send_msg(void * arg)   // send thread main
{
	int sock=*((int*)arg);
	char name_msg[NAME_SIZE+BUF_SIZE];
	while(1) 
	{
		fgets(msg, BUF_SIZE, stdin);
		if(!strcmp(msg,"q\n")||!strcmp(msg,"Q\n")) 
		{
			close(sock);
			exit(0);
		}
		sprintf(name_msg,"%s %s", name, msg);
		write(sock, name_msg, strlen(name_msg));
	}
	return NULL;
}
	
void * recv_msg(void * arg)   // read thread main
{
	int sock=*((int*)arg);
	char name_msg[NAME_SIZE+BUF_SIZE];
	int str_len;
	while(1)
	{
		str_len=read(sock, name_msg, NAME_SIZE+BUF_SIZE-1);
		if(str_len==-1) 
			return (void*)-1;
		name_msg[str_len]=0;
		fputs(name_msg, stdout);
	}
	return NULL;
}
	
void error_handling(char *msg)
{
	fputs(msg, stderr);
	fputc('\n', stderr);
	exit(1);
}

运行结果：

#运行结果： chat_ server.c
root@my_linux:/tcpip# gee ehat_serv.e -D_REENTRANT -o eserv -lpthread
root@my_ linux:/tcpip# ./eserv 9190
Connected client IP: 127.0.0.1
Connected client IP: 127.0.0.1
Connected client IP: 127.0.0.1

#运行结果： chat_clnt.c One [From Yoon]
root@my_linux:/tcpip# gee ehat_elnt.e 一见REENTRANT -o eelnt -lpthread
root@my_ linux:/tcpip# ./eelnt 127.0.0.1 9190 Yoon
Hi everyone~
[Yoon] Hi everyone~
[Choi] Hi Yoon
[Hong] Hi~ friends

#运行结果： chat_clnt.c Two [From Choi]
root@my_linux:/tcpip# ./cclnt 127.0.0.1 9190 Choi
[Yoon] Hi everyone~
Hi Yoon
[Choi] Hi Yoon
[Hong] Hi~ friends

#运行结果： chat_clnt.c Three [From Hong]
root@my_linux:/tcpip# ./cclnt 127.0.0.1 9190 Hong
[Yoon] Hi everyone~
[Choi] Hi Yoon
Hi~ friends
[Hong] Hi~ friends