从零开始实现一个C++高性能服务器框架----线程模块

此项目是根据sylar框架实现，是从零开始重写sylar，也是对sylar丰富与完善
项目地址：https://gitee.com/lzhiqiang1999/server-framework

简介

项目介绍：实现了一个基于协程的服务器框架，支持多线程、多协程协同调度；支持以异步处理的方式提高服务器性能；封装了网络相关的模块，包括socket、http、servlet等，支持快速搭建HTTP服务器或WebSokcet服务器。
详细内容：日志模块，使用宏实现流式输出，支持同步日志与异步日志、自定义日志格式、日志级别、多日志分离等功能。线程模块，封装pthread相关方法，封装常用的锁包括（信号量，读写锁，自旋锁等）。IO协程调度模块，基于ucontext_t实现非对称协程模型，以线程池的方式实现多线程，多协程协同调度，同时依赖epoll实现了事件监听机制。定时器模块，使用最小堆管理定时器，配合IO协程调度模块可以完成基于协程的定时任务调度。hook模块，将同步的系统调用封装成异步操作（accept, recv, send等），配合IO协程调度能够极大的提升服务器性能。Http模块，封装了sokcet常用方法，支持http协议解析，客户端实现连接池发送请求，服务器端实现servlet模式处理客户端请求，支持单Reator多线程，多Reator多线程模式的服务器。

线程模块

1. 主要功能

• 封装了一些常用的锁机制（信号量、互斥锁、自旋锁、读写锁），确保线程安全
• 对pthread系列函数封装，生成Thread类

2. 功能演示

• 锁，RAII，构造时加锁，析构时解锁

Mutex mutex;
{
	Mutex::Lock lock(mutex);	// 构造，加锁
} // 析构，解锁

• 线程

void fun1(){}

Thread::ptr thr(new Thread(&fun1, "name"));

3. 模块介绍

3.1 Lock

• 一些常用的锁机制，包括信号量SemaphoreLock、互斥锁Mutex、自旋锁SpinLock、读写锁RWMutex
• RAII模式，构造时lock，析构时unlcok

 //局部锁
template<class T>
class ScopedLockImpl {
 public:
     //构造函数，自动加锁
     ScopedLockImpl(T& mutex)
         :m_mutex(mutex) {
         lock();
     }

     //析构函数，自动解锁
     ~ScopedLockImpl() {     
         unlock();
     }

     void lock() {
         if (!m_locked) {
             m_mutex.lock();
             m_locked = true;
         }
     }

     void unlock() {
         if (m_locked) {
             m_mutex.unlock();   
             m_locked = false;
         }
     }
     
 private:
     T& m_mutex;
     bool m_locked = false;
 };

3.2 Thread

• 线程模块，主要是对pthread的封装

class Thread : Noncopyable
{
public:
	typedef std::shared_ptr<Thread> ptr;

	/**
	 * @brief 构造函数
	 * @param[in] cb 线程执行函数
	 * @param[in] name 线程名称
	 */
	Thread(std::function<void()> cb, const std::string& name);
	~Thread();
	void join();				// 等待线程执行完成
	static Thread* GetThis();	// 获取当前的线程指针

	// get set 方法

private:
	static void* run(void* arg);	// 线程执行函数 	
private:	
	pid_t m_id = -1;				// 线程id
	std::string m_name;				// 线程名称
	pthread_t m_thread = 0;			// 线程
	std::function<void()> m_cb;		// 线程执行函数
	SemaphoreLock m_semaphore;		// 信号量
};

• 线程的入口函数，只支持void(void)类型的入口函数，不支持给线程传参数，但实际使用时可以结合std::bind来绑定参数，这样就相当于支持任何类型和数量的参数。

std::function<void()> m_cb;		// 线程执行函数

• 因为我们是在线程执行函数中完成一些成员变量的初始化，因此在Thread的构造函数中，应当使用信号量（V操作），保证在构造完成之前已经执行了线程执行函数（入口函数中P操作）。

// 构造函数
Thread::Thread(std::function<void()> cb, const std::string& name)
		: m_cb(cb)
		, m_name(name)
{
	if (name.empty())
	{
		m_name = "UNKNOW";
	}
	int rt = pthread_create(&m_thread, nullptr, &Thread::run, this);
	if (rt) {
		LOG_ERROR(g_logger) << "pthread_create thread fail, rt=" << rt
			<< " name=" << name;
		throw std::logic_error("pthread_create error");
	}

	//等待，直到创建出的线程开始执行，run()
	m_semaphore.wait();
}

// 线程执行函数
void* Thread::run(void* arg) {
	Thread* thread = (Thread*)arg;
	t_thread = thread;
	t_thread_name = thread->m_name;
	thread->m_id = johnsonli::getThreadId();
	pthread_setname_np(pthread_self(), thread->m_name.substr(0, 15).c_str());

	std::function<void()> cb;
	cb.swap(thread->m_cb);

	//线程初始化完成后，就唤醒 Thread()，完成构造
	thread->m_semaphore.notify();

	cb();
	return 0;
}

同时也保证了在构造完成之后线程函数一定已经处于运行状态

• 局部线程静态变量，表示当前正在执行的线程。声明为static thread_local

// thread.cpp
// 局部线程静态变量，只在当前线程有用
// 当前运行的线程
static thread_local Thread* t_thread = nullptr;

在线程执行函数run中，会完成初始化，此后在线程入口函数m_cb中就可以调用静态方法GetThis获得当前线程

// thread.h
static Thread* GetThis()

// thread.cpp
Thread* Thread::GetThis() {
	return t_thread;
}

// main.cpp
void fun1()
{
	// 线程入口函数中获取当前线程
	LOG_INFO(g_logger) << " this.name: " << Thread::GetThis()->getName();
}

Thread::ptr thr(new johnsonli::Thread(&fun1, "name"));