muduo库Thread类剖析

最新推荐文章于 2024-10-05 19:48:22 发布

FreeeLinux

最新推荐文章于 2024-10-05 19:48:22 发布

阅读量2.5k

点赞数

分类专栏： Muduo源码剖析 muduo源码剖析文章标签： muduo muduoThread Thread类

本文链接：https://blog.csdn.net/freeelinux/article/details/52916620

版权

Muduo源码剖析同时被 2 个专栏收录

31 篇文章 14 订阅

订阅专栏

muduo源码剖析

28 篇文章 49 订阅

订阅专栏

muduo库中的Thread类集合了所有线程的操作，其中还运用了线程安全的观察者模式。

运用shared_ptr和weak_ptr做到了生命周期的管理。

线程类的接口：

代码加注释如下：

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 <boost/shared_ptr.hpp>
#include <pthread.h>

namespace muduo
{

class Thread : boost::noncopyable
{
 public:
  typedef boost::function<void ()> ThreadFunc;

  explicit Thread(const ThreadFunc&, const string& name = string());
#ifdef __GXX_EXPERIMENTAL_CXX0X__
  explicit Thread(ThreadFunc&&, const string& name = string()); //右值引用，在对象返回的时候不会拷贝构造临时对象，而是和临时对象交换，提高了效率
#endif
  ~Thread();

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

  bool started() const { return started_; }
  // pthread_t pthreadId() const { return pthreadId_; }
  pid_t tid() const { return *tid_; }   //由于pthread_t的id号可能是一样的，所以需要用gettid()
  const string& name() const { return name_; }

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

 private:
  void setDefaultName();

  bool       started_;
  bool       joined_;
  pthread_t  pthreadId_;
  boost::shared_ptr<pid_t> tid_;    //用来管理生命期
  ThreadFunc func_;                        //线程回调函数
  string     name_;

  static AtomicInt32 numCreated_;   //原子操作
};

}
#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 <boost/weak_ptr.hpp>

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

namespace muduo
{
namespace CurrentThread
{
  __thread int t_cachedTid = 0;      //用来缓存的id  //__thread修饰的变量是线程局部存储的，线程不共享，线程安全，解释见下2
  __thread char t_tidString[32];     //tid的字符串表示形式   
  __thread int t_tidStringLength = 6;   
  __thread const char* t_threadName = "unknown";   //每个线程的名称
  const bool sameType = boost::is_same<int, pid_t>::value; //boost::is_same用来检测参数是否是相同的类型，相同返回true。
  BOOST_STATIC_ASSERT(sameType);   //断言相同
}

namespace detail
{

pid_t gettid()
{
  return static_cast<pid_t>(::syscall(SYS_gettid));     //系统调用获取  //解释见下1
}

void afterFork()        //fork之后打扫战场，子进程中执行
{
  muduo::CurrentThread::t_cachedTid = 0;    //当前为0   //1.先清零tid
  muduo::CurrentThread::t_threadName = "main";//为main//为什么要赋值为0和main，因为fork可能在主线程中调用，也可能在子线程中调用。fork得到一个新进程，
  CurrentThread::tid();        //2.此处再缓存tid               //新进程只有一个执行序列，只有一个线程
  // no need to call pthread_atfork(NULL, NULL, &afterFork);   //实际上服务器要么多进程，要么多线程。如果都用，甚至可能死锁，见下5
}

class ThreadNameInitializer   //线程名初始化
{
 public:
  ThreadNameInitializer()
  {
    muduo::CurrentThread::t_threadName = "main";   //由下面的init全局对象先触发构造，主线程的名称为main
    CurrentThread::tid();                    //获得tid
    pthread_atfork(NULL, NULL, &afterFork);    //如果我们调用了fork函数，调用成功后子进程会调用afterfork()
  }
};

ThreadNameInitializer init;  //全部变量类，这个对象构造先于main函数，当我们的程序引入这个库时，这个全局函数直接构造，我们程序的main()函数还没有执行。

struct ThreadData    //线程数据类，观察者模式
{
  typedef muduo::Thread::ThreadFunc ThreadFunc;   
  ThreadFunc func_;
  string name_;
  boost::weak_ptr<pid_t> wkTid_;     

  ThreadData(const ThreadFunc& func,
             const string& name,
             const boost::shared_ptr<pid_t>& tid)    //保存有Thread类的shared_ptr
    : func_(func),
      name_(name),
      wkTid_(tid)
  { }

  void runInThread()    //线程运行
  {
    pid_t tid = muduo::CurrentThread::tid();  //得到线程tid

    boost::shared_ptr<pid_t> ptid = wkTid_.lock();  //尝试将weak_ptr提升为shared_ptr，thread_safe
    if (ptid)     //如果成功
    {
      *ptid = tid;    
      ptid.reset();   //成功了之后把通过智能指针修改父类线程id，该临时shared_ptr销毁掉
    }

    muduo::CurrentThread::t_threadName = name_.empty() ? "muduoThread" : name_.c_str();
    ::prctl(PR_SET_NAME, muduo::CurrentThread::t_threadName);
    try
    {
      func_();    //运行线程运行函数
      muduo::CurrentThread::t_threadName = "finished";   //运行玩的threadname
    }
    catch (const Exception& ex)   //Exception异常
    {
      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                 //再次抛出
    }
  }
};

void* startThread(void* obj)   //线程启动
{
  ThreadData* data = static_cast<ThreadData*>(obj);  //派生类指针转化成基类指针，obj是派生类的this指针
  data->runInThread();
  delete data;
  return NULL;
}

}
}

using namespace muduo;

void CurrentThread::cacheTid()   //在这里第一次会缓存tid，并不会每次都systemcall，提高了效率
{
  if (t_cachedTid == 0)
  {
    t_cachedTid = detail::gettid();
    t_tidStringLength = snprintf(t_tidString, sizeof t_tidString, "%5d ", t_cachedTid);
  }
}

bool CurrentThread::isMainThread()  //是否是主线程
{
  return tid() == ::getpid();
}

void CurrentThread::sleepUsec(int64_t usec)    //休眠
{
  struct timespec ts = { 0, 0 };
  ts.tv_sec = static_cast<time_t>(usec / Timestamp::kMicroSecondsPerSecond);
  ts.tv_nsec = static_cast<long>(usec % Timestamp::kMicroSecondsPerSecond * 1000);
  ::nanosleep(&ts, NULL);
}

AtomicInt32 Thread::numCreated_;

Thread::Thread(const ThreadFunc& func, const string& n)
  : started_(false),
    joined_(false),
    pthreadId_(0),
    tid_(new pid_t(0)),
    func_(func),
    name_(n)
{
  setDefaultName();
}

#ifdef __GXX_EXPERIMENTAL_CXX0X__     //C++11标准
Thread::Thread(ThreadFunc&& func, const string& n)
  : started_(false),
    joined_(false),
    pthreadId_(0),
    tid_(new pid_t(0)),
    func_(std::move(func)),
    name_(n)
{
  setDefaultName();
}

#endif
//pthread_join()和pthread_detach()都是防止现成资源泄露的途径，join()会阻塞等待。
Thread::~Thread()    //这个析构函数是线程安全的。析构时确认thread没有join，才会执行析构。即线程的析构不会等待线程结束
{                                    //如果thread对象的生命周期长于线程，那么可以通过join等待线程结束。否则thread对象析构时会自动detach线程，防止资源泄露
  if (started_ && !joined_)   //如果没有join，就detach，如果用过了，就不用了。
  {
    pthread_detach(pthreadId_);
  }
}

void Thread::setDefaultName()   //相当于给没有名字的线程起个名字 "Thread %d"
{
  int num = numCreated_.incrementAndGet();  //原子操作
  if (name_.empty())
  {
    char buf[32];
    snprintf(buf, sizeof buf, "Thread%d", num);
    name_ = buf;
  }
}

void Thread::start()   //线程启动
{
  assert(!started_);
  started_ = true;
  // FIXME: move(func_)
  detail::ThreadData* data = new detail::ThreadData(func_, name_, tid_);
  if (pthread_create(&pthreadId_, NULL, &detail::startThread, data))
  {
    started_ = false;
    delete data; // or no delete?
    LOG_SYSFATAL << "Failed in pthread_create";
  }
}

int Thread::join()    //等待线程
{
  assert(started_);
  assert(!joined_);
  joined_ = true;
  return pthread_join(pthreadId_, NULL);
}

需要注意的是

1.在linux系统中，每个进程都有一个pid，类型pid_t，由getpid()取得。Linux下的POSIX线程也有一个id，类型pthread_t，由pthread_self()取得，该线程由线程库维护，其id空间是各个进程独立的（即不同线程中可能拥有相同的id)。有时我们需要知道线程的真实id，就不能使用pid和pthread id，需要使用该线程真实的id，称为tid。(不是我们平常所用的pthread_t tid; tid=pthread_create()的那个tid)。

linux系统中有一个系统调用可以实现得到线程的真实id，我们可以实现一个函数，返回该系统调用的返回值，return syscall(SYS_gettid)，但是频繁系统调用会造成性能降低，muduo库就使用了全局变量current_tid来缓存它，我们只需要调用一次，以后直接获取该缓存就可以了。

2.__thread修饰的变量是线程局部存储的，每个线程都有一份。__thread，gcc内置的线程局部存储设施。__thread只能修饰POD类型。如果类没有定义构造函数，也是POD类型。

3.boost::is_same用来判断是否是同一类型

比如typedef unsigned int u_int，就是同一类型。

4.pthread_atfork()

int pthread_atfork(void (*prepare)(void), void(*parent)(void), void(*child)(void));

调用fork时，内部创建子进程前在父进程中会调用prepare，内部创建子进程成功后，父进程会调用parent，子进程会调用child。

示例：

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

using namespace std;

void prepare()
{
    cout<<"pid = "<<static_cast<int>(getpid())<<" prepare"<<endl;
}

void parent()
{
    cout<<"pid = "<<static_cast<int>(getpid())<<" parent"<<endl;
}

void child()
{
    cout<<"pid = "<<(static_cast<int>(getpid()))<<" child"<<endl;
}

int main()
{
    cout<<"pid = "<<(static_cast<int>(getpid()))<<" enntering main"<<endl;

    pthread_atfork(prepare, parent, child);

    fork();

    cout<<"pid = "<<(static_cast<int>(getpid()))<<" exiting main"<<endl;

    return 0;
}

输出：