【Linux】从零开始认识多线程 --- 线程互斥

   人生有许多事情      正如船后的波纹        总要事后才觉得美的          -- 余光中            

---

  
1 线程类的封装

学习线程互斥之前，我们先对linux的线程库进行封装，熟悉一下C++的线程库。并且方便我们后续使用
1.1 框架搭建

我们主要要实现start stop join三个功能，线程启动，线程制止，线程等待。完成这些就可以快速使用线程了！
类内部需要：

• 线程名字：name
  
• 线程ID ：进行等待和制止关键
  
• 是否运行判断 ：只有运行状态才可以进行制止和等待
  
• 线程需要执行的回调函数指针 typedef void(*func_t)(const std::string& name)
  
• 函数返回值 void* result
  

拥有这些成员变量，就这样就可以包管我们的基本工作了！

1. namespace ThreadMouble
2. {
3.         //回调函数的类型
4.     typedef void(*func_t)(const std::string& name);
5.     class Thread
6.     {
7.     public:
8.             //构造函数需要传入名字和回调函数
9.         Thread(const std::string& name , func_t func):
10.             _name(name), _func(func)
11.         {
12.         }
13.         bool Start()
14.         {
15.         }
16.         void Stop()
17.         {
18.         }
19.         void Join()
20.         {
21.         }
22.         ~Thread()
23.         {
24.         }
25.     private:
26.         //线程名字
27.         std::string _name;
28.         //线程ID
29.         pthread_t id;
30.         //是否运行判断符
31.         bool isrunning;
32.         //回调函数
33.         func_t _func;
34.         //函数返回值
35.         std::string _result;
36.     };
37. }

复制代码

1.2 线程启动

线程启动接口很简单就可以实现，我们调用体系调用pthread_create传入对应的参数.
但是执行的ThreadRun函数就要费一些头脑，pthread_create体系调用中需要传入一个void* (* )(void*)的函数指针

1.    void* ThreadRoutinue(void* args) --- 执行回调方法

复制代码

但是对象内的函数都有一个默认参数 this指针,以是需要加入 static修饰成为类的函数，这样也造成不能调用内部的成员了， 为了优雅的执行 多加一个Excute()成员 进行调用回调函数

1.              void Excute()
2.         {
3.             isrunning = true;
4.             _func(_name);
5.             isrunning = false;
6.         }
7.         static void* ThreadRun(void* args)
8.         {
9.                 //获取类对象
10.             Thread* self = static_cast<Thread*>(args);
11.             self->Excute();
12.             return nullptr;
13.         }
14.                 bool Start()
15.         {
16.             //需要启动线程
17.             isrunning = true;
18.             int n = ::pthread_create(&id , nullptr , ThreadRun , this);
19.             if(n == 0)
20.             {
21.                 return true;
22.             }
23.             else
24.             {
25.                 return false;
26.             }
27.         }

复制代码

PS： ::表现使用标准库的接口
这样就优雅的执行了线程启动
1.3 线程制止

只有线程运行了才可以进行制止,直接调用体系调用即可

1.         void Stop()
2.         {
3.             if(isrunning )
4.             {
5.                 isrunning = false;
6.                 ::pthread_cancel(id);
7.             }
8.             return ;
9.         }

复制代码

1.4 线程等待

直接调用体系调用即可!

1.         void Join()
2.         {
3.             ::pthread_join(id , nullptr);
4.             return ;
5.         }

复制代码

1.5 运行测试

我们写好了线程的封装，接下来就来使用一下，来看看效果：

1. #include<iostream>
2. #include"Thread.hpp"
3. #include<unistd.h>
5. using namespace ThreadMouble;
7. void threadrun(const std::string& name)
8. {
9.     while(true)
10.     {
11.         std::cout << "name: " << name << " is running..." << std::endl;
12.         sleep(1);
13.     }
14.     return ;
15. }
17. int main()
18. {
19.    
20.     Thread t("thread-1" , threadrun);
22.     t.Start();
23.     std::cout << t.status() << std::endl;
24.    
25.     sleep(10);
26.     t.Stop();
27.     t.Join();
29.     return 0;
30. }

复制代码

运行来看：

很好，可以正常创建线程并执行使命！
2 线程互斥

线程可以看到的大部门资源是共享资源，即多个线程可以看到的资源叫做共享资源！那么假如本日这个共享资源是一个大数组，一个线程可以进行写入，其他线程可以进行读取，这样不就实现了线程通信了！可是还是有问题的，因为线程读取不受对方控制，可以刚写一个字符立马就被读取了。就造成了读取不一致的问题。以是共享资源每每需要进行掩护，类似取ATM机取钱，虽然是公共场所但是只有你一个人可以使用当前的ATM机。而线程也有这样的场景，就是线程互斥！
2.1 多线程访问的问题

首先我们先来看看多线程访问中会遇到的问题 — 我们设置一个情形，抢10000张票，我们设置4个并发线程一起来抢票：

• 按理来说每个线程只会在有票的时候可以抢
  
• 抢到就总数减一 ， 直到没票为止
  

1. #include <iostream>
2. #include "Thread.hpp"
3. #include <unistd.h>
4. #include <vector>
6. using namespace ThreadMouble;
9. // 一共10000张票
10. int num = 10000;
12. void threadrun(const std::string &name)
13. {
14.     while (true)
15.     {
16.         if (num > 0)
17.         {
18.             usleep(1000);//抢票的时间
19.             std::cout << "name: " << name << "剩余票数: " << num << std::endl;
20.             num--;
21.         }
22.         else
23.         {
24.             break;
25.         }
26.     }
27.     return;
28. }
30. int main()
31. {
33.     std::vector<Thread> thds;
35.     for (int i = 0; i < 4; i++)
36.     {
37.         char buffer[128];
38.         std::string name = "thread-" + std::to_string(i);
39.         snprintf(buffer, 128, "%s", name.c_str());
40.         thds.emplace_back(buffer, threadrun);
41.     }
42.     for (int i = 0; i < 4; i++)
43.     {
44.         thds[i].Start();
45.     }
47.     std::cout << "所以票已经强光！！！ " << std::endl;
49.     for (int i = 0; i < 4; i++)
50.     {
51.         thds[i].Join();
52.     }
54.     return 0;
55. }

复制代码

我们运行看看：

运行之后发现怎么抢到了负数票？这是为什么？？？这其实就是多线程并发访问中会遇到的问题，访问全局资源时就发生了问题！
我们分析一下为什么会发生问题
   直接原因   

• 判读的过程其实是一种计算，计算结果是真和假（逻辑运算），是由CPU进行的，当CPU进行计算时，会先在内存中读取num ,然后再到一个寄存器中进行储存，再然后将判断数0移动到寄存器进行判断，最后得到结果。每个线程都会进行这样一个过程
  
• 一行代码大概对应多条汇编指令，执行汇编指令 中随时都大概切换到其他线程
  
• CPU中只有一套寄存器，但是寄存器的数据可以有多套（属于线程私有，看起来放在一套公共资源中，它会带走自己的数据，返来时规复），以是假如在判断过程中进行了线程的切换，此时还没有进行--,就大概造成多个线程都存储着最后一张票，这样就造成了负数！
  

2.2 解决办法 — 锁

为相识决上述的问题，就要使用锁，我们先来相识锁和对应接口。

在pthread库中有我们锁的对应接口,和类型pthread_mutex_t互斥锁（任何时候只允许一个线程进行资源访问）。有了这把锁既有对应的初始化和烧毁。设置时不管是全局的还是静态的，只需要进行init即可。

• pthread_mutex_init的第一个参数传入锁的地址，第二个参数设置为nullptr就行.
  
• pthread_mutex_destory传入锁的地址就可以进行烧毁了，全局或者静态的其实不需要进行主动烧毁，在程序运行竣事之后就主动烧毁了。使用临时锁时才需要进行主动烧毁。
  

进行加锁时需要使用lock ,解锁使用unlock，非常直观！在使用过程中，会有多个线程竞争一个锁，成功的正常运行，失败的直接阻塞。
所谓的对共享资源的掩护，本质是对临界区代码的掩护！因为访问资源是由代码进行访问的，把访问资源的代码掩护起来就掩护了共享资源！接下来我们来相识一下临界区和非临界区

在需要掩护的区域进行上锁，使其串行执行线程，就不会出现之前并发执行的问题了！
我们快速上手一下：

1. void threadrun(const std::string &name)
2. {
3.     while (true)
4.     {
5.         pthread_mutex_lock(&gmutex);
6.         if (num > 0)
7.         {
8.             usleep(1000);
9.             std::cout << "name: " << name << "剩余票数: " << num << std::endl;
10.             num--;
11.             pthread_mutex_unlock(&gmutex);
12.         }
13.         else
14.         {
15.             pthread_mutex_unlock(&gmutex);
16.             break;
17.         }
18.     }
19.     return;
20. }

复制代码

我们分析过，出现问题的原因是这个判断语句，也就是临界区，要在临界区之前上锁。也就是在进行抢票判断之前，我们先将代码上锁。之后处理完成绩解锁（一定要包管解锁）。

注意：

• 加锁的粒度一定要小，只将临界区代码加锁就可以
  
• 任何历程要进行抢票，都得先申请锁，不应该有例外！
  
• 全部线程申请锁的条件是都要看到这把锁， 以是锁也是一种共享资源！是共享资源就有大概会出现之前的问题，但是锁用谁来掩护呢？想要不发生问题就得包管加锁的过程必须是原子的（只有一条汇编指令）！
  
• 原子性：要么不做，要做就做完，没有中心状态！
  
• 假如线程申请锁失败了，当前线程就会别阻塞！
  
• 假如线程申请锁成功了，当前线程就继续进行！
  
• 线程申请锁成功了，运行临界区的代码时，会进行切换吗？可以！加锁不会影响调度算法，只会影响线程会不会继续向下运行！加锁的线程可以放心运行，不会受到打扰！
  

总之，对于其他线程，要么没有申请锁，要么释放了锁，对于其他线程才有意义!相称于我访问临界区，对于其他线程是原子的！
我们在对锁和线程名进行一个整体封装，更加优雅地进行使用：

1. // 包含回调函数所需的数据
2.     class ThreadData
3.     {
4.     public:
5.         ThreadData(const std::string name, pthread_mutex_t *gmutex) : _name(name), _lock(gmutex)
6.         {
7.         }
8.         ~ThreadData()
9.         {
10.         }
12.     public:
13.         std::string _name;
14.         pthread_mutex_t *_lock;
15.     };

复制代码

再稍微修改一下线程类内部的构造函数，将主函数的传参修改一下：

1. int main()
2. {
3.         //设置一个局部锁
4.     pthread_mutex_t mutex ;
5.     pthread_mutex_init(&mutex , nullptr);
7.     std::vector<Thread> thds;
9.     for (int i = 0; i < 4; i++)
10.     {
11.         char buffer[128];
12.         std::string name = "thread-" + std::to_string(i);
13.         snprintf(buffer, 128, "%s", name.c_str());
14.                 //每个线程都需要一个td对象
15.         ThreadData *td = new ThreadData(name, &mutex);
17.         thds.emplace_back(name, threadrun, td);
18.     }
19.     for (int i = 0; i < 4; i++)
20.     {
21.         thds[i].Start();
22.     }
24.     for (int i = 0; i < 4; i++)
25.     {
26.         thds[i].Join();
27.     }
28.     //销毁锁
29.     pthread_mutex_destroy(&mutex);
30.     return 0;
31. }

复制代码

我们运行一下：

可以看到使用的是同一个锁！
我们还可以进行优化，我们可以将锁单独封装起来，做到主动解锁释放：

1. #include <pthread.h>
3. class LockGuard
4. {
5. public:
6.     LockGuard(pthread_mutex_t *td) : _td(td)
7.     {
8.         pthread_mutex_lock(_td);
9.     }
10.     ~LockGuard()
11.     {
12.         pthread_mutex_unlock(_td);
13.     }
15. private:
16.     pthread_mutex_t *_td;
17. };

复制代码

这样每次在临界区之前创建一个锁对象，就可以完成对临界区的掩护！
2.3 从原理角度明白锁

上面我们见到了锁的作用，那我们怎样明白：

• 申请锁成功，允许进入临界区
  
• 申请锁失败，不允许进入临界区
  很简单，申请成功了，函数pthread_mutex_lock()会返回，否则不返回（就阻塞了，直到函数内部被唤醒，重新申请锁）！这就一个类似scanf()的情况 。
  

• 我们已经意识到单纯的 i++ 或者 ++i 都不是原子的，因为++这个运算至少经历三条汇编语句，在运行其中一条时退出， 有大概会有数据一致性问题!
  
• 为了实现互斥锁操纵,大多数体系布局都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相互换,由于只有一条指令,包管了原子性(一条汇编语句的是原子性的)。纵然是多处理器平台,访问内存的总线周期也有先后,一个处理器上的互换指令执行时另一个处理器的互换指令只能等待总线周期。
  

我们可以绘图来看：

• 首先先确认一个概念：lock为1才能进行。
  
• 将内存中锁数据与寄存器的数据互换，将 1 移动到寄存器中，而寄存器此时数据是属于当前线程的，在线程调度完之后，就会将这个1带走！
  
• 下一个线程进行锁数据与寄存器的数据互换，只会得到0就阻塞在这里了
  
• 等锁住的线程执行竣事，进行解锁，将1互换到内存中，此时就可以别其他线程使用了！
  

后序文章继续学习线程互斥与线程同步！
Thanks♪(･ω･)ﾉ谢谢阅读！！！

下一篇文章见！！！


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。