C++ 多线程开发常见面试题

1、多线程编程中互斥和同步的区别？

（1）互斥

互斥主要用于保护对共享资源的访问，确保在同一时刻只有一个线程可以访问共享资源。互斥可以防止多个线程同时修改同一个数据，从而避免数据竞争条件（race conditions）。最常用的互斥机制是互斥锁。互斥锁通常用来保护临界区（critical section），即一段不能被多个线程同时访问的代码或数据。通过互斥锁，可以确保在某一时刻只有一个线程可以进入临界区，具有排它性。

但互斥锁无法限制访问者对资源的访问顺序，即访问是无序的。

举个例子：厕所只有一个位置，现在有3个人要上厕所，互斥只能达到控制一个时间只能一个人上的效果，但是这个3个人谁先上是不管的。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int shared_data = 0;

void incrementSharedData() {    
	std::lock_guard<std::mutex> lock(mtx);    
	shared_data++;    
	std::cout << "Thread " << std::this_thread::get_id() << " incremented shared_data to " << shared_data << std::endl;
}

int main() 
{    
	std::vector<std::thread> threads;    
	for (int i = 0; i < 10; ++i) {        
	threads.emplace_back(incrementSharedData);    
		}
    for (auto& t : threads) {        
    t.join();    
    	}
    std::cout << "Final value of shared_data: " << shared_data << std::endl;
    return 0;
}

std::lock_guard：构造时立即加锁，析构时自动解锁，提供最基础的锁管理，保证异常安全
std::unique_lock：提供更高级别控制，包括延迟加锁、尝试加锁、以及条件变量的集成等。

互斥解决了多线程对临界区使用的问题，但是它没有解决多进程协同工作的问题。

（2）同步

同步（Synchronization）指的是在多线程环境中协调不同线程之间的执行顺序，以确保它们按照预期的方式执行。同步机制不仅可以解决互斥问题，还可以解决线程之间的协作问题。

同步在互斥的基础上，通过其它机制实现访问者对资源的有序访问，它解决的是一个时间顺序问题。
所以说同步已经实现了互斥。

举个例子：银行办事大厅的一个窗口，有10个人取号，按照号码顺序来进行办理业务。

同步的特点：
协调执行：确保线程按照一定的顺序执行。
多种机制：除了互斥锁之外，还包括 信号量（Semaphore）、条件变量、原子操作、屏障 等。

互斥锁+条件变量+信号量实现同步

网络库中的例子：

EventLoop* EventLoopThread::startLoop()//开启循环
{
    thread_.start();//启动底层的新线程
	//启动后执行的是EventLoopThread::threadFunc
    EventLoop *loop = nullptr;
    {
        std::unique_lock<std::mutex> lock(mutex_);
        while ( loop_ == nullptr )
        {
            cond_.wait(lock);//挂起，等待  threadFunc中的loop创建好并通知
        }
        loop = loop_;
    }
    return loop;
}


// 下面这个方法是在单独的新线程里运行的
void EventLoopThread::threadFunc()
{
    EventLoop loop; // 创建一个独立的EventLoop，和上面的线程是一一对应的，真正的 one loop per thread ！！

    if (callback_)//如果有回调
    {
        callback_(&loop);//绑定loop做一些事情
    }

    {
        std::unique_lock<std::mutex> lock(mutex_);
        loop_ = &loop;//就是运行在这个线程的loop对象
        cond_.notify_one();//唤醒1个线程
    }


    // 一般来说会一直在loop函数中循环  
    loop.loop();//相当于EventLoop loop  => Poller.poll

    //执行到这个下边就说明服务器程序要关闭掉了
    std::unique_lock<std::mutex> lock(mutex_);
    loop_ = nullptr;
}

主线程创建一个新线程（利用信号量来实现），这个新线程用于执行 threadFunc() 函数，来创建一个Eventloop。

// 启动当前线程
void Thread::start() // 一个Thread对象就是记录的一个新线程的详细信息
{
    started_ = true;
    // 信号量的作用是等待新线程的创建完成，以确保线程对象的 tid_ 成员变量被正确设置
    // 解释：如果start线程走的快，直接执行到sem_wait(&sem)，由于还没有子线程没有给信号量加一 sem_post(&sem)，
    // 所以就阻塞住了，等待子线程给信号量加一， tid_已经正确设置了，就可以继续执行了
    sem_t sem;
    sem_init(&sem, false, 0);

    // 创建子线程thread_， 就是这个类的线程，采用智能指针+lamda表达式的方式
    // 使用智能指针管理子线程生命周期，确保子线程对象销毁时正确回收，避免内存泄漏
    thread_ = std::shared_ptr<std::thread>(new std::thread([&](){
        // 获取线程的tid值
        tid_ = CurrentThread::tid();
        // 子线程给信号量+1，解除主线程的sem_wait阻塞
        sem_post(&sem);
        //开启一个新线程，专门执行该线程函数
        func_(); //包含一个eventLoop
    }));

    // 这里必须等待获取上面新创建线程的tid值
    sem_wait(&sem);
}

补充：信号量：

在生产者消费者模型中，对任务数量的记录就可以使用信号量来做。当信号量的值小于 0 时，工作进程或者线程就会阻塞，等待物品到来。当生产者生产一个物品，会将信号量值 加1 操作 sem_post(&sem)。
这是会唤醒在信号量上阻塞的进程或者线程sem_wait(&sem)，它们去争抢物品。

信号量广泛用于进程或线程间的同步和互斥，信号量本质上是⼀个非负的整数计数器，它被用来控制对公共资源的访问。

注意：信号量不能保证多线程数据安全问题，要与互斥量配合使用。

	信号量的类型 sem_t
	typedef union
	{
	  char __size[__SIZEOF_SEM_T];  //# define __SIZEOF_SEM_T	32
	  long int __align;
	} sem_t;

    int sem_init(sem_t *sem, int pshared, unsigned int value);
        - 初始化信号量
        - 参数：
            - sem : 信号量变量的地址
            - pshared : 0 用在线程间 ，非0 用在进程间
            - value : 信号量中的值

    int sem_destroy(sem_t *sem);
        - 释放资源

    int sem_wait(sem_t *sem);
        - 对信号量加锁，调用一次对信号量的值-1，如果值为0，就阻塞

    int sem_trywait(sem_t *sem);

    int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
    int sem_post(sem_t *sem);
        - 对信号量解锁，调用一次对信号量的值+1

    int sem_getvalue(sem_t *sem, int *sval);

    sem_t psem;
    sem_t csem;
    sem_init(psem, 0, 8);
    sem_init(csem, 0, 0);

    producer() {
        sem_wait(&psem); // 8 可以生产，然后-1 = 7
        sem_post(&csem) // +1
    }

    customer() {
        sem_wait(&csem); // 原来是0，但生产者生产了一个，所以可以消费1个，1-1 = 0
        sem_post(&psem) //我需要一个 +1 = 8
    }