[Muduo网络库源码分析] (9) base/Thread.cc_h_CurrentThread_h线程对象

线程对象

实现：实现Thread类、ThreadData结构体 、CurrentThread命名空间

功能：实现线程对象并实现当前线程信息存储

知识点：

__thread

__thread是GCC内置的线程局部存储设施，存取效率可以和全局变量相比。__thread变量每一个线程有一份独立实体，各个线程的值互不干扰。可以用来修饰那些带有全局性且值可能变，但是又不值得用全局变量保护的变量。

__thread使用规则：只能修饰POD类型(类似整型指针的标量，不带自定义的构造、拷贝、赋值、析构的类型，二进制内容可以任意复制memset,memcpy,且内容可以复原)，不能修饰class类型，因为无法自动调用构造函数和析构函数，可以用于修饰全局变量，函数内的静态变量，不能修饰函数的局部变量或者class的普通成员变量，且__thread变量值只能初始化为编译器常量(值在编译器就可以确定const int i=5,运行期常量是运行初始化后不再改变const int i=rand()).

Pthread_atfork()函数

boost::weak_pt弱指针

prctl函数

用途：

可用于创建线程，创建多线程程序，可用于创建线程池。

模块拆分与封装：

已把其线程对象模块单独分离出来，并利用Makefile统一编译，模块代码地址如下：https://github.com/chudongfang/Learn_From_Muduo/tree/master/Thread

代码及分析：

Thread.cc

// Use of this source code is governed by a BSD-style license
// that can be found in the License file.
//
// Author: Shuo Chen (chenshuo at chenshuo dot com)

#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
{
//线程id
__thread int t_cachedTid = 0;

//线程名
__thread char t_tidString[32];
__thread int t_tidStringLength = 6;

__thread const char* t_threadName = "unknown";

//判断int和pid_t类型是否相同
const bool sameType = boost::is_same<int, pid_t>::value;
//如果类型不相同则断言false，编译出错  ？？
BOOST_STATIC_ASSERT(sameType);
}

namespace detail
{
//通过系统调用syscall获取当前线程
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);
}

// 该类用于初始化CurrentThread信息为当先主线程信息，并且在创建子线程时更新CurrentThread信息
class ThreadNameInitializer
{
public:
ThreadNameInitializer()
{
muduo::CurrentThread::t_threadName = "main";
//获取当前ID信息
CurrentThread::tid();
//子进程执行afterfork
//pthread_atfork(fork前函数，父进程执行的函数，子线程执行的函数)
pthread_atfork(NULL, NULL, &afterFork);
}
};

//初始CurrentThread信息
ThreadNameInitializer init;
//以ThreadData的数据形式向子线程传参
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)
: func_(func),
name_(name),
wkTid_(tid)
{ }

void runInThread()
{

//得到当前线程ID
pid_t tid = muduo::CurrentThread::tid();

//获取所管理的对象的强引用指针。
boost::shared_ptr<pid_t> ptid = wkTid_.lock();
//修改主进程类中pid_为当前进程ID
if (ptid)
{
*ptid = tid;
ptid.reset();
}

muduo::CurrentThread::t_threadName = name_.empty() ? "muduoThread" : name_.c_str();
//设置进程名
::prctl(PR_SET_NAME, muduo::CurrentThread::t_threadName);
try
{
//运行函数
func_();
//运行完成修改CurrentThread中线程名
muduo::CurrentThread::t_threadName = "finished";
}
catch (const Exception& ex)
{
//对于其抛出的异常类，显示erro
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);
data->runInThread();
delete data;
return NULL;
}

}
}

using namespace muduo;
//获取当前线程ID，并赋值给变量
void CurrentThread::cacheTid()
{
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__
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

//主线程函数
Thread::~Thread()//如何子线程未完成，将其与父线程分离
{
if (started_ && !joined_)
{
pthread_detach(pthreadId_);
}
}

//主线程函数
//给线程对象命名
void Thread::setDefaultName()
{
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的作用是现计算表达式 expression ，如果其值为假（即为0），那么它先向stderr打印一条出错信息，然后通过调用 abort 来终止程序运行
assert(!joined_);
joined_ = true;
return pthread_join(pthreadId_, NULL);
}

Thread.h

// Use of this source code is governed by a BSD-style license
// that can be found in the License file.
//
// Author: Shuo Chen (chenshuo at chenshuo dot com)

#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_; }//
const string& name() const { return name_; }//返回线程名

static int numCreated() { return numCreated_.get(); }//初始化numCreated

private:
void setDefaultName();//设置默认名

bool       started_;//是否开始运行
bool       joined_; //是否阻塞
pthread_t  pthreadId_;//线程ID
boost::shared_ptr<pid_t> tid_;//CurrentThread中的ID
ThreadFunc func_;//线程函数
string     name_;//线程名

static AtomicInt32 numCreated_;//初始化32位原子整数
};

}
#endif

CurrentThread.h

// Use of this source code is governed by a BSD-style license
// that can be found in the License file.
//
// Author: Shuo Chen (chenshuo at chenshuo dot com)

#ifndef MUDUO_BASE_CURRENTTHREAD_H
#define MUDUO_BASE_CURRENTTHREAD_H

#include <stdint.h>

namespace muduo
{
namespace CurrentThread
{
// internal
//记录当前线程信息
extern __thread int t_cachedTid;
extern __thread char t_tidString[32];
extern __thread int t_tidStringLength;
extern __thread const char* t_threadName;
void cacheTid();

//得到当前线程ID
inline int tid()
{
//性能优化，t_cachedTid==0 的情况很少发生。
if (__builtin_expect(t_cachedTid == 0, 0))
{
cacheTid();
}
return t_cachedTid;
}

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

inline int tidStringLength() // for logging
{
return t_tidStringLength;
}
//记录线程名字
inline const char* name()
{
return t_threadName;
}
//判断是否是主线程
bool isMainThread();

void sleepUsec(int64_t usec);
}
}

#endif