Linux C/TCP多线程网络聊天室
多线程TCP网络聊天室
我们都知道TCP是一种基于连接的传输协议，使用多线程来实现其实步骤很简单。
首先说明一下项目：服务端开启后，直接运行客户端可以加入聊天室，同时其他客户端可以接收到某某客户端进入聊天室的消息，如果有个客户端主动退出或者意外退出，其他客户端同样会收到某某客户端退出的消息，除了这两个注意的点以外其他就是正常聊天。
注：项目只是完成基本功能，涉及一些网络安全和一些网络加密方面我也不太懂。
客户端
主程序 main函数内部
首先创建网络套接字sockfd，sockfd我创建到全局变量里方便线程使用
sockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建网络套接字
创建server的网络信息结构体并填充
struct sockaddr_in serverSock;
socklen_t serverLen = sizeof(struct sockaddr_in);
//地址为回环地址,如果想要使用其他地址请把htonl(INADDR_ANY)修改为inet_addr(IP),IP为自己地址
serverSock.sin_addr.s_addr = htonl(INADDR_ANY);
// 端口自行设置
serverSock.sin_port = htons(PORT);
serverSock.sin_family = AF_INET;
连接服务端
connect(sockfd, (struct sockaddr *)&serverSock, serverLen);
接下来就是打印下说明，好让人知道已经连接到服务端了
printf("=====欢迎加入聊天室=====\n");
printf(" 退出服务器请输入quit \n");
接下来就是创建两个线程：接收消息和发送消息
pthread_t pthreadSend;
pthread_create(&pthreadSend, NULL, pthread_send, NULL);
pthread_t pthreadRecv;
pthread_create(&pthreadRecv, NULL, pthread_recv, NULL);
在线程创建完成之后我们不要让这个程序结束，否则主程序结束线程也就跟着结束了。
while(!quit);
return 0;
quit变量是一个全局变量，是用在发送端主动输入quit的时候传递变量来结束主程序。
到这里主程序已经结束，接下来就是两个线程的内部功能
接收线程
void *pthread_recv(void *arg)
{
msg_t msg; // 接收消息的结构体，我会放到head.h文件中解释
bzero(&msg, 0); // 初始化
while (1) //循环
{
/* 阻塞接收函数,ret返回值用处来表明接收消息是否正常 */
/* 同时也能知道其他客户端是否还在不在聊天室,比如下文的等于0 */
int ret = recv(sockfd, &msg, sizeof(msg), 0);
if (ret > 0)
{
/* type变量是一个区分,1为正常消息,0为不正常,通常是有客户端主动正常退出 */
if (msg.type == 1 && strlen(msg.message) > 0)
{
/* 打印消息同时打印是哪个客户端打印的 */
printf("客户端(%s:%d):%s\n", inet_ntoa(msg.cli.client.sin_addr), ntohs(msg.cli.client.sin_port), msg.message);
}
else
{
printf("%s\n", msg.message);
}
}
/* 为0就是某某客户端断开连接 */
else if (ret == 0)
{
printf("%s\n", msg.message);
}
}
}
发送线程
void *pthread_send(void *arg)
{
msg_t msg;
bzero(&msg, 0);
while (1)
{
/* 读取输入 */
scanf("%s", msg.message);
/* 防止读取到一个回车就发送 */
if (getchar() == '\n' && msg.message[0] != '\n')
{
/* 安全起先还是加了一个\0 */
int len = strlen(msg.message);
msg.message[len + 1] = '\0';
send(sockfd, &msg, sizeof(msg), 0);
/* 如果是quit的话令quit变量为true,这样主程序会结束 */
if (!strcmp(msg.message, "quit"))
{
quit = true;
break;
}
memset(msg.message, 0, sizeof(msg.message));
}
}
}
到这里客户端代码结束。
服务端
服务端采用多线程的话,思路是这样的
服务端 main函数内部
int main()
{
sockfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in serverSock;
socklen_t serverLen = sizeof(struct sockaddr_in);
serverSock.sin_addr.s_addr = htonl(INADDR_ANY);
serverSock.sin_port = htons(PORT);
serverSock.sin_family = AF_INET;
bind(sockfd, (struct sockaddr *)&serverSock, serverLen);
listen(sockfd, 0);
pthread_t acceptPthread;
pthread_create(&acceptPthread, NULL, pthread_accept, NULL);
while (1)
;
return 0;
}
main函数整体思路跟客户端是一致的,唯一区别就是只有一个接收线程,同时while(1)死循环,只是为了实现客户端主动退出,并未考虑服务端主动关闭。
服务端接收线程函数
void *pthread_accept(void *arg)
{
struct sockaddr_in clientSock;
socklen_t clientLen = sizeof(struct sockaddr_in);
printf("===========聊天室已创建===========\n");
while (1)
{
int acceptFd = accept(sockfd, (struct sockaddr *)&clientSock, &clientLen);
/*pNode保存客户端信息,并将这个结构体传递给common的线程*/
/*common线程是把客户端加入到链表中之后再创建的用于接收和转发聊天*/
cli_t *pNode = (cli_t *)malloc(sizeof(cli_t));
pNode->client = clientSock;
pNode->fd = acceptFd;
pNode->next = NULL;
/*采用头插法*/
if (phead.size > 0)
{
cli_t *p = phead.cli.next;
phead.cli.next = pNode;
pNode->next = p;
}
else if (phead.size == 0)
{
phead.cli.next = pNode;
}
phead.size++;
pthread_t commonPthread;
/*创建聊天线程*/
pthread_create(&commonPthread, NULL, pthread_common, (void *)pNode);
pthread_detach(commonPthread);
}
}
服务端聊天线程
void *pthread_common(void *arg)
{
/*传递过来的pNode结构体中包含客户端的信息*/
cli_t *pNode = (cli_t *)arg;
/*打印给服务端显示*/
printf("客户端(%s:%d)加入聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
/*如果客户端链表大于1就转发某某加入聊天室的信息,并通知其他客户端*/
if (phead.size > 1)
{
cli_t *p = &phead.cli;
msg_t msg;
bzero(&msg, 0);
msg.cli = *pNode;
msg.type = 0;
sprintf(msg.message, "客户端(%s:%d)加入聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
while (p->next != NULL)
{
p = p->next;
/*除自己外不用发*/
if (p->fd == pNode->fd)
continue;
send(p->fd, &msg, sizeof(msg), 0);
}
}
/*死循环,接收和转发消息或者处理客户端消息*/
while (1)
{
msg_t msgs;
bzero(&msgs, 0);
int ret = recv(pNode->fd, &msgs, sizeof(msgs), 0);
/* 这里对客户端链表上锁,以防止两个或多个客户端同时退出造成 */
/* 服务端崩溃或者转发消息失败 */
pthread_mutex_lock(&phead.lock);
if (ret > 0)
{
/*先对发来quit消息的客户端进行处理*/
if (!strcmp("quit", msgs.message))
{
phead.size--;
msgs.type = 0;
printf("客户端(%s:%d)退出聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
sprintf(msgs.message, "客户端(%s:%d)退出聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
cli_t *p = &phead.cli;
while (p->next != NULL)
{
p = p->next;
if (p->fd == pNode->fd)
{
continue;
}
send(p->fd, &msgs, sizeof(msgs), 0);
}
/* 待消息转发结束之后解锁链表 */
pthread_mutex_unlock(&phead.lock);
/* 从链表中删除此客户端信息 */
delNodeFromList(&phead, pNode->fd);
/* 关闭此套接字 */
close(pNode->fd);
/* 线程结束 */
pthread_cancel(pthread_self());
bzero(&msgs, 0);
break;
}
else // 如果不是quit就正常转发此客户端发来的消息
{
msgs.cli = *pNode;
cli_t *p = &phead.cli;
/* type = 1就是为了能够客户端那边打印客户端消息 */
msgs.type = 1;
while (p->next != NULL)
{
p = p->next;
if (p->fd == pNode->fd)
continue;
send(p->fd, &msgs, sizeof(msgs), 0);
}
/* 正常发送消息结束后解锁链表 */
pthread_mutex_unlock(&phead.lock);
}
}
/* 这就是ret小于等于0的情况了,表示客户端意外退出 */
/* 其处理方法和上边quit的处理相同,不过就是发送消息改为了 */
/* 意外退出而已 */
else
{
phead.size--;
msgs.type = 0;
printf("客户端(%s:%d)意外退出聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
sprintf(msgs.message, "客户端(%s:%d)意外退出聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
cli_t *p = &phead.cli;
while (p->next != NULL)
{
p = p->next;
if (p->fd == pNode->fd)
{
continue;
}
send(p->fd, &msgs, sizeof(msgs), 0);
}
pthread_mutex_unlock(&phead.lock);
delNodeFromList(&phead, pNode->fd);
pthread_cancel(pthread_self());
close(pNode->fd);
bzero(&msgs, 0);
break;
}
}
}
服务端 链表删除客户端节点函数
void delNodeFromList(msg_t *phead, int fd)
{
if (phead == NULL)
return;
cli_t *p = &phead->cli;
cli_t *pDel = NULL;
/* 遍历链表找到要删除客户端的节点令pDel指向它 */
while (p->next != NULL)
{
if (p->next->fd == fd)
{
pDel = p->next;
break;
}
p = p->next;
}
p->next = pDel->next;
pDel->next = NULL;
free(pDel);
pDel = NULL;
}
服务端server.c文件
#include "../head.h"
msg_t phead;
int sockfd;
void delNodeFromList(msg_t *phead, int fd)
{
if (phead == NULL)
return;
cli_t *p = &phead->cli;
cli_t *pDel = NULL;
/* 遍历链表找到要删除客户端的节点令pDel指向它 */
while (p->next != NULL)
{
if (p->next->fd == fd)
{
pDel = p->next;
break;
}
p = p->next;
}
p->next = pDel->next;
pDel->next = NULL;
free(pDel);
pDel = NULL;
}
void *pthread_common(void *arg)
{
/*传递过来的pNode结构体中包含客户端的信息*/
cli_t *pNode = (cli_t *)arg;
/*打印给服务端显示*/
printf("客户端(%s:%d)加入聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
/*如果客户端链表大于1就转发某某加入聊天室的信息,并通知其他客户端*/
if (phead.size > 1)
{
cli_t *p = &phead.cli;
msg_t msg;
bzero(&msg, 0);
msg.cli = *pNode;
msg.type = 0;
sprintf(msg.message, "客户端(%s:%d)加入聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
while (p->next != NULL)
{
p = p->next;
/*除自己外不用发*/
if (p->fd == pNode->fd)
continue;
send(p->fd, &msg, sizeof(msg), 0);
}
}
/*死循环,接收和转发消息或者处理客户端消息*/
while (1)
{
msg_t msgs;
bzero(&msgs, 0);
int ret = recv(pNode->fd, &msgs, sizeof(msgs), 0);
/* 这里对客户端链表上锁,以防止两个或多个客户端同时退出造成 */
/* 服务端崩溃或者转发消息失败 */
pthread_mutex_lock(&phead.lock);
if (ret > 0)
{
/*先对发来quit消息的客户端进行处理*/
if (!strcmp("quit", msgs.message))
{
phead.size--;
msgs.type = 0;
printf("客户端(%s:%d)退出聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
sprintf(msgs.message, "客户端(%s:%d)退出聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
cli_t *p = &phead.cli;
while (p->next != NULL)
{
p = p->next;
if (p->fd == pNode->fd)
{
continue;
}
send(p->fd, &msgs, sizeof(msgs), 0);
}
/* 待消息转发结束之后解锁链表 */
pthread_mutex_unlock(&phead.lock);
/* 从链表中删除此客户端信息 */
delNodeFromList(&phead, pNode->fd);
/* 关闭此套接字 */
close(pNode->fd);
/* 线程结束 */
pthread_cancel(pthread_self());
bzero(&msgs, 0);
break;
}
else // 如果不是quit就正常转发此客户端发来的消息
{
msgs.cli = *pNode;
cli_t *p = &phead.cli;
/* type = 1就是为了能够客户端那边打印客户端消息 */
msgs.type = 1;
while (p->next != NULL)
{
p = p->next;
if (p->fd == pNode->fd)
continue;
send(p->fd, &msgs, sizeof(msgs), 0);
}
/* 正常发送消息结束后解锁链表 */
pthread_mutex_unlock(&phead.lock);
}
}
/* 这就是ret小于等于0的情况了,表示客户端意外退出 */
/* 其处理方法和上边quit的处理相同,不过就是发送消息改为了 */
/* 意外退出而已 */
else
{
phead.size--;
msgs.type = 0;
printf("客户端(%s:%d)意外退出聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
sprintf(msgs.message, "客户端(%s:%d)意外退出聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
cli_t *p = &phead.cli;
while (p->next != NULL)
{
p = p->next;
if (p->fd == pNode->fd)
{
continue;
}
send(p->fd, &msgs, sizeof(msgs), 0);
}
pthread_mutex_unlock(&phead.lock);
delNodeFromList(&phead, pNode->fd);
pthread_cancel(pthread_self());
close(pNode->fd);
bzero(&msgs, 0);
break;
}
}
}
void *pthread_accept(void *arg)
{
struct sockaddr_in clientSock;
socklen_t clientLen = sizeof(struct sockaddr_in);
printf("===========聊天室已创建===========\n");
while (1)
{
int acceptFd = accept(sockfd, (struct sockaddr *)&clientSock, &clientLen);
/*pNode保存客户端信息,并将这个结构体传递给common的线程*/
/*common线程是把客户端加入到链表中之后再创建的用于接收和转发聊天*/
cli_t *pNode = (cli_t *)malloc(sizeof(cli_t));
pNode->client = clientSock;
pNode->fd = acceptFd;
pNode->next = NULL;
/*采用头插法*/
if (phead.size > 0)
{
cli_t *p = phead.cli.next;
phead.cli.next = pNode;
pNode->next = p;
}
else if (phead.size == 0)
{
phead.cli.next = pNode;
}
phead.size++;
pthread_t commonPthread;
/*创建聊天线程*/
pthread_create(&commonPthread, NULL, pthread_common, (void *)pNode);
pthread_detach(commonPthread);
}
}
int main()
{
sockfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in serverSock;
socklen_t serverLen = sizeof(struct sockaddr_in);
serverSock.sin_addr.s_addr = htonl(INADDR_ANY);
serverSock.sin_port = htons(PORT);
serverSock.sin_family = AF_INET;
bind(sockfd, (struct sockaddr *)&serverSock, serverLen);
listen(sockfd, 0);
pthread_t acceptPthread;
pthread_create(&acceptPthread, NULL, pthread_accept, NULL);
while (1)
;
return 0;
}
客户端client.c文件
#include "../head.h"
int sockfd;
int quit = 0;
void *pthread_recv(void *arg)
{
msg_t msg; // 接收消息的结构体，我会放到head.h文件中解释
bzero(&msg, 0); // 初始化
while (1) //循环
{
/* 阻塞接收函数,ret返回值用处来表明接收消息是否正常 */
/* 同时也能知道其他客户端是否还在不在聊天室,比如下文的等于0 */
int ret = recv(sockfd, &msg, sizeof(msg), 0);
if (ret > 0)
{
/* type变量是一个区分,1为正常消息,0为不正常,通常是有客户端主动正常退出 */
if (msg.type == 1 && strlen(msg.message) > 0)
{
/* 打印消息同时打印是哪个客户端打印的 */
printf("客户端(%s:%d):%s\n", inet_ntoa(msg.cli.client.sin_addr), ntohs(msg.cli.client.sin_port), msg.message);
}
else
{
printf("%s\n", msg.message);
}
}
/* 为0就是某某客户端断开连接 */
else if (ret == 0)
{
printf("%s\n", msg.message);
}
}
}
void *pthread_send(void *arg)
{
msg_t msg;
bzero(&msg, 0);
while (1)
{
/* 读取输入 */
scanf("%s", msg.message);
/* 防止读取到一个回车就发送 */
if (getchar() == '\n' && msg.message[0] != '\n')
{
/* 安全起先还是加了一个\0 */
int len = strlen(msg.message);
msg.message[len + 1] = '\0';
send(sockfd, &msg, sizeof(msg), 0);
/* 如果是quit的话令quit变量为true,这样主程序会结束 */
if (!strcmp(msg.message, "quit"))
{
quit = true;
break;
}
memset(msg.message, 0, sizeof(msg.message));
}
}
}
int main()
{
sockfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in serverSock;
socklen_t serverLen = sizeof(struct sockaddr_in);
serverSock.sin_addr.s_addr = htonl(INADDR_ANY);
serverSock.sin_port = htons(PORT);
serverSock.sin_family = AF_INET;
connect(sockfd, (struct sockaddr *)&serverSock, serverLen);
printf("=====欢迎加入聊天室=====\n");
printf(" 退出服务器请输入quit \n");
msg_t msg;
bzero(&msg, 0);
pthread_t pthreadSend;
pthread_create(&pthreadSend, NULL, pthread_send, NULL);
pthread_t pthreadRecv;
pthread_create(&pthreadRecv, NULL, pthread_recv, NULL);
while (!quit)
;
return 0;
}
head.h头文件
#ifndef __HEAD_H__
#define __HEAD_H__
#include Makefile文件编译两个可执行文件,cli和ser
all:
gcc client.c -o cli -lpthread
gcc server.c -o ser -lpthread
clean:
rm -rf cli ser
最后效果
正常加入聊天室和聊天的效果
主动退出和意外退出的效果