#include<pthread.h>
#include<iostream>
using namespace std;

static long long total =0;
pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER;//互斥鎖

void * func(void *)
{
    long long i;
    for(i=0;i<100000000LL;i++)
    {
        pthread_mutex_lock(&m);
        total +=i;
        pthread_mutex_unlock(&m);
    }
}

int main()
{
    pthread_t thread1,thread2;
    if(pthread_create(&thread1,nullptr,&func,nullptr))
    {
        throw;
    }
    if(pthread_create(&thread2,nullptr,&func,nullptr))
    {
        throw;
    }
    pthread_join(thread1,nullptr);
    pthread_join(thread2,nullptr);
    cout<<total<<endl;//9999999900000000
}

#include<atomic>
#include<thread>
#include<iostream>
using namespace std;

atomic_llong total {0};//原子數(shù)據(jù)類型

void func(int)
{
    for(long long i=0;i<100000000LL;i++)
    {
        total+=i;
    }
}
int main()
{
    thread t1(func,0);
    thread t2(func,0);

    t1.join();
    t2.join();
    cout<<total<<endl;//9999999900000000
}

using atomic_llong = atomic<long long>;

atomic<float> af{1.2f};//正確
atomic<float> af1{af};//錯(cuò)誤,原子類型不支持拷貝語義
float f=af;//正確,調(diào)用了原子類型的接口
af=0.0;//正確,調(diào)用了原子類型的接口

atomic<int> a(2);
int b=a;
b=a.load();

operator __int_type() const noexcept
{ return load(); }

atomic<int> a;
a=1;
a.store(1);

__int_type operator=(__int_type __i) noexcept
{
store(__i);
return __i;
}

#include<thread>
#include<atomic>
#include<iostream>
#include<unistd.h>
using namespace std;
atomic_flag lock=ATOMIC_FLAG_INIT;//獲得自旋鎖
void f(int n)
{
    while(lock.test_and_set())
    {//嘗試獲得原子鎖
       cout<<"Waiting from thread "<<n<<endl;
    }
    cout<<"Thread "<<n<<" starts working"<<endl;
}
void g(int n)
{
    cout<<"Thread "<<n<<" is going to start"<<endl;
    lock.clear();//打開鎖
    cout<<"Thread "<<n<<" starts working"<<endl;
}
int main()
{
    lock.test_and_set();//關(guān)上鎖
    thread t1(f,1);
    thread t2(g,2);
    t1.join();
    usleep(100000);
    t2.join();
}

void Lock(atomic_flag & lock)
{
    while(lock.test_and_set());
}
void Unlock(atomic_flag & lock)
{
    lock.clear();
}

#include <thread>
#include <atomic>
 
atomic<int> a;
atomic<int> b;
void threadHandle()
{
     int t = 1;
     a = t;
     b = 2; // b 的賦值不依賴 a
}

#include <thread>
#include <atomic>
#include<iostream>
using namespace std;
atomic<int> a{0};
atomic<int> b{0};
void ValueSet(int )
{
     int t = 1;
     a = t;
     b = 2; // b 的賦值不依賴 a
}
int Observer(int)
{
    cout<<"("<<a<<","<<b<<")"<<endl;
}
int main()
{
    thread t1(ValueSet,0);
    thread t2(Observer,0);
    t1.join();
    t2.join();
    cout<<"Final: ("<<a<<","<<b<<")"<<endl;
}

typedef enum memory_order {
    memory_order_relaxed,    // 不對執(zhí)行順序做保證
    memory_order_acquire,    // 本線程中,所有后續(xù)的讀操作必須在本條原子操作完成后執(zhí)行
    memory_order_release,    // 本線程中,所有之前的寫操作完成后才能執(zhí)行本條原子操作
    memory_order_acq_rel,    // 同時(shí)包含 memory_order_acquire 和 memory_order_release
    memory_order_consume,    // 本線程中,所有后續(xù)的有關(guān)本原子類型的操作,必須在本條原子操作完成之后執(zhí)行
    memory_order_seq_cst    // 全部存取都按順序執(zhí)行
    } memory_order;

#include <thread>
#include <atomic>
#include<iostream>
using namespace std;
atomic<int> a{0};
atomic<int> b{0};
void ValueSet(int )
{
     int t = 1;
     a.store(t,memory_order_relaxed);
     b.store(2,memory_order_relaxed); // b 的賦值不依賴 a
}
int Observer(int)
{
    cout<<"("<<a<<","<<b<<")"<<endl;
}
int main()
{
    thread t1(ValueSet,0);
    thread t2(Observer,0);
    t1.join();
    t2.join();
    
    
    cout<<"Final: ("<<a<<","<<b<<")"<<endl;
}

#include <thread>
#include <atomic>
#include<iostream>
using namespace std;
atomic<int> a;
atomic<int> b;
void Thread1(int )
{
     int t = 1;
     a.store(t,memory_order_relaxed);
     b.store(2,memory_order_release); // 本操作前的寫操作必須先完成,即保證a的賦值快于b
}
void Thread2(int )
{
    while(b.load(memory_order_acquire)!=2);//必須等該原子操作完成后,才執(zhí)行下面代碼
    cout<<a.load(memory_order_relaxed)<<endl;//1

}
int main()
{
    thread t1(Thread1,0);
    thread t2(Thread2,0);
    t2.join();
    t1.join();
}

#include<thread>
#include<atomic>
#include<cassert>
#include<string>
using namespace std;

atomic<string*> ptr;
atomic<int> date;
void Producer()
{
    string *p=new string("hello");
    date.store(42,memory_order_relaxed);
    ptr.store(p,memory_order_release);//date賦值快于ptr
}
void Consumer()
{
    string *p2;
    while(!(p2=ptr.load(memory_order_consume)));
    assert(*p2=="hello");//一定成立
    assert(date.load(memory_order_relaxed)==42);//可能斷言失敗,因?yàn)檫@個(gè)指令可能在本線程中首先執(zhí)行
}
int main()
{
    thread t1(Producer);
    thread t2(Consumer);
    t1.join();
    t2.join();
}

#include<pthread.h>
#include<iostream>
using namespace std;

int thread_local errorCode=0;
void* MaySetErr(void *input)
{
    if(*(int*)input==1)
        errorCode=1;
    else if(*(int*)input==2)
        errorCode=2;
    else
        errorCode=0;
    cout<<errorCode<<endl;
}
int main()
{
    int input_a=1;
    int input_b=2;
    pthread_t thread1,thread2;
    pthread_create(&thread1,nullptr,&MaySetErr,&input_a);
    pthread_create(&thread2,nullptr,&MaySetErr,&input_b);
    pthread_join(thread1,nullptr);
    pthread_join(thread2,nullptr);
    cout<<errorCode<<endl;//0
}

#include<cstdlib>
#include<iostream>
using namespace std;

struct A{~A(){cout<<"Destruct A."<<endl;}};
void closeDevice(){cout<<"device is closed."<<endl;}
int main()
{
    A a;
    at_quick_exit(closeDevice);
    quick_exit(0);
}
//樣容易卡死,當(dāng)線程復(fù)雜的時(shí)候,`exit`這種正常退出方式,太過于保守了,但是`abort`這種退出方式又太激進(jìn)了,所以有一種新的退出函數(shù):`quick_exit`函數(shù)。

//這個(gè)函數(shù)不執(zhí)行析構(gòu)函數(shù),而使得程序終止,但是和`abort`不同的是,`abort`一般都是異常退出,而`quick_exit`是正常退出。
#include<cstdlib>
#include<iostream>
using namespace std;

struct A{~A(){cout<<"Destruct A."<<endl;}};
void closeDevice(){cout<<"device is closed."<<endl;}
int main()
{
    A a;
    at_quick_exit(closeDevice);
    quick_exit(0);
}