pthread 系列函数 和 简单多线程服务器端程序

最新推荐文章于 2022-11-16 19:03:18 发布
最新推荐文章于 2022-11-16 19:03:18 发布
阅读量730 收藏
点赞数
分类专栏： C/C++ 网络 Linux
Linux 同时被 3 个专栏收录
420 篇文章 3 订阅
订阅专栏
C/C++
265 篇文章 0 订阅
订阅专栏
网络
184 篇文章 2 订阅
订阅专栏

http://blog.csdn.net/jnu_simba/article/details/9106513

一、posix 线程概述

我们知道，进程在各自独立的地址空间中运行，进程之间共享数据需要用进程间通信机制，有些情况需要在一个进程中同时执行多个控制流程，这时候线程就派上了用场，比如实现一个图形界面的下载软件，一方面需要和用户交互，等待和处理用户的鼠标键盘事件，另一方面又需要同时下载多个文件，等待和处理从多个网络主机发来的数据，这些任务都需要一个“等待-处理”的循环，可以用多线程实现，一个线程专门负责与用户交互，另外几个线程每个线程负责和一个网络主机通信。


以前我们讲过，main函数和信号处理函数是同一个进程地址空间中的多个控制流程，多线程也是如此，但是比信号处理函数更加灵活，信号处理函数的控制流程只是在信号递达时产生，在处理完信号之后就结束，而多线程的控制流程可以长期并存，操作系统会在各线程之间调度和切换，就像在多个进程之间调度和切换一样。由于同一进程的多个线程共享同一地址空间，因此TextSegment、Data Segment都是共享的，如果定义一个函数，在各线程中都可以调用，如果定义一个全局变量，在各线程中都可以访问到，除此之外，各线程还共享以下进程资源和环境：


文件描述符表

每种信号的处理方式（SIG_IGN、SIG_DFL或者自定义的信号处理函数）

当前工作目录

用户id和组id


但有些资源是每个线程各有一份的：

线程id

上下文，包括各种寄存器的值、程序计数器和栈指针

栈空间

errno变量

信号屏蔽字

调度优先级

内核堆栈


我们将要学习的线程库函数是由POSIX标准定义的，称为POSIX thread或者pthread。在Linux上线程函数位于libpthread共享库中，因此在编译时要加上-lpthread选项。


线程有3种模型，分别是N:1用户线程模型，1:1核心线程模型和N:M混合线程模型，posix thread属于N:M模型。

N:M混合线程模型提供了两级控制，将用户线程映射为系统的可调度体以实现并行，这个可调度体称为轻量级进程（LWP:lightweightprocess），LWP

再一一映射到核心线程。如下图所示。OS内核将每一个核心线程都调到系统CPU上，因此，所有线程都工作在“系统竞争范围”。




二、pthread 系列函数

（一）

功能：创建一个新的线程
原型 int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);
参数
thread:返回线程ID
attr:设置线程的属性，attr为NULL表示使用默认属性
start_routine:是个函数地址，线程启动后要执行的函数
arg:传给线程启动函数的参数
返回值：成功返回0；失败返回错误码


错误检查：

以前学过的系统函数都是成功返回0，失败返回-1，而错误号保存在全局变量errno中，而pthread库的函数都是通过返回值返回错误号，虽然每个线程也都有一个errno，但这是为了兼容其它函数接口而提供的，pthread库本身并不使用它，通过返回值返回错误码更加清晰。由于pthread_create的错误码不保存在errno中，因此不能直接用perror(3)打印错误信息，可以先用strerror(3)把错误码转换成错误信息再打印。


（二）

功能：线程终止
原型 void pthread_exit(void *value_ptr);
参数
value_ptr：value_ptr不要指向一个局部变量，因为当其它线程得到这个返回指针时线程函数已经退出了。
返回值：无返回值，跟进程一样，线程结束的时候无法返回到它的调用者（自身）


如果需要只终止某个线程而不终止整个进程，可以有三种方法：

1、从线程函数return。这种方法对主线程不适用，从main函数return相当于调用exit，而如果任意一个线程调用了exit或_exit，则整个进程的所有线程都终止。

2、一个线程可以调用pthread_cancel 终止同一进程中的另一个线程。

3、线程可以调用pthread_exit终止自己。


（三）

功能：等待线程结束
原型 int pthread_join(pthread_t thread, void **value_ptr);
参数
thread:线程ID
value_ptr:它指向一个指针，后者指向线程的返回值
返回值：成功返回0；失败返回错误码


当pthread_create 中的 start_routine返回时，这个线程就退出了，其它线程可以调用pthread_join得到start_routine的返回值，类似于父进程调用wait(2)得到子进程的退出状态。

调用该函数的线程将挂起等待，直到id为thread的线程终止。thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的，总结如下：

1、如果thread线程通过return返回，value_ptr所指向的单元里存放的是thread线程函数的返回值。

2、如果thread线程被别的线程调用pthread_cancel异常终止掉，value_ptr所指向的单元里存放的是常数PTHREAD_CANCELED。

3、如果thread线程是自己调用pthread_exit终止的，value_ptr所指向的单元存放的是传给pthread_exit的参数。

如果对thread线程的终止状态不感兴趣，可以传NULL给value_ptr参数。


（四）

功能：返回线程ID
原型 pthread_t pthread_self(void);
返回值：成功返回线程id

在Linux上，pthread_t类型是一个地址值，属于同一进程的多个线程调用getpid(2)可以得到相同的进程号，而调用pthread_self(3)得到的线程号各不相同。线程id只在当前进程中保证是唯一的，在不同的系统中pthread_t这个类型有不同的实现，它可能是一个整数值，也可能是一个结构体，也可能是一个地址，所以不能简单地当成整数用printf打印。


（五）

功能：取消一个执行中的线程
原型 int pthread_cancel(pthread_t thread);
参数
thread:线程ID
返回值：成功返回0；失败返回错误码

一个新创建的线程默认取消状态（cancelability state）是可取消的，取消类型（ cancelability type）是同步的，即在某个可取消点（ cancellation point，即在执行某些函数的时候）才会取消线程。具体可以man 一下。

相关函数 int pthread_setcancelstate(int state, int *oldstate);  int pthread_setcanceltype(int type, int *oldtype);


（六）

功能：将一个线程分离
原型 int pthread_detach(pthread_t thread);
参数
thread:线程ID
返回值：成功返回0；失败返回错误码

一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止（僵线程）。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL。对一个尚未detach的线程调用pthread_join或pthread_detach都可以把该线程置为detach状态，也就是说，不能对同一线程调用两次pthread_join，或者如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。


下面写个程序走一下这些函数：

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

#include<stdio.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<sys/types.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
#include<string.h>

#define ERR_EXIT(m) \
     do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    }  while( 0)

void *routine( void *arg)
{
     int i;
     for (i =  0; i <  20; i++)
    {
        printf( "B");
        fflush(stdout);
        usleep( 20);
         /*
            if (i == 3)
                pthread_exit("ABC");
            */
    }
     return  "DEF";
}

int main( void)
{
    pthread_t tid;
     int ret;
     if ((ret = pthread_create(&tid,  NULL, routine,  NULL)) !=  0)
    {
        fprintf(stderr,  "pthread create: %s\n", strerror(ret));
        exit(EXIT_FAILURE);
    }

     int i;
     for (i =  0; i <  20; i++)
    {
        printf( "A");
        fflush(stdout);
        usleep( 20);
    }

     void *value;
     if ((ret = pthread_join(tid, &value)) !=  0)
    {
        fprintf(stderr,  "pthread create: %s\n", strerror(ret));
        exit(EXIT_FAILURE);
    }

    printf( "\n");

    printf( "return msg=%s\n", ( char *)value);
     return  0;
}

创建一个线程，主线程打印A，新线程打印B，主线程调用pthread_join 等待新线程退出，打印退出值。

simba@ubuntu:~/Documents/code/linux_programming/UNP/pthread$ ./pthread_create 
ABAABABABABABABABABABABABABAABABBABABABB
return msg=DEF

在新线程中也可调用pthread_exit 退出。


三、简单的多线程服务器端程序

在将socket 编程的时候曾经使用fork 多进程的方式来实现并发，现在尝试使用多线程方式来实现：

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) \
         do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        }  while( 0)

void echo_srv( int conn)
{
     char recvbuf[ 1024];
     while ( 1)
    {
        memset(recvbuf,  0,  sizeof(recvbuf));
         int ret = read(conn, recvbuf,  sizeof(recvbuf));
         if (ret ==  0)
        {
            printf( "client close\n");
             break;
        }
         else  if (ret == - 1)
            ERR_EXIT( "read");
        fputs(recvbuf, stdout);
        write(conn, recvbuf, ret);
    }
}

void *thread_routine( void *arg)
{
     /* 主线程没有调用pthread_join等待线程退出 */
    pthread_detach(pthread_self());  //剥离线程，避免产生僵线程
     /*int conn = (int)arg;*/
     int conn = *(( int *)arg);
    free(arg);
    echo_srv(conn);
    printf( "exiting thread ...\n");
     return  NULL;
}

int main( void)
{
     int listenfd;
     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) <  0)
        ERR_EXIT( "socket");

     struct sockaddr_in servaddr;
    memset(&servaddr,  0,  sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons( 5188);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

     int on =  1;
     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on,  sizeof(on)) <  0)
        ERR_EXIT( "setsockopt");

     if (bind(listenfd, ( struct sockaddr *)&servaddr,  sizeof(servaddr)) <  0)
        ERR_EXIT( "bind");
     if (listen(listenfd, SOMAXCONN) <  0)
        ERR_EXIT( "listen");

     struct sockaddr_in peeraddr;
    socklen_t peerlen =  sizeof(peeraddr);
     int conn;

     while ( 1)
    {
         if ((conn = accept(listenfd, ( struct sockaddr *)&peeraddr, &peerlen)) <  0)
            ERR_EXIT( "accept");

        printf( "ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));

        pthread_t tid;
         //      int ret;
         /*pthread_create(&tid, NULL, thread_routine, (void*)&conn);*/  // race condition问题，竟态问题
         int *p = malloc( sizeof( int));
        *p = conn;
        pthread_create(&tid,  NULL, thread_routine, p);
         /*
                if ((ret = pthread_create(&tid, NULL, thread_routine, (void*)conn)) != 0) //64位系统时指针不是4个字节，不可移植
                {
                    fprintf(stderr, "pthread_create:%s\n", strerror(ret));
                    exit(EXIT_FAILURE);
                }
        */
    }

程序逻辑并不复杂，一旦accept 返回一个已连接套接字，就创建一个新线程对其服务，在每个新线程thread_routine 中调用pthread_detach 剥离线程，我们的主线程不能调用pthread_join 等待这些新线程的退出，因为还要返回while 循环开头去在accept 中阻塞监听。

如果使用pthread_create(&tid, NULL, thread_routine, (void*)&conn); 存在的问题是如果accept 再次返回一个已连接套接字，而此时thread_routine 函数还没取走conn 时，可能会读取到已经被更改的conn 值。

如果使用  pthread_create(&tid, NULL, thread_routine, (void*)conn); 存在的问题是在64位系统中指针不是4个字节而是8个字节，即不可移植 性。

使用上述未被注释的做法，每次返回一个conn，就malloc 一块内存存放起来，在thread_routine 函数中去读取即可。

开多个客户端，可以看到正常服务。


参考：

《linux c 编程一站式学习》

《UNP》

《APUE》

 

雷电羊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pthread 常用函数
moremore的学习记录
08-10 1158
int pthread_create(               pthread_t *tid,               const pthread_attr_t *attr,               void*(*start_routine)(void*),               void *arg               );//参数tid 用于返回新创建线程的线程号；//
多线程函数系列pthread_create(), pthread_join(), pthread_self()，pthread_exit(), pthread_detach()实例详解
Be The Best！
12-16 6248
多线程函数系列pthread_create(), pthread_join(), pthread_self()，pthread_exit(), pthread_detach()实例详解
pthread用法（简单的Pthread程序）
03-31
简单的pthread程序 用pthread 来 计算几个数的和，了解与理解，thread，与process之间的关系。
pthread系列函数实例学习（一）
IT人生
08-08 1262
源码： robin@ubuntu:~/workspace/c_workspace/pthread$ cat thread.c /************************************************* * pthread_create() pthread_join() 实例 * * *************************************
posix 线程和pthread 系列函数
Chenk的专栏
09-27 2141
一、posix 线程概述 进程在各自独立的地址空间中运行，进程之间共享数据需要用进程间通信机制，有些情况需要在一个进程中同时执行多个控制流程，这时候线程就派上了用场，比如实现一个图形界面的下载软件，一方面需要和用户交互，等待和处理用户的鼠标键盘事件，另一方面又需要同时下载多个文件，等待和处理从多个网络主机发来的数据，这些任务都需要一个“等待-处理”的循环，可以用多线程实现，一个线程专门负责与用户
linux下多线程网络编程TCP服务器端数据传输代码
01-14
在Linux环境下进行多线程网络编程，TCP服务器端的数据传输是一项关键任务，它涉及到网络通信、并发处理和系统调用等多个领域。以下是对这个主题的详细解析： 首先，TCP（Transmission Control Protocol）是一种面向...
多线程服务器端的实现1 —— 线程概念1
08-08
以下是一个简单的多线程工作模型示例，其中包含了一个计算和累加数组元素的线程函数`thread_summation`。这个例子展示了如何创建和等待线程，但要注意，由于全局变量`sum`未进行同步保护，这个代码在实际环境中可能...
学习网络编程5-多线程服务器.ppt
11-12
多线程服务器模型是指在服务器端使用多个线程来处理客户端的请求，从而提高服务器的处理能力和响应速度。该模型可以解决单线程服务器模型的缺陷，即单线程服务器模型只能处理一个客户端的请求，导致其他客户端的请求...
多线程服务器端的实现21
08-08
总结来说，多线程服务器端的实现中，线程同步是确保程序正确性和高效运行的关键。互斥量和信号量是实现线程同步的重要工具，它们通过控制对共享资源的访问，避免了竞态条件和死锁等问题。在实际编程中，我们需要根据...
多线程 服务器端-客户端 c
10-26
总结来说，多线程服务器端-客户端C编程涉及到网络编程基础，如套接字、连接处理、I/O多路复用，以及多线程编程，包括线程创建、同步与通信。通过这些技术，我们可以构建高效、可扩展的网络应用。
Linux下基于pthread的简单的多线程程序
06-02
Linux下使用pthread库编写的简单的多线程程序，在调用线程时绑定了内核
linux多线程pthread系列函数详解
weixin_30475039的博客
02-14 141
linux多线程pthread系列函数详解 linux多线程pthread系列函数详解 （一）为什么要引入线程 线程技术早在60年代就被提出，但是在80年代才真正使用到操作系统中。传统UNIX也支持多线程概念，但在一个进程中只允许有一个线程，这样多线程就意味着多进程。现在多线程技术已经被很多操作系统支持，包含Windows/NT，当然也包含...
pthread相关函数
fish的专栏
01-07 1641
pthread_create http://man7.org/linux/man-pages/man3/pthread_create.3.html pthread_exit http://man7.org/linux/man-pages/man3/pthread_exit.3.html pthread_join http://man7.org/linux/man-pages/man3/p...
pthread库实现一个简单的任务池
weixin_30666943的博客
02-28 196
pthread库实现一个简单的任务池 类关系图： 说明： 1：TaskManager类管理Task类，Task类是一个纯虚类; 2：ThreadManager类管理Thread类，Thread类封装pthread库的相关线程函数; 3：Thread类通过TaskManager类获取需要执行的任务; 4：Thre...
【服务器编程】Linux多线程编程（pthread）
on_my_wayshake的博客
05-30 358
本文讨论的线程相关的内容都属于POSIX线程（简称pthread）标准，线程库是NPTL(Native POSIX Thread Library)，以下的具体包括： 创建线程和结束线程 读取和设置线程属性 POSIX线程同步方式：POSIX信号量、互斥锁和条件变量 Linux线程概述 线程模型 线程是程序中完成一个独立任务的完整执行序列，即一个可调度的实体。根据运行环境和调度者的身份，线程可分为内核线程和用户线程。内核线程，有的系统上称为“轻量级线程”，运行在内核空间，由内核来调度；用户线程运行在用户空
Linux Pthread函数列表
Linux学习
06-13 1351
简介  POSIX thread 简称为pthread，Posix线程是一个POSIX标准线程.该标准定义内部API创建和操纵线程.  作用  线程库实行了POSIX线程标准通常称为pthreads.pthreads是最常用的POSIX系统如Linux和Unix,而微软Windowsimplementations同时存在.举例来说,pthreads-w32可支持MIDP的pthread    
网络服务器【二】多线程httpserver(pthread)
最新发布
总结和收藏
11-16 334
【代码】多线程httpserver(pthread)
pthread 线程基本函数
chenwh_cn的博客
05-24 2485
文章目录一、`int pthread_create(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);`二、`int pthread_join(pthread_t tid, void **thread_return);`三、`int pthread_detach(pthread_t tid);`四、`void pthread_exit(void *retval);`五、`int pthrea
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值