悲观锁和乐观锁

悲观锁：在每次取数据时，总是担心数据会被其他线程修改，所以会在取数据前先加锁（读锁，写锁，行锁等），当其他线程想要访问数据时，被阻塞挂起。（互斥锁就是一种悲观锁）

乐观锁：每次取数据时候，总是乐观的认为数据不会被其他线程修改，因此不上锁。但是在更新数据前，会判断其他数据在更新前有没有对数据进行修改。主要采用两种方式：版本号机制和CAS操作。(C++原子操作是基于CAS的乐观锁)

自旋锁

由于挂起等待也有一定的消耗，万一在挂起时直接再次申请锁就成功了，挂起锁的消耗就更高。自旋锁类似于在加锁时采用：

while(pthread_mutex_trylock(&mutex));

的方式加锁。很有可能会反复申请锁，浪费CPU资源，只有在临界区的时间特别短才能使用

比如抢票代码：

#include<iostream>
#include<pthread.h> 
#include<vector>
#include<string>
#include<unistd.h>
using namespace std;
int ticket = 1000;
class mutexGuard
{
public:
    mutexGuard(pthread_spinlock_t* pmutex)
    {
        _pmutex = pmutex;
        pthread_spin_lock(_pmutex);
    }
    ~mutexGuard()
    {
        pthread_spin_unlock(_pmutex);
    }
private:
    pthread_spinlock_t* _pmutex;

};

class threadDate
{
public:
    threadDate(const string& name, pthread_spinlock_t* pmutex)
    :_name(name)
    ,_pmutex(pmutex)
    {}
    string _name;
    pthread_spinlock_t* _pmutex;
};

void* getTicket(void* args)
{
    threadDate* td = static_cast<threadDate*>(args);
    while(ticket > 0)
    {
        
        {
            mutexGuard mg = mutexGuard(td->_pmutex);
            if(ticket > 0)
            {
                usleep(1000);
                --ticket;
                cout << td->_name << " : " << ticket << endl;
            }
        }
    }
    delete td;
    return nullptr;
}

int main()
{
    vector<pthread_t> tid(5);
    int cnt = 0;
    pthread_spinlock_t mutex;
    pthread_spin_init(&mutex, PTHREAD_PROCESS_PRIVATE);
    for(auto& e : tid)
    {
        threadDate* td = new threadDate("thread ", &mutex);
        ++cnt;
        td->_name += to_string(cnt);
        int n = pthread_create(&e, nullptr, getTicket, td);
    }


    //等待线程
    for(auto& e : tid)
    {
        pthread_join(e, nullptr);
    }
    //销毁锁
    pthread_spin_destroy(&mutex);

    return 0;
}

但如果临界区中有IO，就不要使用自旋锁。