此项目是根据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;				// 线程idstd::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"));