Linux c编程之多线程

已于 2022-12-15 15:10:38 修改
阅读量1.5k 收藏 18
点赞数 2
分类专栏： Linux C网络编程实践 文章标签： linux 多线程 pthread_create c语言 pthread
于 2022-12-11 19:54:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szkbsgy/article/details/128242188
版权

一、说明

  运行的程序叫进程，进程是系统资源分配的最小单元。而线程是操作系统能够进行运算调度的最小单位。一个进程默认是有一个线程在运行，也叫单线程进程，也可以启动多个线程，叫做多线程进程。
多线程有如下特点：

  • 共用同一进程的地址空间
  • 共享进程的全局变量

二、常用API

2.1 pthread_create()

#include <pthread.h>
int pthread_create(pthread_t *thread,
                   const pthread_attr_t *attr,
                   void *(*start_routine) (void *),
                   void *arg);

作用：创建新线程
参数说明：
  thread: 线程ID，是输出参数，创建成功后，系统将thread设置为线程ID
  attr： 线程属性，使用pthread_attr_init和相关的函数进行初始化。如果该参数为NULL,则使用默认的属性创建线程
  start_routine: 新线程执行的函数
  arg: 新线程的函数参数
返回值：
  成功返回0，失败返回错误号

2.2 pthread_join()

int pthread_join(pthread_t thread, void **retval);

作用：阻塞等待指定的线程终止，回收相应的资源。如果线程已
  经终止，则pthread_join立即返回。
参数说明：
  thread: 线程ID
  retval： 输出参数，用来保存线程的退出状态（比如调
    用pthread_exit()指定的退出值）。如果
    不需要获取退出状态时，可以使用NULL
返回值：
  成功返回0，失败返回错误号

2.3 pthread_cancel()

int pthread_cancel(pthread_t thread);

作用：取消（结束）线程
参数说明：
  thread: 线程ID

2.4 pthread_exit()

void pthread_exit(void *retval);

作用：主动退出线程
参数说明：
  retval: 线程退出状态值。如果线程是非分离状态，则可以在另一个线程通过调用pthread_join获得退出的状态值

2.5 pthread_attr_init()

 int pthread_attr_init(pthread_attr_t *attr);

作用：初始化属性
返回值：成功返回0， 失败返回错误号

2.6 pthread_attr_destroy()

int pthread_attr_destroy(pthread_attr_t *attr);

作用：销毁属性
返回值：成功返回0， 失败返回错误号

2.7 pthread_attr_setdetachstate()

    int pthread_attr_setdetachstate(pthread_attr_t *attr,
            int detachstate);

作用：将线程设置为分离状态
参数说明：
  thread: 线程ID
返回值：成功返回0， 失败返回错误号

2.8 pthread_attr_getdetachstate()

    int pthread_attr_getdetachstate(pthread_attr_t *attr, 
        int *detachstate);

作用：获取分离状态信息
参数说明：
  attr: 属性
  detachstate：分离状态变量，传入参数。
        0：不分离 1：分离
返回值：成功返回0，失败返回错误号

2.9 pthread_t pthread_self()

 pthread_t pthread_self(void);

作用： 获取当前线程的ID
返回值：返回线程的ID

2.10 pthread_detach()

 int pthread_detach(pthread_t thread);

作用: 将线程设置为分离状态
参数说明：
  thread: 线程ID
返回值:成功返回0,失败返回错误号

2.11 pthread_cond_init()

    #include <pthread.h>
    int pthread_cond_init(pthread_cond_t *restrict cond,
              const pthread_condattr_t *restrict attr);

作用：初始化条件变量

2.12 pthread_cond_destroy()

    #include <pthread.h>
    int pthread_cond_destroy(pthread_cond_t *cond);

作用：销毁条件变量

2.13 互斥锁pthread_mutex_xxx()

    #include <pthread.h>
    int pthread_mutex_lock(pthread_mutex_t *mutex);
    int pthread_mutex_trylock(pthread_mutex_t *mutex);
    int pthread_mutex_unlock(pthread_mutex_t *mutex);

注：以上所有的pthread_xxx()函数编译时需要链接thread库（-pthread）

三、实例解析

3.1 最简单的线程

multi_pthread.c:

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

void *thread_func(void *arg)
{
    pthread_t tid = 0;

    tid = pthread_self();
    printf("sub tid:%ld in sub thread\n", tid);

    while (1) {
        printf("I am sub pthread\n");
        sleep(1);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t tid = 0;
    pthread_t main_tid = 0;
    pthread_attr_t attr;

    ret = pthread_create(&tid, NULL, thread_func, NULL);

    main_tid = pthread_self();
    printf("ret:%d, sub tid:%ld, main tid:%ld\n", ret, tid, main_tid);

    while (1) {
        printf("I am main thread\n");
        sleep(1);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out multi_pthread.c -lpthread
clean:
	-@rm a.out

注：编译时需要链接pthread库
测试：

$ ./a.out 
ret:0, sub tid:140442318440192, main tid:140442326722368
I am main thread
sub tid:140442318440192 in sub thread
I am sub pthread
I am main thread
I am sub pthread
I am main thread
I am sub pthread
I am main thread
I am sub pthread

3.2 线程参数

3.2.1 变量参数

thread_param.c:

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

void *thread_func(void *arg)
{
    pthread_t tid = 0;
    long thread_number = -1;

    thread_number = (long)arg;

    tid = pthread_self();
    printf("tid:%ld, number:%ld\n", tid, thread_number);

    while (1) {
        printf("I am sub pthread, thread number:%ld\n", thread_number);
        sleep(1);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    long i = 0;
    pthread_t tid = 0;
    pthread_t main_tid = 0;

    for (i = 0; i < 3; i++) {
        ret = pthread_create(&tid, NULL, thread_func,  (void *)i);
    }

    while (1) {
        printf("I am main thread\n");
        sleep(1);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out thread_param.c -lpthread
clean:
	-@rm a.out

测试：

$ ./a.out 
I am main thread
tid:139938984036096, number:2
I am sub pthread, thread number:2
tid:139938992428800, number:1
I am sub pthread, thread number:1
tid:139939000821504, number:0
I am sub pthread, thread number:0
I am main thread
I am sub pthread, thread number:2
I am sub pthread, thread number:1
I am sub pthread, thread number:0

3.2.2 结构体参数

thread.c:

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

typedef struct thread_info_s
{
    int number;
    char name[32];
} thread_info_t;

thread_info_t g_thread_info;

void *thread_func(void *arg)
{
    pthread_t tid = 0;
    thread_info_t *thread_info = NULL;

    thread_info = (thread_info_t *)arg;

    tid = pthread_self();
    printf("tid:%ld, name:%s, number:%d\n",
                    tid, thread_info->name, thread_info->number);

    while (1) {
        sleep(1);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t tid = 0;
    pthread_t main_tid = 0;

    g_thread_info.number = 1;
    strcpy(g_thread_info.name, "test-thread");

    ret = pthread_create(&tid, NULL, thread_func,  (void *)&g_thread_info);

    while (1) {
        sleep(1);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out thread.c -lpthread
clean:
	-@rm a.out

测试结果：

$ ./a.out 
tid:140212589033216, name:test-thread, number:1

3.3 线程的退出值及分离属性

3.3.1 退出值为字符串

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

void *thread_func(void *arg)
{
    pthread_t tid = 0;

    tid = pthread_self();
    printf("sub tid:%ld\n", tid);

    sleep(3);

    pthread_exit((void *)"hello world");
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t tid = 0;
    void *exit_value = NULL;

    ret = pthread_create(&tid, NULL, thread_func, NULL);

    pthread_join(tid, (void **)(&exit_value));
    printf("thread exit value:%s\n", (char *)exit_value);

    return 0;
}

测试：

$ ./a.out 
sub tid:140493947586304
thread exit value:hello world

3.3.2 退出值为整型

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

void *thread_func(void *arg)
{
    pthread_t tid = 0;
    static int exit_value = 5;

    tid = pthread_self();
    printf("sub tid:%ld\n", tid);

    sleep(3);

    pthread_exit((void *)&exit_value);
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t tid = 0;
    int *exit_value = NULL;

    ret = pthread_create(&tid, NULL, thread_func, NULL);

    pthread_join(tid, (void **)(&exit_value));
    printf("thread exit value:%d\n", *exit_value);

    return 0;
}

测试：

$ ./a.out 
sub tid:139728337950464
thread exit value:5

3.3.3 线程分离状态时

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

void *thread_func(void *arg)
{
    pthread_t tid = 0;

    tid = pthread_self();
    printf("sub tid:%ld\n", tid);

    sleep(10);

    pthread_exit((void *)"hello world");
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t tid = 0;
    void *exit_value = NULL;
    pthread_attr_t thread_attr;
    int detachstate = 1;

    pthread_attr_init(&thread_attr);

    pthread_attr_setdetachstate(&thread_attr, detachstate);

    ret = pthread_create(&tid, &thread_attr, thread_func, NULL);

    pthread_join(tid, (void **)(&exit_value));
    printf("thread exit value:%s\n", (char *)exit_value);

    pthread_attr_destroy(&thread_attr);

    while (1) {
        sleep(2);
    }

    return 0;
}

测试结果：

$ ./a.out 
thread exit value:(null)
sub tid:140123777509120

3.4 同步互斥锁

没加锁之前：
thread.c:

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

#define THREAD_NUMBER 3

int g_seq = 0;

void *thread_func(void *arg)
{
    long thread_number = -1;

    thread_number = (long)arg;

    while (1) {
        g_seq++;
        printf("I am sub pthread, thread number:%ld, g_seq:%d\n", thread_number, g_seq);
        usleep(1000);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    long i = 0;
    pthread_t tid[THREAD_NUMBER];

    for (i = 0; i < THREAD_NUMBER; i++) {
        ret = pthread_create(&tid[i], NULL, thread_func,  (void *)i);
    }

    while (1) {
        printf("I am main thread\n");
        sleep(1);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out thread.c -lpthread
clean:
	-@rm a.out

测试结果:

I am sub pthread, thread number:0, g_seq:1669
I am sub pthread, thread number:2, g_seq:1670
I am sub pthread, thread number:1, g_seq:1671
I am sub pthread, thread number:0, g_seq:1671
I am sub pthread, thread number:2, g_seq:1672
I am sub pthread, thread number:0, g_seq:1673
I am sub pthread, thread number:1, g_seq:1673
I am sub pthread, thread number:2, g_seq:1674
I am sub pthread, thread number:0, g_seq:1675
I am sub pthread, thread number:1, g_seq:1675
I am sub pthread, thread number:2, g_seq:1676
I am sub pthread, thread number:0, g_seq:1677
I am sub pthread, thread number:1, g_seq:1677
I am sub pthread, thread number:2, g_seq:1678
I am sub pthread, thread number:1, g_seq:1679
I am sub pthread, thread number:0, g_seq:1679
I am sub pthread, thread number:2, g_seq:1680

增加锁后：
thread.c:

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

#define THREAD_NUMBER 3

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int g_seq = 0;

void *thread_func(void *arg)
{
    long thread_number = -1;

    thread_number = (long)arg;

    while (1) {
        pthread_mutex_lock(&mutex);
        g_seq++;
        printf("I am sub pthread, thread number:%ld, g_seq:%d\n", thread_number, g_seq);
        pthread_mutex_unlock(&mutex);
        usleep(1000);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    long i = 0;
    pthread_t tid[THREAD_NUMBER];

    for (i = 0; i < THREAD_NUMBER; i++) {
        ret = pthread_create(&tid[i], NULL, thread_func,  (void *)i);
    }

    while (1) {
        printf("I am main thread\n");
        sleep(1);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out thread.c -lpthread
clean:
	-@rm a.out

测试结果：

I am sub pthread, thread number:1, g_seq:814
I am sub pthread, thread number:0, g_seq:815
I am sub pthread, thread number:2, g_seq:816
I am sub pthread, thread number:2, g_seq:817
I am sub pthread, thread number:0, g_seq:818
I am sub pthread, thread number:1, g_seq:819
I am sub pthread, thread number:0, g_seq:820
I am sub pthread, thread number:2, g_seq:821
I am sub pthread, thread number:1, g_seq:822
I am sub pthread, thread number:0, g_seq:823
I am sub pthread, thread number:2, g_seq:824
I am sub pthread, thread number:1, g_seq:825

3.5 同步条件变量

thread.c:

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

#define THREAD_NUMBER 3

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int g_flag = 0;

void *producer_func(void *arg)
{
    while (1) {
        pthread_mutex_lock(&mutex);
        printf("%s: get lock, flag is:%d\n", __FUNCTION__, g_flag);
        if (1 == g_flag) {
            printf("%s: flag is 0, wait...\n", __FUNCTION__);
            pthread_cond_wait(&cond, &mutex);
            printf("%s: after wait, flag:%d\n", __FUNCTION__, g_flag);
        }
        printf("%s: sleep 10 seconds\n", __FUNCTION__);  
        sleep(10);
        g_flag = 1;
        printf("%s: sleep finish, flag:%d\n", __FUNCTION__, g_flag);
        printf("%s: send cond signal\n", __FUNCTION__);  
        pthread_cond_signal(&cond);
        printf("%s: release lock\n", __FUNCTION__);  
        pthread_mutex_unlock(&mutex);
    }
}

void *customer_func(void *arg)
{
    while (1) {
        pthread_mutex_lock(&mutex);
        printf("%s: get lock, flag is:%d\n", __FUNCTION__, g_flag);
        if (0 == g_flag) {
            printf("%s: flag is 0, wait...\n", __FUNCTION__);
            pthread_cond_wait(&cond, &mutex);
            printf("%s: after wait, flag:%d\n", __FUNCTION__, g_flag);
        }
        printf("%s: sleep 10 seconds\n", __FUNCTION__);  
        sleep(10);
        g_flag = 0;
        printf("%s: sleep finish, flag:%d\n", __FUNCTION__, g_flag);
        printf("%s: send cond signal\n", __FUNCTION__);  
        pthread_cond_signal(&cond);
        printf("%s: release lock\n", __FUNCTION__);  
        pthread_mutex_unlock(&mutex);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t producer_tid;
    pthread_t customer_tid;

    ret = pthread_create(&producer_tid, NULL, producer_func, NULL);
    ret = pthread_create(&customer_tid, NULL, customer_func, NULL);

    while (1) {
        sleep(10);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out thread.c -lpthread
clean:
	-@rm a.out

测试结果:

customer_func: get lock, flag is:0
customer_func: flag is 0, wait...
producer_func: get lock, flag is:0
producer_func: sleep 10 seconds
producer_func: sleep finish, flag:1
producer_func: send cond signal
producer_func: release lock
producer_func: get lock, flag is:1
producer_func: flag is 0, wait...
customer_func: after wait, flag:1
customer_func: sleep 10 seconds
customer_func: sleep finish, flag:0
customer_func: send cond signal
customer_func: release lock
customer_func: get lock, flag is:0
customer_func: flag is 0, wait...
producer_func: after wait, flag:0
producer_func: sleep 10 seconds
浪游东戴河
关注
  • 2
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux下c语言多线程编程
m0_47170940的博客
03-30 1万+
创建线程函数pthread_create()和等待线程函数pthread_join()的用法。 注意：在创建线程pthread_create()之前，要先定义线程标识符： pthread_t 自定义线程名； 例子1：创建线程以及等待线程执行完毕。 #include <stdio.h> #include <stdlib.h> #include <pthread.h> //线程要运行的函数，除了函数名myfunc，其他全都是固定的。 void* myfunc() { p
c语言tips-【linux-C语言多线程编程】
留下虚度光阴的一些证据。
01-13 1113
操作系统具有管理进程进程调度的能力，线程，决定哪个进程、线程使用 CPU。很多时候我们需要在同一时间干不同的任务，这就需要我们通过多进程或者多线程来进行，在我们学习和工作中我们大部分用到的都是多线程,本文主要是在linux下探索c语言的多进程的使用方法
Linux多线程编程实战
博了个客
01-06 2236
1.pthread线程操作相关函数 1.线程创建 函数声明 int pthread_create(pthread_t *newthread,const pthread_attr_t *attr,void *(start_rtn)(void),void *arg); 函数说明 Create a new thread, starting with execution of START-ROUTINE getting passed ARG. Creation attributed come from ATTR.
【Linux C | 多线程编程】线程的创建、线程ID、线程属性
最新发布
wkd_007的博客
03-22 1989
本文介绍了线程创建相关的内容，包括pthread_create函数的详细介绍和使用例子，然后依次介绍该函数第一个参数相关的线程ID知识以及第二个参数相关的线程属性知识。读完完整地了解线程的创建。
Linux下的多线程编程实例解析
09-14
【Linux下的多线程编程实例解析】 在计算机操作系统中，多线程编程是实现并行处理和提高系统效率的一种重要技术。Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多...
linux下c语言的多线程编程
08-29
Linux下C语言的多线程编程 在 Linux 系统中，C 语言的多线程编程是非常重要的一部分。多线程编程可以提高程序的性能，使得程序能够更好地利用系统资源。在本文中，我们将详细介绍 Linux 下 C 语言的多线程编程。 ...
linux c多线程编程实例代码
09-04
在Linux系统中，C语言进行多线程编程可以利用POSIX线程库（pthread），它提供了丰富的线程操作接口。本实例代码展示了如何创建、同步和管理多线程。以下是详细的知识点解析： 1. **多线程概念**：多线程是指一个...
Linux下的多线程编程.pdf
09-06
Linux系统提供了 LinuxThreads 库，它是一个符合 POSIX IO03．1c 标准的内核级多线程函数库。在 LinuxThreads 库中提供了一些多线程编程的关键函数，如 pthread_create() 函数，它可以创建一个新的线程，并执行指定...
Linux C中多线程与volatile变量
09-15
在Linux C编程中，多线程编程是一种常见的并发执行方式，允许程序同时执行多个任务，提高系统的效率。然而，多线程环境下数据同步和一致性问题成为了一大挑战。`volatile`关键字在这里起到了关键作用，它确保了在多...
Linux 的多线程编程的高效开发经验
05-17
本文中我们针对 Linux 上多线程编程的主要特性总结出 5 条经验， 用以改善 Linux 多线程编程的习惯和避免其中的开发 陷阱。
Linux线程（一）—— 多线程（概念、操作）
qq_64353867的博客
10-15 94
多线程（概念、操作）
初识多线程编程
weixin_56738054的博客
11-22 489
多线程，线程创建的方式，run方法
linux下C语言多线程编程总结
ftzchina的博客
11-29 1388
一：线程的创建与等待 线程创建函数： Create a new thread, starting with execution of START-ROUTINE getting passed ARG. Creation attributed come from ATTR. The new handle is stored in *NEWTHREAD. extern int pthread_create (pthread_t *__restrict __newthread,
Linux下多线程编程实例解析
GQ1900的博客
04-07 5308
提到线程，不得不让人想起进程，所以还是先写下进程与线程的区别吧！ 一、进程与线程的区别 进程是程序执行的一个实例，进程有其自己独立的地址空间。一个线程可以含有多个线程，这也是为了提高系统资源利用率，线程的引入有其必然的优势，线程有自己的堆栈。记得操作系统的书籍上有一句经典的话”进程——资源分配的最小单位，线程——程序执行的最小单位“。一个通俗的比喻：进程就像一个人，而线程就好像人体内协
Linux多线程实例
YUE110YUE的博客
02-01 425
Linux多线程实例 线程介绍参考1 一、线程的创建和使用 1.函数介绍 二、互斥锁的使用 三、条件变量的使用
多线程技术 编程案例
m0_56051805的博客
07-19 310
多线程技术 编程案例
linux下多线程(pthread)编程实例,Linux多线程编程实例解析
weixin_36192665的博客
05-10 310
haoLinux系统下的多线程遵循POSIX线程接口，称为 pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux 下pthread的实现是通过系统调用clone()来实现的。clone()是 Linux所特有的系统调用，它的使用方式类似fork，关于clone()的详细情况，有兴趣的读者可以去查看有关文档说...
Linux多线程编程
C_Trip的博客
11-19 3060
1、线程基本知识 2、线程控制 3、线程同步与互斥 线程互斥 线程同步 条件变量 生产者消费者模型 POSIX信号量 读者写者问题 线程池 单例模式
linux网络编程多线程收发
09-13
在Linux网络编程中，使用多线程进行收发操作可以提高网络应用程序的并发性能。下面是一个简单的示例代码，说明如何使用多线程进行收发操作。 ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <pthread.h> #include <sys/socket.h> #include <arpa/inet.h> #define MAX_CLIENTS 10 void *handle_client(void *arg) { int client_fd = *(int *)arg; char buffer[1024]; memset(buffer, 0, sizeof(buffer)); // 接收客户端数据 ssize_t recv_len = recv(client_fd, buffer, sizeof(buffer), 0); if (recv_len > 0) { printf("Received message from client: %s\n", buffer); } // 发送响应给客户端 char response[] = "Hello from server!"; ssize_t send_len = send(client_fd, response, sizeof(response), 0); if (send_len == -1) { perror("send"); } close(client_fd); pthread_exit(NULL); } int main() { int server_fd; struct sockaddr_in server_addr; struct sockaddr_in client_addr; socklen_t client_addr_len = sizeof(client_addr); pthread_t threads[MAX_CLIENTS]; // 创建套接字 server_fd = socket(AF_INET, SOCK_STREAM, 0); if (server_fd == -1) { perror("socket"); exit(1); } // 设置服务器地址 server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = INADDR_ANY; server_addr.sin_port = htons(8080); // 绑定套接字到服务器地址 if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) { perror("bind"); exit(1); } // 监听连接 if (listen(server_fd, MAX_CLIENTS) == -1) { perror("listen"); exit(1); } printf("Server started. Listening on port 8080...\n"); // 接受并处理客户端请求 int i = 0; while (1) { int client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_addr_len); if (client_fd == -1) { perror("accept"); continue; } // 创建线程处理客户端请求 if (pthread_create(&threads[i], NULL, handle_client, &client_fd) != 0) { perror("pthread_create"); continue; } // 分离线程 pthread_detach(threads[i]); i++; if (i >= MAX_CLIENTS) { break; } } close(server_fd); return 0; } ``` 在上面的示例代码中，首先创建了一个服务器套接字，然后绑定到指定的IP地址和端口号。接着，使用`listen`函数监听来自客户端的连接请求。 在主循环中，通过调用`accept`函数接受客户端连接，并且为每个客户端连接创建一个新的线程来处理收发操作。`handle_client`函数是在线程中执行的任务，负责接收客户端数据并发送响应给客户端。 需要注意的是，在多线程编程中，要确保网络资源的正确管理和共享，避免竞争条件和死锁等问题的出现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浪游东戴河

你就是这个世界的唯一

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值