18.2 多线程服务器端的实现2

最新推荐文章于 2022-05-18 17:32:46 发布
最新推荐文章于 2022-05-18 17:32:46 发布
阅读量410 收藏
点赞数
分类专栏： TCP/IP网络编程，尹圣雨
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenwen111111/article/details/54897052
版权

1. 线程同步

a. 需要线程同步的情况：1）同时访问同一内存空间；2）需要指定访问同一内存空间的线程执行顺序。

b. 同步技术：互斥量Mutex和信号量Semaphore


将临界区比喻成洗手间，线程同步理解成一把锁。

为了保护个人隐私，进洗手间时锁上门，出来再打开；

如果有人使用洗手间，其他人需要在外面等待；

等待的人数可能很多，这些人需要排队进入洗手间。


2. 互斥量Mutual Exclusion，创建和销毁函数

#include <pthread.h>

int pthread_mutex_init(pthread_mutex_t * mutex,const pthread_mutexattr_t * attr);

int pthread_mutex_destroy(pthread_mutex_t * mutex);

成功返回0，失败返回其他值
mutex：创建/销毁互斥量时传递保存互斥量的变量地址值
attr：创建的互斥量属性


创建互斥量时，如果第二个参数为NULL，也可以通过宏PTHREAD_MUTEX_INITIALIZER创建。

但是最好还是使用函数，宏比较难检查错误。

3. 互斥量锁住、释放临界区

int pthread_mutex_lock(pthread_mutex_t * mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

成功返回0，失败返回其他值


注意：临界区锁住后，忘记解锁，则其他尝试进入临界区的线程将会“死锁”。


4. 信号量的创建、销毁

int sem_init(sem_t *sem,int pshared,unsigned int value);
int sem_destroy(sem_t * sem);

成功返回0，失败返回其他值

sem：创建信号量时传递保存信号量的变量地址值
pshared：传递其他值时，可创建多个进程共享的信号量。0时，只允许一个进程内部使用该信号量
value：指定信号量初始值。

5. post/wait

int sem_post(sem_t *sem);
int sem_wait(sem_t *sem);

成功返回0，失败时返回其他值

sem：传递保存信号量读取值得变量地址值


调用sem_init时，操作系统创建信号量对象，并赋初始值。

调用sem_post函数值，对象+1，sem_wait函数时-1.

信号量的值不能小于0，在信号量为0的情况，sem_wait函数会进入阻塞直到值大于0。


6. 关于控制访问顺序的同步

代码：

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

void * read(void * arg);
void * accu(void * arg);

static sem_t sem_one;
static sem_t sem_two;
static int num;

int main(int argc, char *argv[]){
	pthread_t id_t1,id_t2;

	sem_init(&sem_one,0,0);
	sem_init(&sem_two,0,1);

	pthread_create(&id_t1,NULL,read,NULL);
	pthread_create(&id_t2,NULL,accu,NULL);

	pthread_join(id_t1,NULL);
	pthread_join(id_t2,NULL);

	sem_destroy(&sem_one);
	sem_destroy(&sem_two);

	return 0;
}


void * read(void * arg){
	int i;

	for(i=0;i<5;i++){
		printf("Input num %d: ",i+1);
		sem_wait(&sem_two);
		scanf("%d",&num);
		sem_post(&sem_one);
	}

	return NULL;
}

void *accu(void *arg){
	int sum = 0,i;
	for(i=0;i<5;i++){
		sem_wait(&sem_one);
		sum += num;
		printf("sum = %d \n",sum);
		sem_post(&sem_two);
	}

	printf("result : %d \n",sum);

	return NULL;
}

执行结果：

alex@alex-VirtualBox:~/Share/Test/tcpip$ ./sema
Input num 1: 123
sum = 123
Input num 2: 123
Input num 3: sum = 246
1
Input num 4: sum = 247
1
Input num 5: sum = 248
1
sum = 249
result : 249

7. 线程的销毁

线程不是在线程main返回时自动销毁，而是使用下面的方法销毁，不然会一直存在内存空间：

a. pthread_join函数//线程一直等待，阻塞

b. pthread_detach函数//通常使用这种方法销毁线程，不会引起线程终止或进入阻塞。

调用个了pthread_detach后，不能再调用pthread_join

int pthread_detach(pthread_t thread);

成功：返回0，失败返回其他值

8. 多线程并发服务器端的实现

chat_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <pthread.h>
#include <semaphore.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 *message);

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

int main(int argc, char *argv[]){
	int serv_sock;
	int clnt_sock;
	struct sockaddr_in serv_adr;
	struct sockaddr_in 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);
	if(serv_sock == -1){
		error_handling("socket() error");
	}

	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("Connetcted client IP :%s \n",inet_ntoa(clnt_adr.sin_addr));
	}

	close(serv_sock);

	return 0;
}

void error_handling(char *message){

	fputs(message,stderr);
	fputs("\n",stderr);
	exit(1);
}

void * handle_clnt(void * arg){
	int clnt_sock = *((int *)arg);
	int str_len =0;
	int 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++){
		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;
}

//send to all
void send_msg(char *msg,int len)
{
	int i;
	
	pthread_mutex_lock(&mutx);
	for(i=0;i<clnt_cnt;i++){
		write(clnt_socks[i],msg,len);
	}

	pthread_mutex_unlock(&mutx);
}

执行结果：

alex@alex-VirtualBox:~/Share/Test/tcpip$ gcc chat_server.c -o server -D_REENTRANT -lpthread
alex@alex-VirtualBox:~/Share/Test/tcpip$ ./server 9190
Connetcted client IP :127.0.0.1
Connetcted client IP :192.168.1.104

chat_client.c

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

#define BUF_SIZE	100
#define NAME_SIZE	20

void error_handling(char *message);
void * send_msg(void * arg);
void * recv_msg(void * arg);

char name[NAME_SIZE] = "[DEFAULT]";
char msg[BUF_SIZE];

int main(int argc,char *argv[]){
	int sock;
	struct sockaddr_in serv_adr;
	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);
	if(sock == -1){
		error_handling("socket() error");
	}
	
	memset(&serv_adr,0,sizeof(serv_adr));
	serv_adr.sin_family = AF_INET;
	serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
	serv_adr.sin_port = htons(atoi(argv[2]));

	if(connect(sock,(struct sockaddr *)&serv_adr,sizeof(serv_adr)) == -1){
		error_handling("connect() error\r\n");
	}else{
		printf("Connected....");
	}

	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 error_handling(char *message){
	fputs(message,stderr);
	fputs("\n",stderr);
	exit(1);
}

void * send_msg(void *arg){
	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){
	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;
}

执行结果：


alex@alex-VirtualBox:~/Share/Test/tcpip$ gcc chat_client.c -o client -D_REENTRANT -lpthread
alex@alex-VirtualBox:~/Share/Test/tcpip$ ./client 192.168.1.104 9190 alex
Connected....[stoney] hello
hi
[alex] hi



alex@alex-VirtualBox:~/Share/Test/tcpip$ ./client 127.0.0.1 9190 stoney
Connected....hello
[stoney] hello
[alex] hi

vancounver
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
疯狂Android讲义.part2
08-30
13.1.4 加入多线程 483 13.2 使用URL访问网络资源 489 13.2.1 使用URL读取网络资源 489 13.2.2 使用URLConnection提交 请求 491 13.3 使用HTTP访问网络 496 13.3.1 使用HttpURLConnection 496 13.3.2 使用Apache ...
TCP实现聊天室（超简单）
m0_56278885的博客
05-18 1917
实现TCP聊天室本质上就是用内核链表管理多线程，再通过遍历的方式向每一个客户端发送消息的过程。 server端（服务端代码实现） #include <stdio.h> #include <string.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> /* See NOTES */ #include <sys/socket.h&gt.
网络编程——TCP客户端（发送消息）（线程实现）
qq_39577221的博客
05-18 454
#include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <stdlib.h> #include <arpa/inet.h> #include <unistd.h> #include <string.h> #include <pthread.h> void *readMsg(void *arg)； in...
linux C下采用TCP网络协议实现同一局域网下的简单的网络聊天
XinST的博客
10-14 225
linux C下采用TCP网络协议实现同一局域网下的简单的网络聊天 平台： 虚拟机：VMware-workstation-full-15.5.0 ubuntu：Ubuntu-16.04-64位 实现方法：采用多线程实现 编译：gcc -prthead server.c -o server gcc -prthead server.c -o server 执行：./server+本机IP ./client+服务器IP+服务器端口 服务器代码 server.c #include <stdio.h> #
linux线程同步
早起的虫儿灬
01-08 479
0 概述 　　所谓同步，就是给多个线程规定一个执行的顺序（或称为时序），要求某个线程先执行完一段代码后，另一个线程才能开始执行。 　　 第一种情况：多个线程访问同一个变量： 　　1. 一个线程写，其它线程读：这种情况不存在同步问题，因为只有一个线程在改变内存中的变量，内存中的变量在任意时刻都有一个确定的值； 　　2. 一个线程读，其它线程写：这种情况会存在同步问题，主要是多个线程在同时写
Visual Basic 6编程技术大全 中译本扫描版带书签 2/2
10-27
20.1.3活动的服务器端页面775 20.2 ASP对象模型778 20.2.1 Request对象778 20.2.2 Response对象783 20.2.3 Server对象787 20.2.4 Application对象790 20.2.5 Session对象792 20.2.6 ObjectContext对象795 20.3 ASP...
Visual Basic 6编程技术大全 中译本扫描版带书签 1/2
10-27
20.1.3活动的服务器端页面775 20.2 ASP对象模型778 20.2.1 Request对象778 20.2.2 Response对象783 20.2.3 Server对象787 20.2.4 Application对象790 20.2.5 Session对象792 20.2.6 ObjectContext对象795 20.3 ASP...
5.2 计算器服务器端/客户端示例
wenwen111111的专栏
01-19 1276
通信过程中一般都需要提前定义好通信协议，TCP中亦是如此。 我们编写计算器的例子，定义好应用层协议：     1.客户端连接到服务器端后以1字节整数形式传递待算数字个数；     2.客户端向服务器端传递的每个整数型数据占用4字节；     3.传递完数据后，接着1个字节运算符；     4.选择字符+，-，*，/;     5.服务器以4字节整数型向客户端传回运算结果；     6
17.2 边缘触发和条件触发
wenwen111111的专栏
02-04 533
1. 两者区别：在于发生事件的时间点，条件触发：只要输入缓冲有数据就一直通知该事件；边缘触发：输入缓冲受到数据时仅注册一次事件。 epoll默认以条件触发方式工作，select也是以条件触发模式工作的。 2. 条件触发事件特性： #include #include #include #include #include #include #inclu
9.2 SO_REUSEADDR配置 & TCP_NODELAY
wenwen111111的专栏
02-03 495
1. time-wait：先断开连接FIN的主机有个时间间隙，在该间隙中端口号被占用，bind时会出错。 在time-wait状态可以继续接收主机B的终止信息，假如没有这个机制，A发送ACK时终止，但是ACK丢失了，则B永远无法接收A的ACK。 系统SOL_SOCKET中的SO_REUSEADDR，默认是FALSE，即time-wait内端口不能重复使用。将值改成TRUE，即可重新使用。
6.3 Connected UDP & unconnected UDP
wenwen111111的专栏
02-02 477
1. 在UDP中，使用sendto数据传输过程分三阶段： a. 向UDP套接字注册目标IP和端口号； b. 传输数据； c. 删除UDP套接字中注册的目标地址信息。 2. unconnected UDP套接字：每次调用sendto重复1的三个步骤，每次都变更目标地址，因此可以重复利用同一UDP向不同目标传递数据。 注册了目标地址的UDP套接字是connected UDP，默认情况下是un
24 实现http服务器端
wenwen111111的专栏
02-08 403
1. HTTP：Hypertext Transfer Protocol超文本传输协议。超文本是可以根据客户端请求而跳转的结构化信息。 HTTP协议是以超文本传输为目的而设计的应用层协议，是基于TCP/IP实现的协议，实现该协议就相当于实现了Web服务器端。 2. Http协议又称为无状态的stateless协议 从下图中可以看出服务器端响应客户端请求后立即断开，不会维持连接状态。即使
1.1 理解网络编程和套接字
wenwen111111的专栏
01-17 386
最近在看网络编程相关的知识，网上说尹圣雨的《TCPIP网络编程》不错，遂网上找了分电子版本的书籍，记录下阅读笔记。 TCP套接字通信可以类比电话机，接听方流程如下： socket  —— 安装电话机 bind —— 分配电话号码 listen —— 连接电话线 accept —— 拿起话筒 打电话端比较简单，只需要： socket connect 举例：服务器端收
4.1 TCP的服务器端/客户端1
wenwen111111的专栏
01-18 378
一、 理解下TCP和UDP 根据数据传输方式的不同，基于网络协议的套接字一般分成TCP套接字和UDP套接字。 TCP套接字是面向连接的，又称为基于流Stream的套接字，TCP（Transmission Control Protocol 传输控制协议）的简写，书中将TCP/IP协议栈分成4层架构，掌握这4层协议栈就足够了。另外不同于OSI 7层架构：物理层-->数据链路层-->网络层-->传输
10.3 基于多任务的并发服务器
wenwen111111的专栏
02-03 358
1.基于进程的并发服务器模型 a. 父进程通过调用accept受理连接请求； b. 获取套接字文件描述符创建并传递给子进程； //子进程复制父进程的所有资源 c. 子进程利用传递来的文件描述符提供服务。 2. 实现 #include #include #include #include #include #include #include
16 IO分离的其他说明
wenwen111111的专栏
02-04 325
1. IO流分离方式： a. 第十章TCP IO routine分离，通过fork文件描述符区分输入输出，虽然文件描述符不会根据输入、输出进行区分，但是分开了两个文件描述符的用途； b. 第十五章 调用fdopen创建FILE指针，分离输入工具和输出工具。 2. 分离流的好处： //第十章 a. 通过分开输入过程和输出过程降低实现难度； b. 与输入无关的输出操作可以提高速度；
vivado18.2下载
最新发布
09-06
您可以通过以下步骤下载 Vivado 18.2： 1. 访问 Xilinx 官方网站：https://www.xilinx.com/support/download.html 2. 在 "I want to download" 下拉菜单中，选择 "Vivado HLx"。 3. 在 "Edition" 下拉菜单中，选择...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值