当前位置：首页 > news >正文

福州建网站，做网页爱站网ip反域名查询

news 2025/8/8 20:24:30

福州建网站，做网页,爱站网ip反域名查询,检测网站为什么打不开了,烟台网站seo服务目录一、问题引入二、线程互斥 1、相关概念 2、加锁保护 1、静态分配 2、动态分配 3、锁的原理 4、死锁三、可重入与线程安全 1、概念 2、常见的线程不安全的情况 3、常见的线程安全的情况 4、常见不可重入的情况 5、常见可重入的情况 6、可重入与线程安全联系…

一、问题引入

二、线程互斥

1、相关概念

2、加锁保护

1、静态分配

2、动态分配

3、锁的原理

4、死锁

三、可重入与线程安全

1、概念

2、常见的线程不安全的情况

3、常见的线程安全的情况

4、常见不可重入的情况

5、常见可重入的情况

6、可重入与线程安全联系

7、可重入与线程安全区别

一、问题引入

大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。
但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。多个线程并发的操作共享变量，会带来一些问题。

我们来看看下面的多线程抢票系统的代码：

#include <iostream>
#include <unistd.h>
#include <cerrno>
#include <cstring>
#include <pthread.h>using namespace std;int ticket = 100;void *getticket(void *arg)
{char *name = (char *)arg;while (true){if (ticket > 0){usleep(1000);cout << name << ":"<< " " << ticket << endl;ticket--;}elsebreak;}
}int main()
{pthread_t tid1, tid2, tid3, tid4;pthread_create(&tid1, nullptr, getticket, (void *)"thread 1");pthread_create(&tid2, nullptr, getticket, (void *)"thread 2");pthread_create(&tid3, nullptr, getticket, (void *)"thread 3");pthread_create(&tid4, nullptr, getticket, (void *)"thread 4");pthread_join(tid1, nullptr);pthread_join(tid2, nullptr);pthread_join(tid3, nullptr);pthread_join(tid4, nullptr);return 0;
}

这里的ticket变量是一个全局变量，那么它就会被所有线程共享。创建线程后，所有线程访问getticket函数，对其进行了重入，访问ticket并对ticket--。但是，我们发现，票数出现了负数，这完全不符合我们的代码逻辑和想要的结果。这是为什么呢？

首先，程序在编译的时候会被编译成汇编代码，而在汇编代码中，ticket--操作在我们看来只有一行代码，但是在汇编中它其实分为了三步：1、将ticket值拷入到CPU寄存器中；2、CPU对其进行--操作；3、将结果写回内存。

而我们知道进程是有时间片的，在执行完上面任意一步时，线程可能因为时间片到了而被切换。而这就会造成一些问题。如下图：

线程A先进入，在完成第二步 -- 操作后，因为时间片到了，要被切换出去，99作为上下文数据被保存起来随A一起被切换。线程B进入，因为B的时间片比较长，他把ticket值减到了50并写回了内存后，时间片到了，被切换。线程A再次进入CPU，把上下文恢复，然后接着第3步执行，直接把99写到了内存里面。

线程B明明已经让ticket的值减到了50，结果你个线程A又直接把结果改成了99。这样就出现了数据错乱的现象。

在我们对ticket进行并发访问的时候，由于ticket- - 操作并不是原子的，所以出现了数据不一致的情况。这种情况怎么解决呢？我们接着往下讲。

二、线程互斥

1、相关概念

1、临界资源：多线程执行流共享的资源就叫做临界资源。
2、临界区：每个线程内部，访问临界资源的代码，就叫做临界区。
3、互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用。
4、原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。

2、加锁保护

为了解决上面代码的数据不一致的问题，需要做到三点：

1、代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。

2、如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。

3、如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。

而其中最简单的一种方法就是对临界资源进行加锁保护。以达到下面的效果：

定义和初始化锁的函数：

NAMEpthread_mutex_destroy, pthread_mutex_init - destroy and initialize a mutexSYNOPSIS#include <pthread.h>1、int pthread_mutex_destroy(pthread_mutex_t *mutex);2、int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);3、pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_t 是由原生线程库给用户提供的一个数据类型，就是我们常说的锁。上图的 1和2 是对锁进行局部定义时的销毁和初始化操作，相当于析构函数和构造函数。

上图的 3 是对全局锁或者static静态锁进行初始化的方式。下面我们一一讲解。

加锁和解锁函数：

发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请锁，但没有竞争到互斥量，那么pthread_ lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁，再去申请锁。

NAMEpthread_mutex_lock,  pthread_mutex_trylock,  pthread_mutex_unlock  -  lock   andunlock a mutexSYNOPSIS#include <pthread.h>int pthread_mutex_lock(pthread_mutex_t *mutex);int pthread_mutex_trylock(pthread_mutex_t *mutex);int pthread_mutex_unlock(pthread_mutex_t *mutex);

1、静态分配

静态分配就是我们 3 对应的对锁定义和初始化的方式。我们使用它对抢票代码进行保护。

#include <iostream>
#include <unistd.h>
#include <cstring>
#include <time.h>
#include <pthread.h>using namespace std;pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int ticket = 100;void *getticket(void *arg)
{char *name = (char *)arg;while (true){pthread_mutex_lock(&mutex); // 加锁保护，其他线程只能在这阻塞等待，直到拿到锁if (ticket > 0)             // 这部分代码只能串行执行{usleep(rand() % 10000);cout << name << ":"<< " " << ticket << endl;ticket--;pthread_mutex_unlock(&mutex); // 访问完临界资源，解锁，// 让其他线程能够拿锁访问}else{pthread_mutex_unlock(&mutex); // 访问完临界资源，解锁// 让其他线程能够拿锁访问break;}usleep(rand() % 2000000);}return nullptr;
}int main()
{srand((unsigned long)time(nullptr) ^ getpid() ^ 433);pthread_t tid1, tid2, tid3, tid4;pthread_create(&tid1, nullptr, getticket, (void *)"thread 1");pthread_create(&tid2, nullptr, getticket, (void *)"thread 2");pthread_create(&tid3, nullptr, getticket, (void *)"thread 3");pthread_create(&tid4, nullptr, getticket, (void *)"thread 4");pthread_join(tid1, nullptr);pthread_join(tid2, nullptr);pthread_join(tid3, nullptr);pthread_join(tid4, nullptr);return 0;
}

注：加锁的时候，一定要保证加锁粒度越小越好。最好不要让一些非临界区也被加锁保护。

2、动态分配

如果我们定义的锁是一个局部变量，那么我们就要像下面的代码这样使用锁：

#include <iostream>
#include <unistd.h>
#include <cstring>
#include <time.h>
#include <pthread.h>using namespace std;
#define THREAD_NUM 5class threaddata
{
public:threaddata(const string &s, pthread_mutex_t *m): name(s), mtx(m){}public:string name;pthread_mutex_t *mtx;
};int ticket = 100;void *getticket(void *arg)
{threaddata *td = (threaddata *)arg;while (true){pthread_mutex_lock(td->mtx);if (ticket > 0)              {usleep(rand() % 10000);cout << td->name << ":"<< " " << ticket << endl;ticket--;pthread_mutex_unlock(td->mtx);}else{pthread_mutex_unlock(td->mtx);break;}usleep(rand() % 2000000);}delete td;return nullptr;
}int main()
{pthread_mutex_t mtx;pthread_mutex_init(&mtx, nullptr);srand((unsigned long)time(nullptr) ^ getpid() ^ 433);pthread_t t[THREAD_NUM];for (int i = 0; i < THREAD_NUM; i++){string name = "thread ";name += to_string(i + 1);threaddata *td = new threaddata(name, &mtx);pthread_create(t + i, nullptr, getticket, (void *)td);}for (int i = 0; i < THREAD_NUM; i++)pthread_join(t[i], nullptr);pthread_mutex_destroy(&mtx);return 0;
}

3、锁的原理

通过加锁，我们能够保证执行临界资源的操作是原子的。可是，访问临界资源时，多个线程要申请同一把锁，那么就必须要能够看到同一把锁，那么这个锁不就成了一个临界资源了吗，那锁是怎么保证自己的安全的呢？

为了保证锁的安全，申请和释放锁的操作也必须是原子的。如何保证呢？

在汇编的角度，如果只有一行汇编语句，我们就认为该汇编语句的执行是原子的。一般来说，是使用swap或exchange指令，以一条汇编语句，将内存和CPU寄存器的数据进行交换。如下图：

线程a是第一个申请锁的。它先将 %al 的内容写成 0，然后交换 %al 和 mutex 的内容，%al 为 1，mutex为0。接着，判断%al的内容 >0，返回，成功拿到锁。线程a切出，寄存器%al的数据作为上下文随线程a一起切出。（当然，线程a可能在任何时候被切出，这是线程a时间片比较长的情况）。

线程b，接着申请锁。它也先将 %al 的内容写成 0，然后交换 %al 和 mutex 的内容，%al 为 0，mutex为0。接着，判断%al的内容不大于0，于是线程b挂起等待。只有线程a将锁释放后，才能重新申请锁。