muduo_base库源码分析（四）

最新推荐文章于 2022-02-16 13:52:47 发布
最新推荐文章于 2022-02-16 13:52:47 发布
阅读量149 收藏
点赞数
分类专栏： 大并发服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ShenHang_/article/details/114529913
版权

在这里插入图片描述

__thread

在这里插入图片描述

线程标识符

（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，更不能使用线程的pthreadid，而只能使用该线程的真实pid，称为tid。
（3）有一个函数gettid()可以得到tid，但glibc并没有实现该函数，只能通过Linux的系统调用syscall来获取。
在这里插入图片描述

Thread类

muduo库采用基于对象的方式实现线程类：
在这里插入图片描述
在这里插入图片描述

Thread.h

#ifndef MUDUO_BASE_THREAD_H
#define MUDUO_BASE_THREAD_H

#include <muduo/base/Atomic.h>
#include <muduo/base/Types.h>

#include <boost/function.hpp>
#include <boost/noncopyable.hpp>
#include <pthread.h>

namespace muduo
{

class Thread : boost::noncopyable//基于对象的线程类的封装
{
 public:
  typedef boost::function<void ()> ThreadFunc;

  explicit Thread(const ThreadFunc&, const string& name = string());
  ~Thread();

  void start();
  int join(); // return pthread_join()

  bool started() const { return started_; }//线程是否启动
  pid_t tid() const { return tid_; }//获取当前线程的tid
  const string& name() const { return name_; }

  static int numCreated() { return numCreated_.get(); }

 private:
  static void* startThread(void* thread);//线程入口函数
  void runInThread();

  bool       started_;
  pthread_t  pthreadId_;
  pid_t      tid_;
  ThreadFunc func_;//线程中需要完成的任务
  string     name_;

  static AtomicInt32 numCreated_;
};

}
#endif

CurrentThread.h

#ifndef MUDUO_BASE_CURRENTTHREAD_H
#define MUDUO_BASE_CURRENTTHREAD_H

namespace muduo
{
namespace CurrentThread
{
  extern __thread int t_cachedTid;//extern表示该变量是一个已经定义的外部变量（定义在Thread.cc中）
  extern __thread char t_tidString[32];
  extern __thread const char* t_threadName;
  void cacheTid();

  inline int tid()
  {
    if (t_cachedTid == 0)
    {
      cacheTid();
    }
    return t_cachedTid;
  }

  inline const char* tidString() // for logging
  {
    return t_tidString;
  }

  inline const char* name()
  {
    return t_threadName;
  }

  bool isMainThread();
}
}

#endif

Thread.cc

#include <muduo/base/Thread.h>
#include <muduo/base/CurrentThread.h>
#include <muduo/base/Exception.h>
//#include <muduo/base/Logging.h>

#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>

#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <linux/unistd.h>

namespace muduo
{


namespace CurrentThread
{
  // __thread修饰的变量是线程局部存储的全局变量，每个线程都有一份
  __thread int t_cachedTid = 0;		// 设置t_cachedTid来缓存线程真实的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);
}// namespace CurrentThread


namespace detail
{
pid_t gettid()
{
  return static_cast<pid_t>(::syscall(SYS_gettid));
}

void afterFork()
{
  muduo::CurrentThread::t_cachedTid = 0;
  muduo::CurrentThread::t_threadName = "main";
  CurrentThread::tid();
  // no need to call pthread_atfork(NULL, NULL, &afterFork);
}

class ThreadNameInitializer
{
 public:
  ThreadNameInitializer()
  {
    muduo::CurrentThread::t_threadName = "main";
    CurrentThread::tid();
    pthread_atfork(NULL, NULL, &afterFork);
  }
};

ThreadNameInitializer init;//全局变量
}// namespace detail

}// namespace muduo




using namespace muduo;

void CurrentThread::cacheTid()
{
  if (t_cachedTid == 0)
  {
    t_cachedTid = detail::gettid();
    int n = snprintf(t_tidString, sizeof t_tidString, "%5d ", t_cachedTid);
    assert(n == 6); (void) n;
  }
}

bool CurrentThread::isMainThread()
{
  return tid() == ::getpid();//如果当前线程的tid和当前进程的pid相等，说明当前线程是主线程
}

AtomicInt32 Thread::numCreated_;

Thread::Thread(const ThreadFunc& func, const string& n)
  : started_(false),
    pthreadId_(0),
    tid_(0),
    func_(func),
    name_(n)
{
  numCreated_.increment();
}

Thread::~Thread()
{
}

void Thread::start()
{
  assert(!started_);
  started_ = true;
  errno = pthread_create(&pthreadId_, NULL, &startThread, this);
  if (errno != 0)
  {
    //LOG_SYSFATAL << "Failed in pthread_create";
  }
}

int Thread::join()
{
  assert(started_);
  return pthread_join(pthreadId_, NULL);
}

void* Thread::startThread(void* obj)//线程入口函数
{
  Thread* thread = static_cast<Thread*>(obj);
  thread->runInThread();
  return NULL;
}

void Thread::runInThread()
{
  tid_ = CurrentThread::tid();//首先获取当前线程的tid（重点！！！）
  muduo::CurrentThread::t_threadName = name_.c_str();
  try
  {
    func_();//线程中需要完成的任务
    muduo::CurrentThread::t_threadName = "finished";
  }
  catch (const Exception& ex)
  {
    muduo::CurrentThread::t_threadName = "crashed";
    fprintf(stderr, "exception caught in Thread %s\n", name_.c_str());
    fprintf(stderr, "reason: %s\n", ex.what());
    fprintf(stderr, "stack trace: %s\n", ex.stackTrace());
    abort();
  }
  catch (const std::exception& ex)
  {
    muduo::CurrentThread::t_threadName = "crashed";
    fprintf(stderr, "exception caught in Thread %s\n", name_.c_str());
    fprintf(stderr, "reason: %s\n", ex.what());
    abort();
  }
  catch (...)
  {
    muduo::CurrentThread::t_threadName = "crashed";
    fprintf(stderr, "unknown exception caught in Thread %s\n", name_.c_str());
    throw; // rethrow
  }
}

测试程序Thread_test.cc

#include <muduo/base/Thread.h>
#include <muduo/base/CurrentThread.h>

#include <string>
#include <boost/bind.hpp>
#include <stdio.h>

void threadFunc()
{
  printf("tid=%d\n", muduo::CurrentThread::tid());
}

void threadFunc2(int x)
{
  printf("tid=%d, x=%d\n", muduo::CurrentThread::tid(), x);
}

class Foo
{
 public:
  explicit Foo(double x)
    : x_(x)
  {
  }

  void memberFunc()
  {
    printf("tid=%d, Foo::x_=%f\n", muduo::CurrentThread::tid(), x_);
  }

  void memberFunc2(const std::string& text)
  {
    printf("tid=%d, Foo::x_=%f, text=%s\n", muduo::CurrentThread::tid(), x_, text.c_str());
  }

 private:
  double x_;
};

int main()
{
  printf("pid=%d, tid=%d\n", ::getpid(), muduo::CurrentThread::tid());

  muduo::Thread t1(threadFunc);
  t1.start();
  t1.join();

  muduo::Thread t2(boost::bind(threadFunc2, 42),
                   "thread for free function with argument");
  t2.start();
  t2.join();

  Foo foo(87.53);
  muduo::Thread t3(boost::bind(&Foo::memberFunc, &foo),
                   "thread for member function without argument");
  t3.start();
  t3.join();

  muduo::Thread t4(boost::bind(&Foo::memberFunc2, boost::ref(foo), std::string("Shuo Chen")));
  t4.start();
  t4.join();

  printf("number of created threads %d\n", muduo::Thread::numCreated());
}

在这里插入图片描述

pthread_atfork

在这里插入图片描述
在源码的muduo::detail命名空间下，用到了pthread_atfork，如下图所示：
在这里插入图片描述

可以看出，init是一个全局变量，在创建时调用其构造函数，在构造函数中调用pthread_atfork。下面分析这样写的原因：
在Linux中，在线程中调用fork的时候只复制当前线程到子进程，也就是说除了调用fork的线程外，其他线程在子进程中“蒸发”了。

fork可能是在主线程中调用，也可能在子线程中调用。fork在主线程中调用时，新进程仍然会复制该主线程，而新的线程在新的进程中仍然是主线程，此时调用afterFork没变化；fork在子线程中调用时，新进程仍然会复制该子线程，而新的线程在新的进程中此时变成了主线程，因此需要修改其线程id和名称，这就是调用全局函数afterFork的目的。

ShenHang_
关注
专栏目录
muduo_base库源码分析（九）
ShenHang_的博客
03-12 195
__thread关键字前面已经学过了。其实本质上，线程特定数据的数据结构如下： 注意，实际数据在堆空间上。 ThreadLocal.h #ifndef MUDUO_BASE_THREADLOCAL_H #define MUDUO_BASE_THREADLOCAL_H #include <boost/noncopyable.hpp> #include <pthread.h> namespace muduo { //核心点：每创建一个ThreadLocal对象，就能创建一个线程..
muduo_base库源码分析（十二）
ShenHang_的博客
03-20 178
LogFile类对象调用append函数时，里面会调用LogFile类的append_unlock函数，而append_unlock函数中又会通过LogFile类的嵌套类FILE的对象file_去调用嵌套类FILE的append函数，
muduo_base库源码分析（七）
ShenHang_的博客
03-10 116
线程池问题本质上也是生产者-消费者问题，生产者向任务队列中添加任务，线程队列中的线程从任务队列中取出任务执行。 Task函数是要执行的任务； threads_是线程队列，是一个ptr_vector，内部存放线程指针； queue_是任务队列； start函数用来启动线程池（创建固定个数的线程）； run函数用来往线程池中的任务队列添加任务； runInThread函数是线程池中的线程要执行的函数（显然每个线程要重复执行任务，所以函数中肯定有while循环）； take函数：线程池中的线程函数要去任务队.
muduo_base库源码分析（八）
ShenHang_的博客
03-11 178
Singleton.h #ifndef MUDUO_BASE_SINGLETON_H #define MUDUO_BASE_SINGLETON_H #include <boost/noncopyable.hpp> #include <pthread.h> #include <stdlib.h> // atexit namespace muduo { template<typename T> class Singleton : boost::nonco..
（13）muduo_base库源码分析：Thread类实现
喜欢打篮球的普通人
04-08 316
文章目录1.线程标识符2.Thread类图 1.线程标识符 Linux中，每个进程有一个pid，类型pid_t，由getpid()取得。Linux下的POSIX线程也有一个id，类型 pthread_t，由pthread_self()取得，该id由线程库维护，其id空间是各个进程独立的（即不同进程中的线程可能有相同的id）。 Linux中的POSIX线程库实现的线程其实也是一个进程（LWP），只...
muduo_base库源码分析（五）
ShenHang_的博客
03-09 185
MutexLock类和MutexLockGuard类 Mutex.h 很简单 #ifndef MUDUO_BASE_MUTEX_H #define MUDUO_BASE_MUTEX_H #include <muduo/base/CurrentThread.h> #include <boost/noncopyable.hpp> #include <assert.h> #include <pthread.h> namespace muduo { clas.
muduo_base库源码分析（三）
ShenHang_的博客
03-08 141
Exception.h #ifndef MUDUO_BASE_EXCEPTION_H #define MUDUO_BASE_EXCEPTION_H #include <muduo/base/Types.h> #include <exception> namespace muduo { class Exception : public std::exception { public: explicit Exception(const char* what); expl.
muduo_base库源码分析（一）
ShenHang_的博客
03-06 303
BOOST_STATIC_ASSERT #include <boost/static_assert.hpp> #include <cassert> class Timestamp { private: int64_t microSecondsSinceEpoch_; }; BOOST_STATIC_ASSERT(sizeof(Timestamp) == sizeof(int64_t));//编译时断言 //BOOST_STATIC_ASSERT(sizeof(int) == ..
muduo_base库源码分析（二）
ShenHang_的博客
03-07 171
解释一下上面几个原语： __sync_fetch_and_add(type *ptr, type value); 函数的返回值是 *ptr（旧值），同时 *ptr=*ptr+value __sync_val_compare_and_swap(type *ptr, type oldval, type newval); 如果 *ptr不等于oldval，那么直接函数返回 *ptr，结束； 如果 *ptr等于oldval，那么函数返回 *ptr（旧值），同时 *ptr=newval __sync_loc...
muduo_net库源码分析（25)
Riak, Spark, Golang, Erlang, 云存储, 云计算, 数据挖掘
11-07 2351
TCP网络编程本质     TCP网络编程最本质是的处理三个半事件         连接建立：服务器accept（被动）接受连接，客户端connect（主动）发起连接         连接断开：主动断开（close、shutdown），被动断开（read返回0）         消息到达：文件描述符可读         消息发送完毕：这算半个。对于低流量的服务，可不必关心这个事件;这里的
muduo库base源码分析四 (线程封装)
侯彩桦
02-14 358
线程标识符：我们知道Linux每一个进程都有一个pid，类型pid_t ，由getpid() 来获得。Linux下的POSIX 线程也有一个id，类型pthread_id ，由pthread_self() 取得，该id 是线程库维护，其id 空间是各个进程独立的（即不同进程中的线程可能有相同的id）。Linux中的POSIX线程库实现的线程其实也是一个进程（LWP），只是该线程与主进程（启动线程的进程）共享一些资源而已，比如代码段、数据段等。 有时候我们可能需要知道线程的真实pid。比如进程P1要向另外一
muduo库base源码分析二 (原子性操作AtomicIntegerT类封装)
侯彩桦
02-13 230
为什么需要原子性操作？ 我们考虑这样一种场景，两个线程对同一个变量同时x++操作。 x++ 在计算机的步骤：从内存中读取x的值到寄存器中，对寄存器加1，再把新值写回x所处的内存地址。 假设有如下时序图： ​ 两个线程运行结束后，x等于11，正确应该是12，那要得出正确的结果，有两个方法： 第一种是锁：在X++ 之前加一把锁，加完解锁。这样就可以保证在同一时刻只有一个线程进入临界区域，对X进行读的操作，写的操作，当一个线程进入这个临界区域的时候，其他线程就不能访问这个临界区的资源，只能等到占用的线
muduo库base源码分析十一 (日志类封装)
侯彩桦
02-16 413
日志的作用 开发过程中： 1、有助于调试错误。 实际上C/C++程序员很少使用GDB调试错误，更多的是使用日志调试错误，程序错误，分为编译时错误和运行错误。对于编译时错误编译器可以帮我们发现错误，对于运行时错误比如调用某个库函数或者系统调用出现的错误，我们可以把errno 所对应的错误信息记录到日志当中，这样我们就可以分析日志找出错误所在。如果是运行时的逻辑错误，用GDB调试的话就像大海捞针很难定位错误的位置，特别是代码量多的时候调试更加麻烦。 如果我们把整个程序运行状态都记录到了日志当中，那么通过分
Muduo 网络库源码分析 之 关键技术点总结
NK_test的博客
04-28 3063
最近又把muduo网络库仔细研究了一遍，收获良多。本文将对muduo中的设计思想以及关键的技术细节进行总结和分析，当然由于篇幅的原因这里更多的是对关键技术的简略提及，具体细节还需要读者自己去查找学习资料。muduo/base Date类 日期类的封装，使用Julian（儒略日）可以方便的计算日期差。具体公式和思想见 儒略日的计算 Exception类 异常类的封装，对外提供what()输出错误信
fflush()函数
热门推荐
ShenHang_的博客
03-18 3万+
fflush()函数：更新缓存区。 头文件：#include<stdio.h> 函数定义：int fflush(FILE *stream); 函数说明：调用fflush()会将缓冲区中的内容写到stream所指的文件中去.若stream为NULL，则会将所有打开的文件进行数据更新。 fflush(stdin)：刷新缓冲区,将缓冲区内的数据清空并丢弃。 fflush(stdout)：刷新缓冲区,将缓冲区内的数据输出到设备。 看如下代码： #inlcude<stdio.h> int ma
std::bind
ShenHang_的博客
08-16 823
其实std::bind和boost::bind几乎完全一样。 普通函数使用std::bind #include <iostream> #include <functional> double callableFunc (double x, double y,double z) {return x+y-z;} int main() { std::function<double(double)> NewCallable1 = std::bind (callableF
muduo_net库源码分析（九）（TcpServer类、TcpConnection类）
ShenHang_的博客
05-02 745
Acceptor类的对象是TcpServer类的成员！Acceptor类与TcpServer类是组合关系。 Acceptor::handleRead–>在Acceptor::handleRead中，除了调用::accept外，还调用了应用层回调函数 newConnectionCallback_（这里通过Acceptor::setNewConnectionCallback将应用层回调函数newConnectionCallback_设置为TcpServer::newConnection） ...
linux pthread_atfork函数（解决在多线程程序中fork可能造成的死锁问题）
ShenHang_的博客
03-09 542
首先来看一个问题，在linux系统中，我们都知道fork会产生一个调用进程的复制，创建出一个新的进程，那么如果父进程有多个线程会不会复制父进程的多个线程呢？ 答案：子进程创建出来时只有一个线程，就是调用fork()函数的那个线程。也就是说，父进程在复制子进程的时候，只会复制当前线程的执行状态，其它线程不会复制。（https://www.cnblogs.com/wenxuanh/p/12573966.html） 在linux下，经常会调用fork来产生一个子进程，如果出现既要考虑多线程，又要考虑多进程的情况，
Muduo网络库：多线程设计与实战示例
Muduo网络库是由陈硕开发的一款专门为Linux系统设计的高性能、轻量级的网络库，专注于TCP协议，特别是为多核多线程环境优化。它的设计理念是专为特定应用场景提供，如局域网内的应用，强调线程安全和非阻塞I/O模型，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值