自旋锁

自旋锁定义：它是为实现保护共享资源的一种锁机制。如果资源已经被占用，就一直循环在那里看是否该自旋锁的保持者已经释放了锁。

与互斥锁的区别：互斥锁，如果资源已经被占用，资源申请者只能进入睡眠状态。

 

代码主要是做练习用的，水平有限，路过的大神看到代码有哪里不好的请帮忙指出来，万分感谢。

#pragma once

#include <atomic>
#include <thread>
#include <iostream>

class SpinLock
{
public:
    SpinLock() = default;
    SpinLock(const SpinLock&) = delete;
    SpinLock(SpinLock&&) = delete;
    SpinLock& operator = (const SpinLock&) = delete;
    SpinLock& operator = (SpinLock&&) = delete;

    ~SpinLock()
    {
        mvUnLock();
    }

    void mvLock()
    {
        bool b_except = false;

        while (!moFlag.compare_exchange_weak(b_except, true))
        {
            b_except = false;
        }
    }

    void mvUnLock()
    {
        moFlag.store(false);
    }

private:
    std::atomic_bool moFlag{ false };
};

int num = 0;
SpinLock mutex;
void fun()
{
    while (num < 10)
    {
        mutex.mvLock(); 
        if (num < 10)   // 这里还是需要双重判断
        {
            num++;
            std::cout << std::this_thread::get_id() << " num:" << num << std::endl;
        }
        
        
        mutex.mvUnLock();
    }
}
void test()
{
    std::thread t1(fun);
    std::thread t2(fun);

    t1.join();
    t2.join();
}

一点疑问：我在析构函数中加了一个解锁的动作，看上去有点不合理，但是，我觉得lock的时候是一个循环，如果漏了解锁或者其他异常情况，那不是程序退出都退出不了？ 我查了一下网上的列子都没有加的，估计是不要加，求大神帮忙解释一下，感谢。