【Linux-多线程】线程互斥（锁和它的接口等）

一、线程互斥

我们把多个线程可以或许看到的资源叫做共享资源，我们对共享资源举行保护，就是互斥
1.多线程访问问题

【示例】见一见多线程访问问题，下面是一个抢票的代码，共计票数10000张，4个线程去抢
之前我们展示过封装代码，这里我们直接使用

1. #include <iostream>
2. #include <vector>
3. #include <cstdio>
4. #include <unistd.h>
5. #include "mythread.hpp"
7. using namespace TreadMoudle;
9. int tickets = 10000;
11. void route(const std::string &name)
12. {
13.     while (true)
14.     {
15.         if (tickets > 0)
16.         {
17.             // 抢票过程
18.             usleep(1000); // 1ms -> 抢票花费的时间
19.             printf("who: %s, get a ticket: %d\n", name.c_str(), tickets);
20.             tickets--;
21.         }
22.         else
23.         {
24.             break;
25.         }
26.     }
27. }
29. int main()
30. {
31.     Thread t1("thread-1", route);
32.     Thread t2("thread-2", route);
33.     Thread t3("thread-3", route);
34.     Thread t4("thread-4", route);
36.     t1.Start();
37.     t2.Start();
38.     t3.Start();
39.     t4.Start();
41.     t1.Join();
42.     t2.Join();
43.     t3.Join();
44.     t4.Join();
45. }

复制代码

【测试结果】：四个线程均抢完票，而且等候乐成，回收乐成；但是我们却发现一个问题，票一共只有1w张，理应最后一个线程得到的票号是1，这里确出现了负数，这是什么原因？

【解释】：盘算机的运算类型有算数运算和逻辑运算，而且是CPU中寄存器举行运算，在CPU内，寄存器只有一套，但是寄存器内里的数据，可以有多套；这些数据属于线程私有，看起来放在了一套公共的寄存器中，但是属于线程私有，当他被切换的时间，他要带走本身的数据！返来的时间会恢复；

• 我们寻常所用的一条代码，在汇编层上大概会对应很多汇编语句，好比一个简单的 tickets-- ，就扳连到至少三条指令：1.重读数据，2.--数据，3.写回数据；
  
• 因此在进入抢票的过程中，看似就几行代码，到了汇编层就是很多代码，CPU是会举行线程切换，这样就会发生数据不一至的问题，怎样明白？我们看图
  

 

怎样办理这种问题？加锁！！
2.认识锁和它的接口 

pthread_mutex_lock

pthread_mutex_lock 是一个在多线程编程中用于锁定互斥量（mutex）的函数。以下是关于 pthread_mutex_lock 的详细阐明：
函数原型：该函数的原型界说如下：

参数：pthread_mutex_t是互斥锁的类型，任何时刻，只允许一个线程举行资源访问
功能形貌：当调用 pthread_mutex_lock 时，它将尝试锁定 mutex 参数指向的互斥量。如果这个互斥量当前没有被锁定，它将被锁定，而且调用该函数的线程将成为互斥量的所有者，函数会立即返回。如果互斥量已经被其他线程锁定，那么调用该函数的线程将会壅闭，直到互斥量被解锁。
互斥量的状态：互斥量有两种状态：未锁定（此时不被任何线程拥有）和锁定（此时被一个线程拥有）。一个互斥量不能同时被两个差别的线程所拥有。如果一个线程尝试锁定一个已经被其他线程锁定的互斥量，它将会等候，直到那个线程解锁互斥量。
返回值：如果函数实行乐成，返回值为 0。如果发生错误，比方尝试重新锁定已经被同一个线程锁定的互斥量，函数将返回一个错误码。

pthread_mutex_t

pthread_mutex_t 是 POSIX 线程（通常称为 pthreads）API 中界说的一个数据类型，用于表示互斥量（mutex）。互斥量是一种同步机制，用于防止多个线程同时访问共享资源，从而制止竞态条件。
界说：

 
注意，pthread_mutex_t 是一个不透明的数据类型，其内部布局对用户是潜伏的。用户不应该尝试直接访问或修改这个布局体的内容。
初始化： 在使用 pthread_mutex_t 之前，必须对其举行初始化。互斥量可以通过以下几种方式举行初始化：
静态初始化（锁是全局的或者静态的）：可以在声明时直接使用宏 PTHREAD_MUTEX_INITIALIZER 举行初始化。

动态初始化：使用 pthread_mutex_init 函数举行初始化。

 
此中 attr 是一个指向 pthread_mutexattr_t 布局的指针，该布局用于设置互斥量的属性。如果 attr 为 NULL，则互斥量将使用默认属性。
烧毁： 当不再须要互斥量时，应该使用 pthread_mutex_destroy 函数来释放它所占用的资源。 

在烧毁一个互斥量之前，必须确保没有线程正在等候或持有该互斥量。
锁定与解锁：

• 使用 pthread_mutex_lock 尝试锁定互斥量。如果互斥量已被锁定，调用线程将壅闭直到互斥量被解锁。
  
• 使用 pthread_mutex_trylock 尝试锁定互斥量，但不会壅闭；如果互斥量已被锁定，则立即返回一个错误码。
  
• 使用 pthread_mutex_unlock 解锁互斥量。
  

属性： 互斥量可以有差别的属性，如类型（平常、递归、错误查抄等），这些属性可以通过 pthread_mutexattr_t 布局来设置。
错误处理： 所有与互斥量相干的函数在出错时都会返回错误码，可以通过 strerror 函数或 perror 函数来获取错误信息。
pthread_mutex_lock / _unlock

 
pthread_mutex_lock 是 POSIX 线程（pthreads）库中的一个函数，用于锁定一个互斥量（mutex）。当一个线程调用 pthread_mutex_lock 尝试锁定一个互斥量时，以下环境大概会发生：
❍ 如果互斥量当前是未锁定的状态，调用线程会乐成锁定该互斥量，并继续实行。
❍ 如果互斥量已经被另一个线程锁定，调用线程将会壅闭，直到该互斥量被解锁。

pthread_mutex_unlock 函数，这是一个 POSIX 线程（pthreads）库中的函数，用于解锁一个互斥量（mutex）。当一个线程完成了对临界区的访问后，它应该解锁互斥量，以便其他线程可以锁定并访问该临界区。
pthread_mutex_trylock

pthread_mutex_trylock 是 POSIX 线程（pthreads）库中的一个函数，用于尝试锁定一个互斥量（mutex），但它与 pthread_mutex_lock 的重要区别在于，如果互斥量已经被锁定，pthread_mutex_trylock 不会壅闭调用线程，而是立即返回一个错误码。

返回值：

• 乐成时（互斥量被乐成锁定），返回 0。
  
• 如果互斥量已经被锁定，返回 EBUSY。
  
• 出现其他错误时，返回其他错误编号。
  

使用场景:

• 非壅闭互斥量锁定：当线程不希望因等候互斥量而壅闭时，可以使用 pthread_mutex_trylock。
  
• 制止死锁：通过尝试锁定互斥量，线程可以决定是否继续实行或接纳其他操作，从而制止死锁。
  
• 优先级继续：在某些实时系统中，为了制止优先级反转，可以使用 pthread_mutex_trylock 来尝试锁定互斥量。
  

注意事项

• 错误处理：调用 pthread_mutex_trylock 时，应查抄返回值，并根据返回值做出相应的处理。
  
• 资源释放：如果 pthread_mutex_trylock 返回 EBUSY，线程应该释放已经持有的资源，制止资源泄露。
  
• 重试策略：通常在使用 pthread_mutex_trylock 时，如果返回 EBUSY，线程大概会在一段时间后重试锁定。
  

学会锁的根本使用后我们就可以修改我们本身实现的多线程，而且重新举行抢票
mythread.hpp

1. #pragma once
2. #include <iostream>
3. #include <string>
4. #include <pthread.h>
6. namespace ThreadMoudle
7. {
8.     class ThreadData
9.     {
10.     public:
11.         ThreadData(const std::string &name, pthread_mutex_t *lock):_name(name), _lock(lock)
12.         {}
13.     public:
14.         std::string _name;
15.         pthread_mutex_t *_lock;
16.     };
18.     // 线程要执行的方法，后面我们随时调整
19.     typedef void (*func_t)(ThreadData *td); // 函数指针类型
21.     class Thread
22.     {
23.     public:
24.         void Excute()
25.         {
26.             std::cout << _name << " is running" << std::endl;
27.             _isrunning = true;
28.             _func(_td);
29.             _isrunning = false;
30.         }
31.     public:
32.         Thread(const std::string &name, func_t func, ThreadData *td):_name(name), _func(func), _td(td)
33.         {
34.             std::cout << "create " << name << " done" << std::endl;
35.         }
36.         static void *ThreadRoutine(void *args) // 新线程都会执行该方法！
37.         {
38.             Thread *self = static_cast<Thread*>(args); // 获得了当前对象
39.             self->Excute();
40.             return nullptr;
41.         }
42.         bool Start()
43.         {
44.             int n = ::pthread_create(&_tid, nullptr, ThreadRoutine, this);
45.             if(n != 0) return false;
46.             return true;
47.         }
48.         std::string Status()
49.         {
50.             if(_isrunning) return "running";
51.             else return "sleep";
52.         }
53.         void Stop()
54.         {
55.             if(_isrunning)
56.             {
57.                 ::pthread_cancel(_tid);
58.                 _isrunning = false;
59.                 std::cout << _name << " Stop" << std::endl;
60.             }
61.         }
62.         void Join()
63.         {
64.             ::pthread_join(_tid, nullptr);
65.             std::cout << _name << " Joined" << std::endl;
66.             delete _td;
67.         }
68.         std::string Name()
69.         {
70.             return _name;
71.         }
72.         ~Thread()
73.         {
74.         }
76.     private:
77.         std::string _name;
78.         pthread_t _tid;
79.         bool _isrunning;
80.         func_t _func; // 线程要执行的回调函数
81.         ThreadData *_td;
82.     };
83. } // namespace ThreadModle

复制代码

 main.cc

1. #include <iostream>
2. #include <vector>
3. #include <cstdio>
4. #include <unistd.h>
5. #include "mythread.hpp"
7. using namespace ThreadMoudle;
8. int tickets = 10000; // 共享资源，造成了数据不一致的问题
10. pthread_mutex_t gmutex = PTHREAD_MUTEX_INITIALIZER;
11. static int threadnum = 4;
13. void route(ThreadData *td)
14. {
15.     // std::cout <<td->_name << ": " << "mutex address: " << td->_lock << std::endl;
16.     // sleep(1);
17.     while (true)
18.     {
19.         pthread_mutex_lock(td->_lock);
20.         if (tickets > 0)
21.         {
22.             // 抢票过程
23.             usleep(1000); // 1ms -> 抢票花费的时间
24.             printf("who: %s, get a ticket: %d\n", td->_name.c_str(), tickets);
25.             tickets--;
26.             pthread_mutex_unlock(td->_lock);
27.         }
28.         else
29.         {
30.             pthread_mutex_unlock(td->_lock);
31.             break;
32.         }
33.     }
34. }
36. int main()
37. {
38.     pthread_mutex_t mutex;
39.     pthread_mutex_init(&mutex, nullptr);
41.     std::vector<Thread> threads;
42.     for (int i = 0; i < threadnum; i++)
43.     {
44.         std::string name = "thread-" + std::to_string(i + 1);
45.         ThreadData *td = new ThreadData(name, &mutex);
46.         threads.emplace_back(name, route, td);
47.     }
49.     for (auto &thread : threads)
50.     {
51.         thread.Start();
52.     }
54.     for (auto &thread : threads)
55.     {
56.         thread.Join();
57.     }
59.     pthread_mutex_destroy(&mutex);
60.     return 0;
61. }

复制代码

【结果】：此时重新实行步调就不会出现数据不同等问题了

所谓的对临界资源举行保护，本质是对临界区代码举行保护
我们对所有资源举行访问，本质都是通过代码举行访问的！保护资源，本质就是把访问资源的代码保护起来
3.办理汗青问题

• 所以，加锁的范围，粒度一定要尽量小
  
• 任何线程，要举行抢票，都得先申请锁，原则上不应该有例外
  
• 所有线程申请锁，前提是所有的线程都得看到这把锁，锁本身也是共享资源----加锁的过程，必须是原子的
  
• 原子性：要么不做，要做就做完，没有中间状态，就是原子性
  
• 如果线程申请锁失败了，我的线程要被壅闭
  
• 如果线程申请锁乐成了，继续向后运行
  
• 如果线程申请锁乐成了，实行临界区的代码了，实行临界区代码期间是可以发生切换的（好比时间片到了），但是纵然切换了，其他线程无法进入！因为我虽然被切换了，但是我没有释放锁，我可以放心的实行完毕，没有人能打扰我
  

结论：所以对于其他线程，要么我没有申请锁，要么我释放了锁，对其他线程才故意义
4.原理角度明白这个锁

 
5.从实现角度明白锁

✸ 经过上面的例子，各人已经意识到单纯的i++或者++i 都不是原子的，有大概会有数据同等性问题
✸ 为了实现互斥锁的操作，大多数体系布局都提供了 swap 或 exchange指令，该指令的作用是把寄存器和内存单元的数据相互换，由于只有一条指令，包管了原子性，纵然是多处理器平台访问内存的，总线周期也有先后，一个处理器上的互换指令实行时另一个处理器的互换指令只能等候总线周期。

 
◉ CPU的寄存器只有一套，被所有的线程共享。但是寄存器内里的数据，属于实行流的上下文，属于实行流私有的数据
◉ CPU在实行代码的时间，一定要有对应的实行载体 -- 线程 && 历程
◉ 数据在内存中，被所有线程是共享的
结论：把数据从内存移动到CPU寄存器中，本质是把数据从共享，变成线程私有
 

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