muduo网络库学习之Exception类、Thread 类封装中的知识点(重点讲pthread_atfork())

一、Exception类封装

class Exception : public std::exception

 #include <execinfo.h>  int backtrace(void **buffer, int size); // backtrace 栈回溯,保存各个栈帧的地址  char **backtrace_symbols(void *const *buffer, int size); // backtrace_symbols 根据地址,转成相应的函数符号

// buffer 是指向一个数组的指针,数组存放的每一项是指向字符串的指针

// backtrace_symbols 内部调用malloc 分配数组空间,需要调用者自己释放,但数组指针指向的字符串不需要调用者去释放。

二、Thread类封装

class Thread : boost::noncopyable

typedef boost::function<void ()> ThreadFunc;

具体实现分析见这里。注意:结合CurrentThead.h 一起看,因为CurrentThead命名空间内的一些函数是在

Thead.cc 里面实现的,Thead类的一些成员函数也调用了CurrentThread命名空间的一些函数。

1、获取标识符

pid --> getpid() //进程id

pthread_t --> pthread_self() //线程id tid--> gettid() //线程真实id

(1)、Linux中,每个进程有一个pid,类型pid_t,由getpid()取得。Linux下的POSIX线程也有一个id,类型 pthread_t,由pthread_self()取得,该id由线程库维护,其id空间是各个进程独立的(即不同进程中的线程可能有相同的id)。Linux中的POSIX线程库实现的线程其实也是一个进程(LWP),只是该进程与主进程(启动线程的进程)共享一些资源而已,比如代码段,数据段等。

(2)、有时候我们可能需要知道线程的真实pid。比如进程P1要向另外一个进程P2中的某个线程发送信号时,既不能使用P2的pid,更不能使用线程的pthread id,而只能使用该线程的真实pid,称为tid。

(3)、有一个函数gettid()可以得到tid,但glibc并没有实现该函数,只能通过Linux的系统调用syscall来获取。 return syscall(SYS_gettid)

2、__thread,gcc内置的线程局部存储设施(每个线程有一份)

__thread只能修饰POD类型 POD类型(plain old data),与C兼容的原始数据,例如,结构体和整型等C语言中的类型是 POD 类型,但带有用户定义的构造函数或虚函数的类则不是

__thread string   t_obj1(“simba”);     // 错误,不能调用对象的构造函数 __thread string* t_obj2 = new string;     // 错误,初始化只能是编译期常量 __thread string* t_obj3 = NULL;     // 正确 若不是POD数据类型,但也想作为线程局部存储,可以使用线程特定数据TSD,参见以前的文章

namespace CurrentThread {

  __thread int t_cachedTid = 0; //线程真实pid(tid)的缓存,是减少系统调用::syscall(SYS_gettid),提高获取tid的效率。   __thread char t_tidString[32]; // tid 的字符串表示   __thread const char* t_threadName = "unknown"; //线程名称   const bool sameType = boost::is_same<int, pid_t>::value;     //判断类型是否相同   BOOST_STATIC_ASSERT(sameType);

}

3、boost::is_same

const bool sameType = boost::is_same<int, pid_t>::value;

4、assert(n == 6); (void) n;

在release 版本下assert语句被忽略,那么n是未使用的变量,由于编译选项会把警告当作错误,导致编译不通过。

5、pthread_atfork()

#include <pthread.h> int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));

pthread_atfork()在fork()之前调用,当调用fork时,内部创建子进程前在父进程中会调用prepare,内部创建子进程成功后,父进程会调用parent ,子进程会调用child。

#include <stdio.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>

void prepare(void)
{
    printf("pid = %d prepare ...\n", static_cast<int>(getpid()));
}

void parent(void)
{
    printf("pid = %d parent ...\n", static_cast<int>(getpid()));
}

void child(void)
{
    printf("pid = %d child ...\n", static_cast<int>(getpid()));
}


int main(void)
{
    printf("pid = %d Entering main ...\n", static_cast<int>(getpid()));

    pthread_atfork(prepare, parent, child);

    fork();

    printf("pid = %d Exiting main ...\n", static_cast<int>(getpid()));

    return 0;
}

执行结果如下:

simba@ubuntu:~/Documents/build/debug/bin$ ./pthread_atfork_test  pid = 4791 Entering main ... pid = 4791 prepare ... pid = 4791 parent ... pid = 4791 Exiting main ... simba@ubuntu:~/Documents/build/debug/bin$ pid = 4792 child ... pid = 4792 Exiting main ... simba@ubuntu:~/Documents/build/debug/bin$ 

因为父进程首先退出,故bash提到前台,子进程输出混杂在命令行。

在实际编程中,最好不要多线程多进程,两者择其一,比如在多线程程序中调用fork 容易出现死锁,因为子进程复制父进程的时候包含状态变化,如锁的状态如果被复制的时候是已经加锁,那么子进程想加锁的时候就会死锁,因为不是本进程程序加的锁,解锁就不从谈起,一直处于等待中。看下面的例子:

#include <stdio.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>


pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *doit(void *arg)
{
    printf("pid = %d begin doit ...\n", static_cast<int>(getpid()));
    pthread_mutex_lock(&mutex);
    struct timespec ts = {2, 0};
    nanosleep(&ts, NULL);
    pthread_mutex_unlock(&mutex);
    printf("pid = %d end doit ...\n", static_cast<int>(getpid()));

    return NULL;
}

int main(void)
{
    printf("pid = %d Entering main ...\n", static_cast<int>(getpid()));
    pthread_t tid;
    pthread_create(&tid, NULL, doit, NULL);
    struct timespec ts = {1, 0};
    nanosleep(&ts, NULL);
    if (fork() == 0)
    {
        doit(NULL);
    }
    pthread_join(tid, NULL);
    printf("pid = %d Exiting main ...\n", static_cast<int>(getpid()));

    return 0;
}

首先主线程先调用pthread_create()创建一个子线程执行doit(),doit()里面先加锁,睡眠2s; 主线程睡眠1s后调用fork(),子进程会复制父进程的内存映像,此时全局变量mutex 处于加锁的状态,所以子进程自己的mutex也是加锁的,此时子进程是独立运行的,也去执行doit(),在里面试图加锁,因为本来mutex已经加锁,而且根本没有人会来解锁,所以子进程就会死锁。

执行结果如下:

simba@ubuntu:~/Documents/build/debug/bin$ ./deadlock_test pid = 4823 Entering main ... pid = 4823 begin doit ... pid = 4825 begin doit ... pid = 4823 end doit ... pid = 4823 Exiting main ... simba@ubuntu:~/Documents/build/debug/bin$ ps aux | grep deadlock_test simba     4825  0.0  0.0  11684   144 pts/0    S    06:09   0:00 ./deadlock_test simba     4830  0.0  0.0   4392   848 pts/0    S+   06:09   0:00 grep --color=auto deadlock_test simba@ubuntu:~/Documents/build/debug/bin$ 

可以看到Exiting main 只输出了一次,子进程根本没有从doit()出来,ps 一下可以发现pid=4825 的进程一直没有退出,注意死锁跟僵尸进程是不同的,僵尸进程是退出但占据着资源还没被清理,而死锁是一直没有退出进程。

此时可以用pthread_atfork() 来解决这个问题:

#include <stdio.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>


pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *doit(void *arg)
{
    printf("pid = %d begin doit ...\n", static_cast<int>(getpid()));
    pthread_mutex_lock(&mutex);
    struct timespec ts = {2, 0};
    nanosleep(&ts, NULL);
    pthread_mutex_unlock(&mutex);
    printf("pid = %d end doit ...\n", static_cast<int>(getpid()));

    return NULL;
}

void prepare(void)
{
    pthread_mutex_unlock(&mutex);
}

void parent(void)
{
    pthread_mutex_lock(&mutex);
}

int main(void)
{
    pthread_atfork(prepare, parent, NULL);
    printf("pid = %d Entering main ...\n", static_cast<int>(getpid()));
    pthread_t tid;
    pthread_create(&tid, NULL, doit, NULL);
    struct timespec ts = {1, 0};
    nanosleep(&ts, NULL);
    if (fork() == 0)
    {
        doit(NULL);
    }
    pthread_join(tid, NULL);
    printf("pid = %d Exiting main ...\n", static_cast<int>(getpid()));

    return 0;
}

同样的流程,但在执行fork() 创建子进程之前,先执行prepare(), 将子线程加锁的mutex 解锁下,然后为了与doit() 配对,在创建子进程成功后,父进程调用parent() 再次加锁,这时父进程的doit() 就可以接着解锁执行下去。而对于子进程来说,由于在fork() 创建子进程之前,mutex已经被解锁,故复制的状态也是解锁的,所以执行doit()就不会死锁了。

执行结果如下:

simba@ubuntu:~/Documents/build/debug/bin$ ./deadlock_test2 pid = 4905 Entering main ... pid = 4905 begin doit ... pid = 4908 begin doit ... pid = 4905 end doit ... pid = 4905 Exiting main ... simba@ubuntu:~/Documents/build/debug/bin$ pid = 4908 end doit ... pid = 4908 Exiting main ... simba@ubuntu:~/Documents/build/debug/bin$ 

可以看到子进程也正常退出了。

参考:

muduo manual.pdf

《linux 多线程服务器编程:使用muduo c++网络库》

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏猿人谷

unix共享内存要点

共享内存优点:     1.在进程之间不通过内核传递数据,即不通过系统调用拷贝数据,达到快速,高效的数据传输。     2.随内核持续     *nix的共享内...

1725
来自专栏码云1024

MFC多线程

3106
来自专栏温安适的blog

手写jvm中的各种OOM

3249
来自专栏猿人谷

unix共享内存要点

共享内存优点:     1.在进程之间不通过内核传递数据,即不通过系统调用拷贝数据,达到快速,高效的数据传输。     2.随内核持续     *nix的共享内...

16610
来自专栏微服务生态

NIO DirectByteBuffer 内存泄露的测试

      写NIO程序经常使用ByteBuffer来读取或者写入数据,那么使用ByteBuffer.allocate(capability)还是使用ByteB...

703
来自专栏MasiMaro 的技术博文

windows 线程

在windows中进程只是一个容器,用于装载系统资源,它并不执行代码,它是系统资源分配的最小单元,而在进程中执行代码的是线程,线程是轻量级的进程,是代码执行的最...

432
来自专栏JAVA烂猪皮

Java 内存泄漏分析和对内存设置

为了判断 Java 中是否有内存泄漏,我们首先必须了解 Java 是如何管理内存的。下面我们先给出一个简单的内存泄漏的例子,在这个例子中我们循环申请 Objec...

722
来自专栏JetpropelledSnake

Python Web学习笔记之多线程编程

本次给大家介绍Python的多线程编程,标题如下: Python多线程简介 Python多线程之threading模块 Python多线程之Lock线程锁 Py...

2868
来自专栏Linux驱动

8.中断按键驱动程序之poll机制(详解)

本节继续在上一节中断按键程序里改进,添加poll机制. 那么我们为什么还需要poll机制呢。之前的测试程序是这样: while (1) { read(fd, &...

1736
来自专栏xingoo, 一个梦想做发明家的程序员

程序猿的日常——JVM内存模型与垃圾回收

Java开发有个很基础的问题,虽然我们平时接触的不多,但是了解它却成为Java开发的必备基础——这就是JVM。在C++中我们需要手动申请内存然后释放内存,否则...

1639

扫码关注云+社区