【Linux】多线程

目录

线程

线程和进程的关系

虚拟地址与物理地址的映射（三级映射）

​编辑

线程的使用

线程安全

 临界资源和临界区

互斥锁

同步与互斥

 互斥锁的使用

锁的初始化

加锁与解锁

信号量

信号与信号量的区别

 信号量的使用

Lock_guard与unique_lock

线程池

原理与作用

完整代码

---

线程

线程和进程的关系

线程在进程内部运行，是linux下调度的最小执行单位。

进程是承担分配系统资源的基本实体。

         但在Linux中严格来说不存在线程，只有轻量级进程（Linux中的线程和进程本质上是轻量级进程）。

        PCB（进程控制块），在Linux上具体表现为task_struct结构体，每个轻量级进程都有一个task_struct进行管理，所以一个PCB是<=一个进程的，为什么会出现一个PCB是<一个进程的情况？因为当线程数量大于1时，进程就会退化为主线程。

         多线程就是将正文代码的每一部分分别交给多个线程去执行。既然代码存储在内存中那代码必然是有存储地址的（这个地址是虚拟地址）。所以虚拟地址也是一种资源，而多线程执行不同的代码就是因为分配到了不同的资源。

 

虚拟地址与物理地址的映射（三级映射）

         对于一个32位的地址，如果直接通过一个页表进行映射则会非常浪费空间，于是在设计上将虚拟地址拆成10，10，12位。查询时先根据前10位虚拟地址从页目录中找到对应页表，再通过虚拟地址中间10位确定映射哪一个页框，最后加上虚拟地址最后12位偏移量就可以访问物理内存每一个地址了

线程的使用

pthread_t在Linux下是无符号整数(%lu)。

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg)

• 创建一个新线程，成功返回0，失败返回错误号 。

int pthread_join(pthread_t thread, void **retval) 

• 等待线程结束，回收线程返回的信息。retval用于存储线程结束状态，简单地说就是存储返回值（不关心返回的结束状态可以设为nullptr）。

 注意线程调用的函数类型必须为返回值为void*参数为void*的函数。

void *threadStart(void *args)
{//将args强转成char*类型std::string name = static_cast<char *>(args);while (true){sleep(1);std::cout << name << " is running..." << std::endl;}//返回一个void*类型的错误码return (void*)1;
}int main()
{pthread_t tid;int n = pthread_create(&tid, nullptr, threadStart, (void *)"thread-1");if (n != 0){std::cout << "pthread_create error" << std::endl;return 1;}//用void *类型参数接收错误码void *code = nullptr;//等待线程tid结束n = pthread_join(tid, &code);if (n == 0){std::cout << "main thread wait success, newthread exit code is " <<         (uint64_t)code << std::endl;//（强转类型后）打印错误码}return 0;
}

pthread_t pthread_self（） 

• 获取线程id，成功返回0，失败无返回值。

gettid 获取的是内核中真实线程ID,  对于多线程进程来说，每个tid实际是不一样的，而pthread_self获取的是相对于进程的线程控制块的首地址， 只是用来描述统一进程中的不同线程。

void *threadStart(void *args)
{std::string name = static_cast<char *>(args);while (true){sleep(1);//对比getpid()和pthread_self()std::cout << name << " is running..." << ", getpid(): " << getpid() << " , pthread_self():" << pthread_self() << std::endl;}return (void*)1;
}int main()
{pthread_t tid;int n = pthread_create(&tid, nullptr, threadStart, (void *)"thread-1");if (n != 0){std::cout << "pthread_create error" << std::endl;return 1;}void *code = nullptr;n = pthread_join(tid, &code);if (n == 0){std::cout << "main thread wait success, newthread exit code is " <<         (uint64_t)code << std::endl;}return 0;
}

 

void pthread_exit(void *retval)

• 将单个线程退出(对比exit函数)，retval常常传NULL。

 这里为了打印效果家里互斥锁。（线程安全部分详细介绍）

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;void *threadStart(void *args)
{std::string name = static_cast<char *>(args);int cnt = 0;while (true){sleep(1);pthread_mutex_lock(&mutex);std::cout << name << " is running..." << ", getpid(): " << getpid() << " , pthread_self():" << pthread_self() << std::endl;pthread_mutex_unlock(&mutex);if (cnt == 5){std::cout << name << " is stop" << std::endl;pthread_exit(nullptr);}cnt++;}return (void *)1;
}int main()
{pthread_t tid1;int n = pthread_create(&tid1, nullptr, threadStart, (void *)"thread-1");if (n != 0){std::cout << "pthread_create error" << std::endl;return 1;}while (true){sleep(1);pthread_mutex_lock(&mutex);std::cout << "main is running..." << std::endl;pthread_mutex_unlock(&mutex);}void *code = nullptr;n = pthread_join(tid1, &code);if (n == 0){std::cout << "main thread wait success, newthread exit code is " << (uint64_t)code << std::endl;}return 0;
}

 pthread_exit()与exit()不同，前者在线程中使用停止当前线程，而后者无论在哪里调用都会使整个程序停止运行。

int pthread_cancel(pthread_t thread)

• 杀死指定的线程，成功返回0，失败返回错误号 。 

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;void *threadStart(void *args)
{std::string name = static_cast<char *>(args);while (true){sleep(1);pthread_mutex_lock(&mutex);std::cout << name << " is running..." << ", getpid(): " << getpid() << " , pthread_self():" << pthread_self() << std::endl;pthread_mutex_unlock(&mutex);}return (void *)1;
}int main()
{pthread_t tid1;int n = pthread_create(&tid1, nullptr, threadStart, (void *)"thread-1");if (n != 0){std::cout << "pthread_create error" << std::endl;return 1;}int cnt = 0;while (true){sleep(1);pthread_mutex_lock(&mutex);std::cout << "main is running..." << std::endl;pthread_mutex_unlock(&mutex);if(cnt == 5){pthread_cancel(tid1);std::cout << "-----------------------------" << std::endl;std::cout << "       pthread_cancel" << std::endl;std::cout << "-----------------------------" << std::endl;}cnt++;}void *code = nullptr;n = pthread_join(tid1, &code);if (n == 0){std::cout << "main thread wait success, newthread exit code is " << (uint64_t)code << std::endl;}return 0;
}

 

int pthread_detach(pthread_t thread)  

• 实现线程分离，成功返回0，失败返回错误号 。
• 也可使用 pthread_create函数参2(线程属性)来设置线程分离。
• 线程分离状态：线程主动与主线程断开关系。线程结束后，其退出状态不由其他线程获取，而直接自己自动释放。（分离后，不能使用pthread_join等待它的终止状态。）

线程安全

        线程安全指的是在多线程编程中，多个线程对临界资源进行争抢访问而不会造成数据二义或程序逻辑混乱的情况。

为什么要保证线程安全？

就以展示线程接口的代码为例，如果不加互斥锁限制主线程和1号线程对屏幕这份资源的争抢，就会出现如图这样的打印错乱。

 再举个例子如图，现在假设有cnt张票只要大于零就可以进行抢票。但如果不对多线程加以限制有可能会出现图中票被抢到负数的情况（不合理的情况）。

 

 临界资源和临界区

什么是临界资源和临界区？

• 临界资源：一次只允许一个线程访问的共享资源。
• 临界区：每个进程中访问临界资源的那一段代码。

 而锁的作用就是对临界区上锁，保证只有持有锁的那一个线程可以对临界资源进行访问。

互斥锁

同步与互斥

• 互斥是指某一资源同时只允许一个访问者对其进行访问，但互斥无法控制对资源的访问顺序。
• 同步是指在互斥的基础上实现对资源的有序访问。

 互斥锁的使用

锁的初始化

使用锁前，必须要先有一把锁，而锁有两种初始化方式。

动态方法：

调用pthread_mutex_init函数初始化，第一个参数传要初始化锁的指针，第二个参数是互斥量的属性一般传NULL使用缺省值。

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

当然第二个参数也可以不传NULL，还能有以下选择：

•  PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。

• PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。 

• PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。

• PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。

静态方法：

pthread_mutex_t是一个结构体，而PTHREAD_MUTEX_INITIALIZER是一个结构体常量宏。

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int main()
{//静态：pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;//动态：pthread_mutex_t mutex2;pthread_mutex_init(&mutex2,nullptr);return 0;
}

加锁与解锁

只有拿到锁的线程才能去访问临界资源，pthread_mutex_lock()函数就是在竞争锁，抢到锁的线程去访问临界资源，没抢到的等待持有锁的线程进行解锁操作pthread_mutex_unlock()然后再进行竞争。（锁只能保证同一时间只有一个访问资源的线程，但无法控制线程访问资源的顺序，同一个线程连续抢到锁的情况也是有的）

 

• int pthread_mutex_lock(pthread_mutex_t *mutex) 加锁，获取不到锁会挂起等待

• int pthread_mutex_unlock(pthread_mutex_t *mutex)解锁

• int pthread_mutex_trylock(pthread_mutex_t *mutex) 尝试获取锁，锁被占据时返回EBUSY而不挂起等待

//线程要执行的函数
void *threadStart(void *args)
{std::string name = static_cast<char *>(args);while (true){sleep(1);//加锁pthread_mutex_lock(&mutex);std::cout << name << " is running..." << std::endl;//解锁pthread_mutex_unlock(&mutex);}return (void *)1;
}

• int pthread_mutex_destroy(pthread_mutex_t *mutex) 销毁一个互斥（释放它所占用的资源），销毁时锁不能被占用。

int main()
{//静态：pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;//动态：pthread_mutex_t mutex2;pthread_mutex_init(&mutex2,nullptr);pthread_mutex_destroy(&mutex1);pthread_mutex_destroy(&mutex2);return 0;
}

信号量

        信号量是指可用资源的数量。

        具体些可以简单地理解为：当它的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。

信号与信号量的区别

• 信号是Linux系统中用于进程之间通信或操作的一种机制，通常一种信号代表一种状态或一个操作。（冷知识：不处理本身也是一种操作）
• 信号量是指可用资源的数量

 信号量的使用

Lock_guard与unique_lock

Lock_guard与unique_lock都是类，模板参数传入锁的类型，实例化时传入对应类型的锁作为构造函数的参数，用于上锁，生命周期到了会自动解锁。（初始化如下）

unique_lock<mutex> lock(mutex);
lock_guard<mutex> lock(mutex);

 原理：

简单实现了一下（仅供理解原理），原理也很简单，构造函数上锁，析构函数解锁，利用生命周期结束自动调用析构函数的特性解锁（即离开作用域）。

#pragma once
#include <iostream>
#include <pthread.h>class LockGuard
{
public://利用构造函数加锁LockGuard(pthread_mutex_t* mutex): _mutex(mutex){pthread_mutex_lock(_mutex);}//利用析构函数解锁~LockGuard(){pthread_mutex_unlock(_mutex);}private:pthread_mutex_t* _mutex;
};

使用方法：

//线程要执行的函数
void *threadStart(void *args)
{std::string name = static_cast<char *>(args);while (true){sleep(1);       //加锁unique_lock<mutex> lock(mutex);//使用lock_guard<mutex> lock(mutex)替换也可std::cout << name << " is running..." << std::endl;}return (void *)1;
}

除了正常使用，还可以像这样用大括号限定出一个作用域

int main()
{pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;{unique_lock<mutex> lock(mutex);}{lock_guard<mutex> lock(mutex);}return 0;
}

线程池

原理与作用

原理：

        线程池通过一个线程安全的阻塞任务队列加上一个或一个以上的线程实现，线程池中的线程可以从阻塞队列中获取任务进行任务处理，当线程都处于繁忙状态时可以将任务加入阻塞队列中，等到其它的线程空闲后进行处理。

作用：

   可以避免大量线程频繁创建或销毁所带来的时间成本，也可以避免在峰值压力下，系统资源耗尽的风险；并且可以统一对线程池中的线程进行管理，调度监控。

完整代码

线程封装代码：

#pragma once
#include <iostream>
#include <string>
#include <functional>
#include <pthread.h>namespace ThreadMoudle
{class Thread{public:using func_t = std::function<void(std::string)>;Thread(const std::string &name, const func_t &func): _name(name), _func(func){}void Excute(){_isrunning = true;_func(_name);_isrunning = false;}static void *ThreadRoutine(void *args){Thread *self = static_cast<Thread *>(args);self->Excute();return nullptr;}bool start(){int n = pthread_create(&_tid, nullptr, ThreadRoutine, this);if (n != 0)return false;return true;}void stop(){if (_isrunning){pthread_cancel(_tid);_isrunning = false;}}void join(){pthread_join(_tid, nullptr);}~Thread(){}private:pthread_t _tid;std::string _name;bool _isrunning;func_t _func;};
};

日志代码：

#pragma once
#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <ctime>
#include <cstdarg>
#include <fstream>
#include <cstring>
#include <pthread.h>
#include "LockGuard.hpp"namespace log_ns
{#define SCREEN_TYPE 1
#define FILE_TYPE 2enum{DEBUG = 1,INFO,WARNING,ERROR,FATAL};class LogMessage{public:std::string _level;pid_t _id;std::string _filename;int _filenumber;std::string _curr_time;std::string _message_info;};const std::string logfile = "./log.txt";pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER;class log{private:void FlushLogToScreen(LogMessage &log){printf("[%s][%d][%s][%d][%s] %s",log._level.c_str(),log._id,log._filename.c_str(),log._filenumber,log._curr_time.c_str(),log._message_info.c_str());}void FlushLogToFile(LogMessage &log){std::ofstream out(logfile, std::ios::app);char logtxt[1024];snprintf(logtxt, sizeof(logtxt), "[%s][%d][%s][%d][%s] %s",log._level.c_str(),log._id,log._filename.c_str(),log._filenumber,log._curr_time.c_str(),log._message_info.c_str());out.write(logtxt, strlen(logtxt));out.close();}void FlushLog(LogMessage &log){switch (_type){case SCREEN_TYPE:FlushLogToScreen(log);break;case FILE_TYPE:FlushLogToFile(log);break;}}std::string LevelToString(int level){switch (level){case DEBUG:return "DEBUG";case INFO:return "INFO";case WARNING:return "WARNING";case ERROR:return "ERROR";case FATAL:return "FATAL";default:return "UNKNOW";}}std::string GetCurTime(){time_t now = time(nullptr);struct tm *curtime = localtime(&now);char buffer[1024];snprintf(buffer, sizeof(buffer), "%d-%02d-%02d %02d:%02d:%02d",curtime->tm_year + 1900,curtime->tm_mon + 1,curtime->tm_mday,curtime->tm_hour,curtime->tm_min,curtime->tm_sec);return buffer;}public:log(const std::string &filename = logfile) : _filename(filename), _type(SCREEN_TYPE){}~log(){}void Enable(int type){_type = type;}void logMessage(const std::string &filename, int filenumber, int level, const char *format, ...){LogMessage log;log._filename = filename;log._filenumber = filenumber;log._id = getpid();log._level = LevelToString(level);log._curr_time = GetCurTime();va_list ap;va_start(ap, format);char info[1034];vsnprintf(info, sizeof(info), format, ap);va_end(ap);log._message_info = info;FlushLog(log);}private:int _type;std::string _filename;};log_ns::log lg;#define LOG(Level, Format, ...)                                          \do                                                                   \{                                                                    \lg.logMessage(__FILE__, __LINE__, Level, Format, ##__VA_ARGS__); \} while (0)
#define EnableScreen()          \do                          \{                           \lg.Enable(SCREEN_TYPE); \} while (0)
#define EnableFILE()          \do                        \{                         \lg.Enable(FILE_TYPE); \} while (0)
};

线程池完整代码：

#pragma once
#include <iostream>
#include <queue>
#include <string>
#include <vector>
#include <functional>
#include <pthread.h>
#include "Thread.hpp"
#include "Log.hpp"using namespace log_ns;static const int gdefualtnum = 5;template <class T>
class ThreadPool
{
private:void LockQueue(){pthread_mutex_lock(&_mutex);}void UnLockQueue(){pthread_mutex_unlock(&_mutex);}void WakeUp(){pthread_cond_signal(&_cond);}void WakeUpAll(){pthread_cond_broadcast(&_cond);}void Sleep(){pthread_cond_wait(&_cond, &_mutex);}bool TQIsEmpty(){return _task_queue.empty();}void HandlerTask(std::string name){while (true){LockQueue();while (TQIsEmpty() && _isrunning){_sleep_thread_num++;Sleep();_sleep_thread_num--;}if (TQIsEmpty() && !_isrunning){LOG(DEBUG, "%s : quit\n", name.c_str());UnLockQueue();break;}T task = _task_queue.front();_task_queue.pop();LOG(DEBUG, "hander task done, task is : %s\n", task.result().c_str());UnLockQueue();task();}}ThreadPool(int thread_num = gdefualtnum) : _thread_num(thread_num), _isrunning(false), _sleep_thread_num(0){pthread_mutex_init(&_mutex, nullptr);pthread_cond_init(&_cond, nullptr);}ThreadPool(const ThreadPool<T> &) = delete;void operator=(const ThreadPool<T> &) = delete;public:~ThreadPool(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}void Init(){ThreadMoudle::Thread::func_t func = std::bind(&ThreadPool::HandlerTask, this, std::placeholders::_1);for (int i = 0; i < _thread_num; i++){std::string threadname = "pthread_" + std::to_string(i + 1);_threads.emplace_back(threadname, func);}}void Start(){_isrunning = true;for (auto &thread : _threads){thread.start();}}void Stop(){LockQueue();_isrunning = false;if (_sleep_thread_num > 0)WakeUpAll();UnLockQueue();}void Equeue(const T &in){LockQueue();if (_isrunning){_task_queue.push(in);if (_sleep_thread_num > 0)WakeUp();}UnLockQueue();}static ThreadPool<T> *GetInstance(){if (_tp == nullptr){LockGuard lockguard(&_sig_mutex);if (_tp == nullptr){LOG(INFO, "create threadpool\n");_tp = new ThreadPool();_tp->Init();_tp->Start();}else{LOG(INFO, "get threadpool\n");}}return _tp;}private:int _thread_num;int _sleep_thread_num;bool _isrunning;std::vector<ThreadMoudle::Thread> _threads;std::queue<T> _task_queue;pthread_mutex_t _mutex;pthread_cond_t _cond;static ThreadPool<T> *_tp;static pthread_mutex_t _sig_mutex;
};template <typename T>
ThreadPool<T> *ThreadPool<T>::_tp = nullptr;
template <typename T>
pthread_mutex_t ThreadPool<T>::_sig_mutex = PTHREAD_MUTEX_INITIALIZER;