【面经笔记】线程、多线程 - 死锁、读写、消费者问题、TLS【续2】

最新推荐文章于 2024-01-22 19:40:36 发布

xiaxzhou

最新推荐文章于 2024-01-22 19:40:36 发布

阅读量655

点赞数

分类专栏：阿里巴巴面试题面试题文章标签：多线程

本文链接：https://blog.csdn.net/xiaxzhou/article/details/75944302

版权

阿里巴巴面试题同时被 2 个专栏收录

32 篇文章

订阅专栏

面试题

11 篇文章

订阅专栏

本文深入探讨了多线程编程中的关键概念，包括死锁的发生原因、预防策略和银行家算法，生产者消费者问题与读者-写者问题的差异，volatile关键字的作用，以及在C++中使用线程局部存储（TLS）的方法。通过这些内容，有助于理解和解决多线程环境下的并发问题。

摘要由CSDN通过智能技术生成

死锁：

定义：一组相互竞争资源或进行通信的进程间的永久阻塞。
死锁产生的原因：
（1）因为系统资源不足。
（2）进程运行推进的顺序不合适。
（3）资源分配不当等。
死锁条件：互斥、占有并等待、不可剥夺、（循环等待）
死锁预防：解除死锁的必要条件，排除发生死锁的可能性。
1. 互斥：不可禁止
2. 占有并等待：要求进程一次性请求所有资源，阻塞直到所有请求满足
3. 不可剥夺：进程若进一步请求被拒绝，则需释放最初占有的资源；优先级高的进程可以抢占优先级低的进程资源。
死锁避免：允许三个发生死锁的条件，但是通过明智的策略，确保不会发生死锁。
1. 进程启动拒绝：如果一个进程的请求会导致死锁，则不启动这个进程：
  对每种资源，都需要满足：
  新进程及已有进程对此项资源的最大需求之和小于系统可分配资源数
2. 资源分配拒绝：如果一个进程增加的资源请求会导致死锁，则不允许资源分配：银行家算法

银行家算法：

参考：http://blog.csdn.net/leo115/article/details/8039589

链接中博文指出算法核心是：保证银行家的余额至少不小于一个客户的限额
这种判断安全的方法必须和进程启动拒绝判断一起使用才可以避免死锁。
如：系统资源10；A、B、C三个进程分别最大需求：8、 8、 2 。
A请求4 、 B请求 4 。
而此时 A还需要4且B还需要4才能结束，则发生死锁。
但如果有进程启动拒绝，则B进程是不会被启动的。

安全状态：至少有一个资源分配序列不会导致死锁，所有进程都能运行直到结束。

安全状态的判断：每次找一个可满足其最大资源需求的进程，回收其资源；直到所有进程回收。中途若找不到可满足最大资源需求的进程，则说明不安全。

若已有进程启动拒绝判断，只需剩余资源可以满足某一个进程的最大需求，则为安全状态。

当进程请求资源时，假设同意该请求，改变了系统状态，然后确认其结果是否还是安全状态。若是，则同意请求；否则，拒绝请求。

生产者消费者问题：

任何时候只有一个主体可以访问缓冲区
缓冲区大小有限：N

#include <pthread.h>
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <semaphore.h>
#include <iostream>
#pragma comment(lib,"pthreadVC2.lib") 

using namespace::std;

#define CONSUMERNUM 3
#define BUFFERSIZE 10

vector<int> data;

sem_t sem_buffer;//信号量：防止缓冲区溢出
sem_t sem_product;//信号量：防止消费者消费空
pthread_mutex_t mutex;//互斥量：限制访问缓冲区线程数

void * consume_func(void * arg)
{
    int id = (int)arg;
    while (1)
    {
        sem_wait(&sem_product);
        pthread_mutex_lock(&mutex);
        cout << "线程"<<id <<"消费： "<<*data.begin() << endl;
        data.erase(data.begin());
        sem_post(&sem_buffer);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}
void * product_func(void * arg)
{
    int i(0);
    while (1)
    {
        sem_wait(&sem_buffer);
        pthread_mutex_lock(&mutex);
        data.push_back(i++);
        cout <<"线程生产: "<< data.back() << endl;
        sem_post(&sem_product);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}
int main()
{
    pthread_mutex_init(&mutex, 0);
    sem_init(&sem_buffer, 0, 10);
    sem_init(&sem_product, 0, 0);
    pthread_t consumer[CONSUMERNUM], productor;

    for (auto i = 0; i < CONSUMERNUM;++i)
        pthread_create(&consumer[i], NULL, consume_func, (void *)i);
    pthread_create(&productor, NULL, product_func, NULL);

    void * res;
    for (auto i = 0; i < CONSUMERNUM;++i)
        pthread_join(consumer[i], &res);
    pthread_join(productor, &res);

    pthread_mutex_destroy(&mutex);
    sem_destroy(&sem_buffer);
    sem_destroy(&sem_product);
    return 0;
}

读者-写者问题：

生产者-消费者问题能不能看成一个写进程，一个读进程的读者-写者问题呢？

不能，生产者不仅是一个写进程，还必须读取队列指针，决定下一项往哪里写，还必须确定缓冲区是否已满，消费者不仅仅是读取数据，还必须调整队列指针。

直接使用读写锁：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <semaphore.h>
#include <iostream>
#pragma comment(lib,"pthreadVC2.lib") 

using namespace::std;

pthread_rwlock_t rwlock;

pthread_t readerM, readerN, writerA, writerB;

int data(1);//共享资源

void* readM(void * arg)
{
    while (1)
    {
        pthread_rwlock_rdlock(&rwlock);
        cout << "读者M 读取数据：" << data << endl;
        pthread_rwlock_unlock(&rwlock);
        Sleep(1200);
    }
    return NULL;
}

void* readN(void * arg)
{
    while (1)
    {
        pthread_rwlock_rdlock(&rwlock);
        cout << "读者N 读取数据：" << data << endl;
        pthread_rwlock_unlock(&rwlock);
        Sleep(1200);
    }
    return NULL;
}

void* writeA(void * arg)
{
    while (1)
    {
        pthread_rwlock_wrlock(&rwlock);
        data++;
        cout << "写者A 写入数据：" << data << endl;
        pthread_rwlock_unlock(&rwlock);
        Sleep(2000);
    }
    return NULL;
}

void* writeB(void * arg)
{
    while (1)
    {
        pthread_rwlock_wrlock(&rwlock);
        data++;
        cout << "写者B 写入数据：" << data << endl;
        pthread_rwlock_unlock(&rwlock);
        Sleep(2000);

    }
    return NULL;
}

int main()
{
    pthread_rwlock_init(&rwlock,NULL);

    pthread_create(&readerM, NULL, readM, NULL);
    pthread_create(&readerN, NULL, readN, NULL);
    pthread_create(&writerA, NULL, writeA, NULL);
    pthread_create(&writerB, NULL, writeB, NULL);

    void * res;
    pthread_join(readerM,&res);
    pthread_join(readerN,&res);
    pthread_join(writerA,&res);
    pthread_join(writerB,&res);

    pthread_rwlock_destroy(&rwlock);

    return 0;
}

volatile :

volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。声明时语法：int volatile vInt;

当要求使用 volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。

有些变量是用 volatile 关键字声明的。当两个线程都要用到某一个变量且该变量的值会被改变时，应该用 volatile 声明，该关键字的作用是防止优化编译器把变量从内存装入 CPU 寄存器中。如果变量被装入寄存器，那么两个线程有可能一个使用内存中的变量，一个使用寄存器中的变量，这会造成程序的错误执行。volatile 的意思是让编译器每次操作该变量时一定要从内存中真正取出，而不是使用已经存在寄存器中的值

C++类中线程callback函数怎么使用自己类的成员

首先回调函数得定义成static，然后把this指针传入

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <iostream>
#pragma comment(lib,"pthreadVC2.lib") 

using namespace::std;

class my_class
{
public:
    static void *thrd_func(void* p_)
    {
        my_class* p = (my_class*)p_;
        cout << p->value << endl;
        return NULL;
    }
    my_class(int v) :value(v){};
private:
    int value;
};

int main()
{
    pthread_t class_thrd;
    my_class tmp_class(3);
    pthread_create(&class_thrd, NULL, my_class::thrd_func, (void*)&tmp_class);

    void *res;
    pthread_join(class_thrd,&res);
    return 0;
}

线程局部存储：

如果需要在一个线程内部的各个函数调用都能访问、但其它线程不能访问的变量（被称为static memory local to a thread 线程局部静态变量），就需要新的机制来实现。这就是TLS。

要实现线程局部存储并不难，最简单的办法就是建立一个全局表，通过当前线程ID去查询相应的数据，因为各个线程的ID不同，查到的数据自然也不同了。但Windows系统采用了每个线程建线程专享的索引表，表的条目为线程局部存储的地址。在线程执行的任何代码处，都可以查询本线程的这个索引表获得要访问的线程局部存储的地址。

windows下：