多线程socket通信，信号量控制发送多线程发送顺序，测试通信延时

最新推荐文章于 2022-05-11 01:10:44 发布
最新推荐文章于 2022-05-11 01:10:44 发布
阅读量899 收藏 2
点赞数
分类专栏： linux c socket 文章标签： c语言 多线程 socket 通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37774756/article/details/78765450
版权
这是我工作的第一个任务，为了熟悉套接字，刚开始做这个任务几乎是崩溃的，因为对C语言，对套接字，锁的原理毫无了解，编了很久，出了很多问题
任务：在linux上，做一个1个client，1个service，自己做makefile，client建立5个线程建立5个套接字按顺序向service发包，service收到包以后返回timestamp，计算延时。
需求分析：
1.一个client实现5个线程
2.5个线程按顺序向sevice发包
3.server端发送test ready to client，client接到命令后，向service发送测试程序
4.service可以实现和多个套接字的通信，分别返回多个套接字所用的信息
5.做makefile，可以在linux环境下编译


client端：

/* 
* 客户端代码 
*/  
#include "confile.h"

/*定义传送包结构体*/
struct DataForm
	{
	char 	DataForm_content[1024];
	int 	DataForm_i;
	long    DataForm_send_sec;
	long 	DataForm_send_usec;
	};
/*定义时间戳结构体*/
struct timeval t_begin,t_end;
struct DataForm p1,p3;
long latecy,Recvtime;
/*定义互斥量，条件变量*/
pthread_mutex_t mutex;
pthread_cond_t cond1_2 = PTHREAD_COND_INITIALIZER;  
pthread_cond_t cond2_3 = PTHREAD_COND_INITIALIZER;  
pthread_cond_t cond3_4 = PTHREAD_COND_INITIALIZER; 
pthread_cond_t cond4_5 = PTHREAD_COND_INITIALIZER;  
pthread_cond_t cond5_1 = PTHREAD_COND_INITIALIZER;  
//标记
int flag1_2,flag2_3,flag3_4,flag4_5,flag5_1;
char buffer[MAX_LINE],msg[MAX_LINE];
int  iSent,length;
//声明延迟时间，收包时间
long latecy,Recvtime_sec,Recvtime_usec;
/*声明套接字和链接服务器地址*/
int  sockfd,sockfd_1,sockfd_2,sockfd_3,sockfd_4,sockfd_5;
struct sockaddr_in servaddr;
//标记检查的线程等待  
void th_condflag_wait(int *flag,pthread_cond_t *cond,pthread_mutex_t *mutex)  
{  
    (*flag) = 1;  
    pthread_cond_wait(cond,mutex);  
    (*flag) = 0;  
}  
  
//标记检查的线程通知  
void th_condflag_broadcast(int *flag,pthread_cond_t *cond,pthread_mutex_t *mutex)  
{  
    while(!(*flag))  
    {  
        pthread_mutex_unlock(mutex);  
        usleep(50);  
        pthread_mutex_lock(mutex);  
    }  
    pthread_cond_broadcast(cond);  
}  

//*线程1向服务器发送test包 序列号_收服务器test包 计算延时并输出 *//
void *send_sn1()
{	
	while(1) {
		pthread_mutex_lock(&mutex);
		th_condflag_wait(&flag5_1,&cond5_1,&mutex); 
		p1.DataForm_i++;
		gettimeofday(&t_begin, NULL);//get send time
		p1.DataForm_send_sec=t_begin.tv_sec;
		p1.DataForm_send_usec=t_begin.tv_usec;
		strcpy(p1.DataForm_content,"test");
		bzero(msg, sizeof(msg));
		memcpy(msg,&p1,sizeof(p1));
		iSent=send(sockfd_1,msg,sizeof(msg),0);
		
		if (iSent<0) {  
			printf("Client Send Data Failed!\n");  
			exit(1);  
		}
		
		bzero(buffer, sizeof(buffer));
		
		length=recv(sockfd_1, buffer, sizeof(buffer), 0);  
		
		if (length < 0) {  
			printf("Server Recieve Data Failed!\n");  
			exit(1);  
    	        }
  
		memcpy(&p3,buffer,sizeof(p3));
		if (strcmp(p3.DataForm_content, "test") == 0) {	
			Recvtime_sec=p3.DataForm_send_sec;
			Recvtime_usec=p3.DataForm_send_usec;
			gettimeofday(&t_end, NULL);//get recive time
			latecy=(1000000*(t_end.tv_sec-Recvtime_sec)+(t_end.tv_usec-Recvtime_usec))/2;
			printf("延时是%ld微秒\n",latecy);
		}
		sleep(1);
		th_condflag_broadcast(&flag1_2,&cond1_2,&mutex); 
		pthread_mutex_unlock(&mutex);
	}
}
//*线程2向服务器发送test包 序列号_收服务器test包 计算延时并输出 *//
void *send_sn2()
{	
	while(1) {
		pthread_mutex_lock(&mutex);
		th_condflag_wait(&flag1_2,&cond1_2,&mutex); 
		p1.DataForm_i++;
		gettimeofday(&t_begin, NULL);
		p1.DataForm_send_sec=t_begin.tv_sec;
		p1.DataForm_send_usec=t_begin.tv_usec;
		strcpy(p1.DataForm_content,"test");
		bzero(msg, sizeof(msg));
		memcpy(msg,&p1,sizeof(p1));
		iSent=send(sockfd_2,msg,sizeof(msg),0);
		if (iSent<0) {  
			printf("Client Send Data Failed!\n");  
			exit(1);  
		}
		bzero(buffer, sizeof(buffer));
		
		length=recv(sockfd_2, buffer, sizeof(buffer), 0);  
		
		if (length < 0) {  
			printf("Recieve Data Failed!\n");  
			exit(1);  
    		}  
		
		memcpy(&p3,buffer,sizeof(p3));
		
		if (strcmp(p3.DataForm_content, "test") == 0) {	
			Recvtime_sec=p3.DataForm_send_sec;
			Recvtime_usec=p3.DataForm_send_usec;
			gettimeofday(&t_end, NULL);
			latecy=(1000000*(t_end.tv_sec-Recvtime_sec)+(t_end.tv_usec-Recvtime_usec))/2;
			printf("延时是%ld微秒\n",latecy);
		}
		sleep(1);
		th_condflag_broadcast(&flag2_3,&cond2_3,&mutex);
		pthread_mutex_unlock(&mutex);
	}
}

//*线程3向服务器发送test包 序列号_收服务器test包 计算延时并输出 *//
void *send_sn3()
{	
	while(1) {
		pthread_mutex_lock(&mutex);
		th_condflag_wait(&flag2_3,&cond2_3,&mutex); 
		p1.DataForm_i++;
		gettimeofday(&t_begin, NULL);
		p1.DataForm_send_sec=t_begin.tv_sec;
		p1.DataForm_send_usec=t_begin.tv_usec;
		strcpy(p1.DataForm_content,"test");
		bzero(msg, sizeof(msg));
		memcpy(msg,&p1,sizeof(p1));
		iSent=send(sockfd_3,msg,sizeof(msg),0);
		if (iSent<0) {  
			printf("Client Send Data Failed!\n");  
			exit(1);  
		}
		bzero(buffer, sizeof(buffer));
	
		length=recv(sockfd_3, buffer, sizeof(buffer), 0);  
	
		if (length < 0) {  
			printf("Server Recieve Data Failed!\n");  
			exit(1);  
    	        }
	  
		memcpy(&p3,buffer,sizeof(p3));
		if (strcmp(p3.DataForm_content, "test") == 0) {	
			Recvtime_sec=p3.DataForm_send_sec;
			Recvtime_usec=p3.DataForm_send_usec;
			gettimeofday(&t_end, NULL);
			latecy=(1000000*(t_end.tv_sec-Recvtime_sec)+(t_end.tv_usec-Recvtime_usec))/2;
			printf("延时是%ld微秒\n",latecy);
		}
		sleep(1);
		th_condflag_broadcast(&flag3_4,&cond3_4,&mutex);
		pthread_mutex_unlock(&mutex);
	}
}
	
//*线程4向服务器发送test包 序列号_收服务器test包 计算延时并输出 *//

void *send_sn4()
{	
	while(1) {
		pthread_mutex_lock(&mutex);
		th_condflag_wait(&flag3_4,&cond3_4,&mutex);
		p1.DataForm_i++;
		gettimeofday(&t_begin, NULL);
		p1.DataForm_send_sec=t_begin.tv_sec;
		p1.DataForm_send_usec=t_begin.tv_usec;
		strcpy(p1.DataForm_content,"test");
		bzero(msg, sizeof(msg));
		memcpy(msg,&p1,sizeof(p1));
		iSent=send(sockfd_4,msg,sizeof(msg),0);
		if (iSent<0) {  
			printf("Client Send Data Failed!\n");  
			exit(1);  
		}
		bzero(buffer, sizeof(buffer));
	
		length=recv(sockfd_4, buffer, sizeof(buffer), 0);  
	
		if (length < 0) {  
			printf("Server Recieve Data Failed!\n");  
			exit(1);  
    		}  
		
		memcpy(&p3,buffer,sizeof(p3));
		
		if (strcmp(p3.DataForm_content, "test") == 0) {	
			Recvtime_sec=p3.DataForm_send_sec;
			Recvtime_usec=p3.DataForm_send_usec;
			gettimeofday(&t_end, NULL);
			latecy=(1000000*(t_end.tv_sec-Recvtime_sec)+(t_end.tv_usec-Recvtime_usec))/2;
			printf("延时是%ld微秒\n",latecy);
		}
		sleep(1);
		th_condflag_broadcast(&flag4_5,&cond4_5,&mutex);
		pthread_mutex_unlock(&mutex);
	}
}
//*线程5向服务器发送test包 序列号_收服务器test包 计算延时并输出 *//
void *send_sn5()
{	
	while(1) {
		pthread_mutex_lock(&mutex);
		th_condflag_wait(&flag4_5,&cond4_5,&mutex);
		p1.DataForm_i++;
		gettimeofday(&t_begin, NULL);
		p1.DataForm_send_sec=t_begin.tv_sec;
		p1.DataForm_send_usec=t_begin.tv_usec;
		strcpy(p1.DataForm_content,"test");
		bzero(msg, sizeof(msg));
		memcpy(msg,&p1,sizeof(p1));
		iSent=send(sockfd_5,msg,sizeof(msg),0);
		if (iSent<0) {  
			printf("Client Send Data Failed!\n");  
			exit(1);  
		}
		bzero(buffer, sizeof(buffer));
		length=recv(sockfd_5, buffer, sizeof(buffer), 0);  
		if (length < 0) {  
			printf("Server Recieve Data Failed!\n");  
			exit(1);  
    	}  
		memcpy(&p3,buffer,sizeof(p3));
		if (strcmp(p3.DataForm_content, "test") == 0) {	
			Recvtime_sec=p3.DataForm_send_sec;
			Recvtime_usec=p3.DataForm_send_usec;
			gettimeofday(&t_end, NULL);
			latecy=(1000000*(t_end.tv_sec-Recvtime_sec)+(t_end.tv_usec-Recvtime_usec))/2;
			printf("延时是%ld微秒\n",latecy);
		}
		sleep(1);
		th_condflag_broadcast(&flag5_1,&cond5_1,&mutex);
		pthread_mutex_unlock(&mutex);
	}
}
int main(int argc, char **argv)
{
    /*申明线程ID*/
	pthread_t send_tid1,send_tid2,send_tid3,send_tid4,send_tid5; 
	p1.DataForm_i=0;
 	/*(1) 设置链接服务器地址结构*/ 
	bzero(&servaddr , sizeof(servaddr));  
	servaddr.sin_family = AF_INET;  
	servaddr.sin_port = htons(PORT);
	servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); 
	/*(2) 创建套接字，连接套接字,接受test请求*/
	sockfd= socket(AF_INET,SOCK_STREAM , 0);
	if(sockfd==-1) {  
	perror("socket error");  
	exit(1);  
	}
	if (connect(sockfd, (struct sockaddr *)&servaddr , sizeof(servaddr)) < 0) {  
		perror("connect error");  
		exit(1);
	};
	length=recv(sockfd, buffer, sizeof(buffer), 0);  
	if (length < 0) {  
		printf("Recieve Data Failed!\n");  
		exit(1);  
    } 
	if (strcmp(buffer, "test ready") == 0) {
		printf("test begin\n");
		sleep(1);
	/*(3)创建5个线程的套接字并连接*/
		sockfd_1= socket(AF_INET,SOCK_STREAM , 0);
		if(sockfd_1==-1) {  
			perror("socket_1 error");  
			exit(1);  
		}//创建套接字1
		if (connect(sockfd_1, (struct sockaddr *)&servaddr , sizeof(servaddr)) < 0) {  
			perror("connect error");  
			exit(1);  
		};//连接套接字1
		sockfd_2= socket(AF_INET,SOCK_STREAM , 0);
		if(sockfd_2==-1) {  
        	perror("socket_2 error");  
        	exit(1);  
		}//创建套接字2
		if (connect(sockfd_2, (struct sockaddr *)&servaddr , sizeof(servaddr)) < 0) {  
			perror("connect error");  
			exit(1);  
		}; //连接套接字2
		sockfd_3= socket(AF_INET,SOCK_STREAM , 0);
		if(sockfd_3==-1) {  
			perror("socket error");  
			exit(1);  
		}//创建套接字3
		if (connect(sockfd_3, (struct sockaddr *)&servaddr , sizeof(servaddr)) < 0) {  
			perror("connect error");  
			exit(1);  
		} //连接套接字3
		sockfd_4= socket(AF_INET,SOCK_STREAM , 0);
		if(sockfd_4==-1) {  
			perror("socket error");  
			exit(1);  
		}//创建套接字4
		if (connect(sockfd_4, (struct sockaddr *)&servaddr , sizeof(servaddr)) < 0) {  
			perror("connect error");  
			exit(1);
		};//连接套接字4
		sockfd_5= socket(AF_INET,SOCK_STREAM , 0);
		if(sockfd_5==-1) {  
			perror("socket error");  
			exit(1);  
		}//创建套接字5
		if (connect(sockfd_5, (struct sockaddr *)&servaddr , sizeof(servaddr)) < 0) {  
			perror("connect error");  
			exit(1);  
		};//连接套接字5
		/*创建5个线程向服务器发送序列号*/
		pthread_mutex_init(&mutex,NULL);
  		if (pthread_create(&send_tid1, NULL , send_sn1, NULL) == -1) {  
			perror("pthread create error.\n");  
			exit(1);  
		} 
		if (pthread_create(&send_tid2, NULL , send_sn2, NULL) == -1) {  
			perror("pthread create error.\n");  
			exit(1);  
		} 
		if (pthread_create(&send_tid3, NULL , send_sn3, NULL) == -1) {  
			perror("pthread create error.\n");  
			exit(1);  
		}
		if (pthread_create(&send_tid4, NULL , send_sn4, NULL) == -1) {  
			perror("pthread create error.\n");  
			exit(1);  
		}
		if (pthread_create(&send_tid5, NULL , send_sn5, NULL) == -1) {  
			perror("pthread create error.\n");  
			exit(1);  
		}
		//给起始线程发信号，防止1和5死锁
		pthread_mutex_lock(&mutex);  
    	        th_condflag_broadcast(&flag5_1,&cond5_1,&mutex);  
    	        pthread_mutex_unlock(&mutex);  
		pthread_join(send_tid1,NULL);
		pthread_join(send_tid2,NULL);
		pthread_join(send_tid3,NULL);
		pthread_join(send_tid4,NULL);
		pthread_join(send_tid5,NULL);	  
		pthread_mutex_destroy(&mutex);
		}
	return 0;  
}












 
 

  
  
client端分析：
 
 


 
 

  
  
1.基本实现了需求的功能，用pthread_cond_wait实现了按顺序发送的功能
 
 


 
 

  
  
2.封装性较差，5个函数send_sn，实现了几乎相同的功能。可以将cond，flag，sockfd作为参数传递进去
 
 


 
 

  
  
修改方法如下：
 
 


 
 


  
  
typedef  struct{
	int cond_wait;
	int flag_tell;
	int cond_tell;
	int socketfd;
   }send_t

void *send_sn（void *arg)
{
	send_t  *send = (send_t  *)arg
	while(1) {
		pthread_mutex_lock(&mutex);
		th_condflag_wait(&(send->flag_wait),&(send->cond_wait),&mutex); 
		p1.DataForm_i++;
		gettimeofday(&t_begin, NULL);//get send time
		p1.DataForm_send_sec=t_begin.tv_sec;
		p1.DataForm_send_usec=t_begin.tv_usec;
		strcpy(p1.DataForm_content,"test");
		bzero(msg, sizeof(msg));
		memcpy(msg,&p1,sizeof(p1));
		iSent=send(send->socketfd,msg,sizeof(msg),0);
		If (iSent<0) {  
			printf("Client Send Data Failed!\n");  
			exit(1);  
		}
		bzero(buffer, sizeof(buffer));
		length=recv(send->socketfd, buffer, sizeof(buffer), 0);  
		if (length < 0) {  
			printf("Server Recieve Data Failed!\n");  
			exit(1);  
           	}
  
		memcpy(&p3,buffer,sizeof(p3));
		if (strcmp(p3.DataForm_content, "test") == 0) {
			Recvtime_sec=p3.DataForm_send_sec;
			Recvtime_usec=p3.DataForm_send_usec;
			gettimeofday(&t_end, NULL);//get recive time
			latecy=(1000000*(t_end.tv_sec-Recvtime_sec)+(t_end.tv_usec-Recvtime_usec))/2;
			printf("延时是%ld微秒\n",latecy);
		}
		sleep(1);
		th_condflag_broadcast(&(send->flag_tell),&(send->cond_tell),&mutex); 
		pthread_mutex_unlock(&mutex);
	}
}

	send_t send_1;
	send_1.flag_wait = flag5_1;
	send_1. flag_tell = flag1_2;
	send_1.cond_wait = cond5_1;
	send_1.cond_tell = cond1_2;
 
	if (pthread_create(&send_tid1, NULL , send_sn,  (void *)&sent_t) == -1) {  
		perror("pthread create error.\n");  
		exit(1);  
	} 


  
  


  
  


 
 




/* 
*  服务器端代码实现 
*/  

#include "confile.h"
//定义接收数据包结构体
	struct DataForm
	{
	char 	DataForm_content[1024];
	int 	DataForm_i;
	long    DataForm_send_sec;
	long 	DataForm_send_usec;
	};
	
int main(int argc , char **argv)  
{  
	struct DataForm p2;//接受包的结构体
	int i,p,maxi, maxfd, listenfd, connfd, sockfd, testfd;//创建套接字
	int nready , client[BACKLOG];//select的返回值    
	ssize_t n;// 接收字节	  
	fd_set rset , allset;//定义套接字的文件描述符
	char buffer[MAX_LINE];//接受信息的缓存区 
	socklen_t clilen;
	//设置套接字地址结构
	struct sockaddr_in servaddr,cliaddr;
	clilen = sizeof(cliaddr);
	bzero(&servaddr , sizeof(servaddr));  
	servaddr.sin_family = AF_INET;	
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
	servaddr.sin_port = htons(PORT);  
	/*(1) 得到监听描述符*/	
	listenfd = socket(AF_INET , SOCK_STREAM , 0);  
	/*(2) 绑定套接字*/	
	bind(listenfd , (struct sockaddr *)&servaddr , sizeof(servaddr));  	  
	/*(3) 监听*/  
	listen(listenfd , LISTENQ);
	/*(4) 向服务器发送test信号*/
	if((testfd= accept(listenfd , (struct sockaddr *)&cliaddr , &clilen)) < 0) {  
		perror("accept error.\n");	
		exit(1);
	}
	bzero(buffer,sizeof(buffer));
	strcpy(buffer,"test ready");
	send(testfd,buffer,sizeof(buffer),0);
	/*(5) 设置select*/	
	maxfd = listenfd;  
	maxi = -1;	
	p=0;
	for(i=0 ; i<BACKLOG; ++i)  
	{  
		client[i] = -1;  
		}//for	
	FD_ZERO(&allset);  
	FD_SET(listenfd , &allset);    
	/*(6) 进入服务器接收请求死循环*/  
	while(1) {  
		p++;//计数器
		rset = allset;//向文件描述符赋值	
		nready = select(maxfd+1 , &rset , NULL , NULL , NULL);	  
		if(FD_ISSET(listenfd , &rset)) {//判断是否有新的套接字进入     
			printf("\naccpet connection~\n");  
			if((connfd = accept(listenfd , (struct sockaddr *)&cliaddr , &clilen)) < 0) { //连接
				perror("accept error.\n");	
				exit(1);  
			}//if		  
			printf("accpet a new client: %s:%d\n", inet_ntoa(cliaddr.sin_addr) , cliaddr.sin_port);
		/*将客户链接套接字描述符添加到数组*/  
			for(i=0 ; i<FD_SETSIZE ; ++i) {  
				if(client[i] < 0) {  
				client[i] = connfd;  
				break;	
				}  
			}	
			if(BACKLOG == i) {//判断是否达到最大监听数
				perror("too many connection.\n");  
				exit(1);  
			}  
			FD_SET(connfd , &allset);//把新连接加入到allset中
			if(connfd > maxfd) {	
				maxfd = connfd;
			}
			if(i > maxi) {  
				maxi = i;
			}
			if(--nready < 0) {//说明没有新连接 
				continue;
			}
		}//if    
		for(i=0; i<=maxi ; ++i) {  
			if((sockfd = client[i]) < 0)//  
				continue;  
			if(FD_ISSET(sockfd , &rset)) {  
				/*处理客户请求*/  
				bzero(buffer , MAX_LINE);
				if((n = recv(sockfd , buffer, sizeof(buffer), 0)) <= 0) {  
					close(sockfd);	
					FD_CLR(sockfd , &allset);  
					client[i] = -1;  
				}//if  
				else {  
					memcpy(&p2,buffer,sizeof(p2));
					printf("clint[%d] send message: %d\n", i , p2.DataForm_i);
					if(strcmp(buffer, "\0") == 0) {
						printf("传递序列号有空值\n"); 	
						continue;
					}
					if (p2.DataForm_i==p) {
						printf("传递序列号顺序乱\n");
						continue;
					}
					if (strcmp(p2.DataForm_content, "test") == 0) {
					send(sockfd,buffer,sizeof(buffer),0);
					bzero(buffer,sizeof(buffer));
					}//if 
				}//else  
			if(--nready <= 0)  
				break;	
			}//if  
		}//for	
	} 
} 

	




 
 


 
 


 
 

  
  
service端分析：
 
 


 
 

  
  
1.利用select监听多个线程，收到信息后，check包序列号是否正确，立刻返回。
 
 


 
 

  
  
2.对于一个新手来说，selec模式监听的套接字server端理解相对较为困难。
 
 


 
 


  
  


 
 













include:




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


#define MAX_LINE  2048  
#define PORT	  8000  
#define BACKLOG     10  
#define LISTENQ   6666  
#define MAX_CONNECT 20



makefile:



all:server1 client1

server1:server1.o
	arm-linux-gcc -o server1 server1.o
	
client1:client1.o
	arm-linux-gcc -o client1 client1.o -lpthread
	
server1.o:server1.c confile.h
	arm-linux-gcc -c -lpthread -Wall -Werror server1.c 
	
client1.o:client1.c confile.h
	arm-linux-gcc	-c -lpthread -Wall -Werror client1.c 

clean:
	rm *.o
	rm server1
	rm client1


 
 


 
 

一个标准的linux开发人员，应该基本写makefile，写shell脚本的能力，这一期的程序为一个简单的测试程序，不做过多的详细描述，希望各位看官提出宝贵的意见，希望初学者们可以仔细理解server端select模式代码处理逻辑，对于今后的开发会有很大的帮助

 
 


  
  


 
 





                

        

        

    




    

      

        

            

              
                
                  tc22213
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
【面试宝典】Java八股文之多线程&并发面试题

				
			

			

				

					热爱技术，享受生活
				

				

					11-22
					
					611
					
				

			

		

		

			
				
2022年接近年底了，相信绝大多数小伙伴们跳操的心已经蠢蠢欲动了，那么罡哥给大家吐血整理了Java领域各个知识点的面试题，把碎片的知识，系统化的整理，有代码有讲解，通俗易懂，最重要的好记！！！希望能够为小伙伴们的面试保驾护航，争取拿到自己期望的薪资。

			
		

	



                

              
                



	

		

			

				
					
多线程的几种实现方式

					
最新发布

				
			

			

				

					欢迎来到我的博客
				

				

					07-12
					
					3967
					
				

			

		

		

			
				
当队列中有元素后，被阻塞的线程会自动被唤醒，这极大的提高的编码的灵活性，非常方便。4.线程池ExecutorService和工具类Executors优点：可以根据实际情况创建线程数量，且只需要创建一个线程池即可，也能够通过Callable和Future接口得到线程的返回值，程序的执行时间与线程的数量紧密相关。2.继承Thread类的优点：简单，且只需要实现父类的run方法即可(start方法中含有run方法，会创建一个新的线程，而run是执行当前线程)。每当一个线程完成了自己的任务后，计数器的值就会减1。

			
		

	



                


  
              

                


	

		

			

				
					
利用信号量处理多线程示例

				
			

			

				

					05-07
				

			

		

		

			
				
利用信号量，等待函数，处理多线程示例，处理生产者和消费者问题，谢谢

			
		

	





	

		

			

				
					
线程工具类-通过信号量、计时器等机制控制多线程之间的运行阻塞-笔记整理11

				
			

			

				

					Mark2When的博客
				

				

					04-26
					
					692
					
				

			

		

		

			
				
线程工具类
1.Semaphore实现信号灯,可以控制访问线程的个数。信号量初始化10，最多只有10个线程并发访问
2.CyclicBarrier：提供一种阻塞机制，等待所有线程到达某一点集合之后，再继续向下运行
3.CountDownLatch：通过计数器技术，实现一同多，或多通知一
4.Exchanger：提供一种阻塞机制，实现俩个线程交换数据
 
 
1.Semaphore实现

			
		

	



		

			
		



	

		

			

				
					
多线程与子进程的区别

				
			

			

				

					cz2499的专栏
				

				

					10-31
					
					625
					
				

			

		

		

			
				
<br />所谓多线程：<br />线程是可执行代码的可分派单元。这个名称来源于“执行的线索”的概念。在基于线程的多任务的环境中，所有进程有至少一个线程，但是它们可以具有多个任务。这意味着单个程序可以并发执行两个或者多个任务。<br /> <br />简而言之，线程就是把一个进程分为很多片，每一片都可以是一个独立的流程。这已经明显不同于多进程了，进程是一个拷贝的流程，而线程只是把一条河流截成很多条小溪。它没有拷贝这些额外的开销，但是仅仅是现存的一条河流，就被多线程技术几乎无开销地转成很多条小流程，它的伟大就

			
		

	





	

		

			

				
					
二进制信号量在多线程间实现同步模型

				
			

			

				

					weixin_34292924的博客
				

				

					12-23
					
					108
					
				

			

		

		

			
				
2019独角兽企业重金招聘Python工程师标准>>>   
                                        
         ...

			
		

	





	

		

			

				
					
多线程任务超时的处理机制

				
			

			

				

					weixin_45151960的博客
				

				

					05-11
					
					3220
					
				

			

		

		

			
				
使用Thread.join(long million)方法，参数是毫秒
代码&解析如下：
解析：原本有t1和t2两个线程，根据实例化new Task（）时t1传入了4，t2传入了2，分别相当于t1需要执行4次，t2需要执行2次，但是在run方法中使用了Thread.sleep(1000)，所以t1执行4次就等于是执行4秒，t2同理。在t1.start启动后，调用了join方法设置了两秒的参数，相当于在t1执行两秒后就超时了，后面就是t1超时后的设置，
1、t1.interrupt()表示打断t1线程

			
		

	





	

		

			

				
					
socket多线程通信

				
			

			

				

					qq_19457459的博客
				

				

					11-02
					
					819
					
				

			

		

		

			
				
进程与线程的区别：
进程：在操作系统构成单独执行流的单位。
线程：在进程构成单独执行流的单位
线程的创建和执行流程
#include <pthread.h>
int pthread_create(pthread_t * restrict thread,const pthread_attr_t * restrict attr,
void * (* start_routine)(void ...

			
		

	





	

		

			

				
					
python3 socket threading fork 多线程+多进程 简单实例

				
			

			

				

					12-21
				

			

		

		

			
				
这篇文章主要讲解了如何在Python3中使用`socket`、`threading`以及`fork`来实现多线程和多进程的简单示例。通过这些技术，开发者可以构建一个能够同时处理多个客户端请求的服务端程序。  首先，`socket`库是Python中...

			
		

	





	

		

			

				
					
Linux多线程

				
			

			

				

					qq_44394692的博客
				

				

					12-20
					
					522
					
				

			

		

		

			
				
Linux多线程
linux多线程，看着一篇就够了！（指入门）
在学习多线程之前，为了让各位先感受多线程的厉害之处，建议先跑一下这个程序。（先保存和关闭重要的文件和程序）
//
//  test.c
//  thread
//
//  Created by echo on 2020/12/19.
//  Copyright © 2020 echo. All rights reserved.
//


#include <stdio.h>
#include <stdlib.h>
#in

			
		

	





	

		

			

				
					
java信号量控制线程打印顺序的示例分享

				
			

			

				

					09-04
				

			

		

		

			
				
主要介绍了java信号量控制线程打印顺序的示例,如ABCABC这样输出线程，大家参考使用吧

			
		

	





	

		

			

				
					
linux上实现多进程和多线程实现同步互斥（源代码）

				
			

			

				

					04-18
				

			

		

		

			
				
在linux上分别用多进程和多线程实现的同步互斥操作（源代码）

			
		

	





	

		

			

				
					
Linux下多线程及多进程及同步与互斥编程详细介绍

				
			

			

				

					09-02
				

			

		

		

			
				
Linux下多线程及多进程及同步与互斥编程详细介绍

			
		

	





	

		

			

				
					
【JAVA多线程19】JAVA 阻塞队列原理

				
			

			

				

					dcm19920115的博客
				

				

					06-13
					
					1946
					
				

			

		

		

			
				
今天我们来讨论另外一类容器：阻塞队列。

　　非阻塞队列，比如PriorityQueue、LinkedList（LinkedList是双向链表，它实现了Dequeue接口）。

　　使用非阻塞队列的时候有一个很大问题就是：它不会对当前线程产生阻塞，那么在面对类似消费者-生产者的模型时，就必须额外地实现同步策略以及线程间唤醒策略，这个实现起来就非常麻烦。但是有了阻塞队列就不一样了，它会对当前线程产生...

			
		

	





	

		

			

				
					
Socket连接超时

				
			

			

				

					weixin_34148508的博客
				

				

					01-16
					
					416
					
				

			

		

		

			
				
Socket.connect连接超时有二种情况：
1.由于网络的问题，TCP/IP三次握手时间&gt;timeout的设置时间。这在国外访问weibo时，并且网络环境极差的情况下有可能发生。解决的办法：调大socket.connect方法中的timeout参数值，比如50s，linux默认最高是70s，如果超过70s没有意义，linux会采用70s.但是当调大之后，发现不到10s就报timeou...

			
		

	





	

		

			

				
					
Socket 多线程发送数据失败问题

				
			

			

				

					Werial
				

				

					04-21
					
					731
					
				

			

		

		

			
				
Socket在主进程发送短字符消息可以成功，在多线程发送数据失败。

```cpp
void DataSendThread::run() 
{
    webclient.sendTextMessage(strData);
    webclient.flush();    //加上这句就可以成功发送
}




...

			
		

	





	

		

			

				
					
有关socket各方法执行顺序问题

				
			

			

				

					hb0523的专栏
				

				

					09-30
					
					1866
					
				

			

		

		

			
				
<br />最近在写这个方面的程序！<br />假设客户端是发送数据的，服务器是用来接收数据的！<br />我认识到的顺序是：派生于CAsyncSocket<br />1，服务器建一个socket来create and listen<br />2，客户端建一个socket来create and connect（这个时候服务器端自动触发OnAccept()，客户端自动触发OnConnect()）<br />3，服务器端在建一个socket来接收数据！<br />4，客户端send数据，这个时候客户端自动触发O

			
		

	





	

		

			

				
					
Java网络编程从入门到精通（16）：客户端套接字（Socket）的超时

				
			

			

				

					mustbelove的专栏
				

				

					12-03
					
					1402
					
				

			

		

		

			
				
客户端套接字的超时（timeout）就是指在客户端通过Socket和服务器进行通讯的过程中，由于网络延迟，网络阻塞等原因，造成服务器并未及时响应客户端的一种现象。在一段时间后，客户端由于未收到服务端的响应而抛出一个超时错误； 其中客户端所等待的时间就是超时时间。    由于生产超时错误的一端都是被动端；也就是说，这一端是在接收数据，而不是发送数据。对于客户端Socket来说，只有两个地方是在接

			
		

	





	

		

			

				
					
Socket多线程问题【转载】

				
			

			

				

					xianjiangao的专栏
				

				

					12-01
					
					1326
					
				

			

		

		

			
				
http://blog.csdn.net/dlutcat/archive/2007/10/21/1835594.aspx--  作者：心镜--  发布时间：2007-1-29 13:52:57--  JAVA中Socket的使用       网络编程基本上就是两台计算机相互通讯数据，底层常用Socket进行数据包的传送。Socket有两种主要的操作方式：面向连接的和无连接的。面向连接的

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值