线程同步与互斥

#include<iostream>
#include<memory>
#include<thread>
#include<atomic>	//其中包含很多原子操作
#include<vector>

using namespace std;

volatile atomic_bool isReady = false;	//volatile：防止共享变量被缓存，导致线程跑来跑去
volatile atomic_int mycount = 0;

void task() {
	while (!isReady) {
		this_thread::yield();	//出让时间片，等待下一次调用
	}

	for (int i = 0; i < 100; i++) {
		mycount++;
	}
}

int main() {
	vector<thread> tvec;
	for (int i = 0; i < 10;i++) {
		tvec.push_back(thread(task));
	}

	this_thread::sleep_for(chrono::seconds(3));
	isReady = true;

	for (thread& t : tvec) {
		t.join();
	}

	cout << mycount << endl;
	return 0;
}

class optimistic_lock(){
public:
	static optimistic_lock& instance(){
    static optimistic_lock op_lock;
    return op_lock;
	}
	
	int get_vision(){
		return vision;
	}

	void update_vision(){
		++vision;
	}
	
	bool check_vision(int vision){
		return vision == this->vision;
	}
	
private:
	int vision;	//版本号
	mutex mutex_;
	optimistic_lock(){
		vision = 0;
	}	//设置单例
}

//获取数据，也获取vision
int vision = optimistic_lock.get_vision();

//数据回写时	
//如果return false，则业务回滚
bool update_data(){
	if(optimistic_lock.check_vision(vision)){
			mutex_.lock();	//想来想去，这里还是要上个锁
			//如果不上锁，线程A在写入的过程中线程B也进来写了，怎么办？
			//但是如果这里上了锁，这个乐观锁还有什么乐观的意义？
			//晓得了，只要不写，就没锁
			
			if(optimistic_lock.check_vision(vision)){//双保险，如果在进入了上一层判断之后，线程被切出去了，会怎么样？
				//这里更新数据
				optimistic_lock.update_vision();
				mutex_.unlock();
				return true;
			}
			else{
				return false;
			}
		}
		else{
			return false;
		}
};

//只读取数据进行操作
bool only_read(){
	//vision已经是拿到的
	//读取数据
	
	if(optimistic_lock.check_vision(vision)){
		return ture;
	}
	else{
		return false;	//丢弃数据，业务回滚（这个简单，重读）
	}
}

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, 
                       const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

class RDWR_lock{
public:
	static RDWR_lock& instance(){
    static RDWR_lock rdwr_lock;
    return rdwr_lock;
	}

	void WR_lock(){
		while(lock_flag != WR_ONLY){}	//如果被加了写锁，那就阻塞在这边等着吧
	
		++write_count;
	}

	void RD_lock(){
		if(lock_flag == RD_ONLY){
			mutex_.lock();
			//可以去开始写了，写完记得解锁
		}
		else if(lock_flag == WR_ONLY){	//说明它是第一个进来等的
			mutex_.lock();
			lock_flag = RD_WAIT;
			while(write_count){}	//搁这儿等着
			lock_flag = RD_ONLY;
			//可以开始写了
			//写完状态换回去，可以解锁了
		}
		else{
			mutex_.lock();	//等着拿锁
			//回去写吧
		}
	}

	void unlock(){
		switch lock_flag{
			case WR_ONLY:
				--write_count;
			case RD_ONLY:
				lock_flag = WR_ONLY;
				mutex_.unlock();
			default:
				LOG_FATAL("unlock RDLR_lock failed in thread %p",getpid());
		}
	}
	
private:
	RDWR_lock(){
		write_count = 0;
		lock_flag = WR_ONLY;
	}
	
	int write_count;	//加读锁数量
	enum flag = {
		WR_ONLY = 1,	//只读
		RD_WAIT,			//等待写锁
		RD_ONLY			//只写
	}

	int lock_flag;
	
	mutex mutex_;
};

#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
                        const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
两者的返回值都是：若成功则返回0，否则返回错误编号

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
所有的返回值都是：若成功则返回0，否则返回错误编号

#include <pthread.h>
#include <time.h>

int pthread_mutex_timedlock( pthread_mutex_t *restrict mutex,
                             const struct timespec *restrict tsptr );

创建即加锁，作用域结束自动析构并解锁，无需手工解锁
不能中途解锁，必须等作用域结束才解锁
不能复制

#include <thread>
#include <mutex>
#include <iostream>
 
int g_i = 0;
std::mutex g_i_mutex;  // protects g_i
 
void safe_increment()
{
    const std::lock_guard<std::mutex> lock(g_i_mutex);
    ++g_i;
 
    std::cout << std::this_thread::get_id() << ": " << g_i << '\n';
 
    // g_i_mutex is automatically released when lock
    // goes out of scope
}
 
int main()
{
    std::cout << "main: " << g_i << '\n';
 
    std::thread t1(safe_increment);
    std::thread t2(safe_increment);
 
    t1.join();
    t2.join();
 
    std::cout << "main: " << g_i << '\n';
}

创建时可以不锁定（通过指定第二个参数为std::defer_lock），而在需要时再锁定
可以随时加锁解锁
作用域规则同 lock_grard，析构时自动释放锁
不可复制，可移动
条件变量需要该类型的锁作为参数（此时必须使用unique_lock）

#include <mutex>
#include <thread>
#include <chrono>
 
struct Box {
    explicit Box(int num) : num_things{num} {}
 
    int num_things;
    std::mutex m;
};
 
void transfer(Box &from, Box &to, int num)
{
    // don't actually take the locks yet
    std::unique_lock<std::mutex> lock1(from.m, std::defer_lock);
    std::unique_lock<std::mutex> lock2(to.m, std::defer_lock);
 
    // lock both unique_locks without deadlock
    std::lock(lock1, lock2);
 
    from.num_things -= num;
    to.num_things += num;
 
    // 'from.m' and 'to.m' mutexes unlocked in 'unique_lock' dtors
}
 
int main()
{
    Box acc1(100);
    Box acc2(50);
 
    std::thread t1(transfer, std::ref(acc1), std::ref(acc2), 10);
    std::thread t2(transfer, std::ref(acc2), std::ref(acc1), 5);
 
    t1.join();
    t2.join();
}

//初始化条件变量：
//本人还是喜欢静态初始化，省事儿
pthread_cont_t cont = PTHREAD_COND_INITIALIZER;

//好，再看看动态初始化
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
//参数释义：cond:用于接收初始化成功管道条件变量
//attr:通常为NULL,且被忽略

//有初始化那肯定得有销毁
int pthread_cond_destroy(pthread_cond_t *cond);

//既然说条件变量是用来等待的，那就更要看看这等待的特殊之处了
int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);  //无条件等待

int pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t mytex,const struct timespec *abstime);  //计时等待

//好，加入等待唤醒大军了，那得看看怎么去唤醒了
int pthread_cond_signal(pthread_cond_t *cptr); //唤醒一个等待该条件的线程。存在多个线程是按照其队列入队顺序唤醒其中一个
int pthread_cond_broadcast(pthread_cond_t * cptr); //广播，唤醒所哟与等待线程

以免出现唤醒丢失问题。
这里有个大神解释要不要看：https://stackoverflow.com/questions/4544234/calling-pthread-cond-signal-without-locking-mutex
做事做全套，源码也给放这儿了：https://code.woboq.org/userspace/glibc/nptl/pthread_cond_wait.c.html

在线程未获得相应的互斥锁时调用pthread_cond_signal或pthread_cond_broadcast函数可能会引起唤醒丢失问题。

唤醒丢失往往会在下面的情况下发生：

一个线程调用pthread_cond_signal或pthread_cond_broadcast函数；
另一个线程正处在测试条件变量和调用pthread_cond_wait函数之间；
没有线程正在处在阻塞等待的状态下。

//例子演示了使用Pthreads条件变量的几个函数。主程序创建了三个线程，两个线程工作，根系“count”变量。第三个线程等待count变量值达到指定的值。 

#include <pthread.h> 
#include <stdio.h> 

#define NUM_THREADS  3 
#define TCOUNT 10 
#define COUNT_LIMIT 12 

int count = 0; 
int thread_ids[3] = {0,1,2}; 
pthread_mutex_t count_mutex; 
pthread_cond_t count_threshold_cv; 

void *inc_count(void *idp)  
{ 
  int j,i; 
  double result=0.0; 
  int *my_id = idp; 
 
  for(i=0; i<TCOUNT; i++) { 
	    pthread_mutex_lock(&count_mutex); 
	    count++; 
	    /*  
	    Check the value of count and signal waiting thread when condition is 
	    reached.  Note that this occurs while mutex is locked.  
	    */ 
	    if (count == COUNT_LIMIT) { 
	        pthread_cond_signal(&count_threshold_cv); 
	        printf("inc_count(): thread %d, count = %d  Threshold reached./n",*my_id, count); 
	    } 
	    printf("inc_count(): thread %d, count = %d, unlocking mutex/n",*my_id, count); 
	    pthread_mutex_unlock(&count_mutex); 

    /* Do some work so threads can alternate on mutex lock */ 
    for (j=0; j<1000; j++) 
        result = result + (double)random(); 
    } 
  pthread_exit(NULL); 
} 

void *watch_count(void *idp)  
{ 
  int *my_id = idp;  
  printf("Starting watch_count(): thread %d/n", *my_id); 
  /* 
  Lock mutex and wait for signal.  Note that the pthread_cond_wait  
  routine will automatically and atomically unlock mutex while it waits.  
  Also, note that if COUNT_LIMIT is reached before this routine is run by 
  the waiting thread, the loop will be skipped to prevent pthread_cond_wait \
  from never returning.  
  */ 
  pthread_mutex_lock(&count_mutex); 
  if (count<COUNT_LIMIT) { 
      pthread_cond_wait(&count_threshold_cv, &count_mutex); 
      printf("watch_count(): thread %d Condition signal received./n", *my_id); 
  } 
  pthread_mutex_unlock(&count_mutex); 
  pthread_exit(NULL); 
} 

int main(int argc, char *argv[]) 
{ 
  int i, rc; 
  pthread_t threads[3]; 
  pthread_attr_t attr; 

  /* Initialize mutex and condition variable objects */ 
  pthread_mutex_init(&count_mutex, NULL); 
  pthread_cond_init (&count_threshold_cv, NULL); 

  /* For portability, explicitly create threads in a joinable state */ 
  pthread_attr_init(&attr); 
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); 
  pthread_create(&threads[0], &attr, inc_count, (void *)&thread_ids[0]); 
  pthread_create(&threads[1], &attr, inc_count, (void *)&thread_ids[1]); 
  pthread_create(&threads[2], &attr, watch_count, (void *)&thread_ids[2]); 
  
  /* Wait for all threads to complete */ 
  for (i=0; i<NUM_THREADS; i++) { 
      pthread_join(threads[i], NULL); 
  } 

  printf ("Main(): Waited on %d  threads. Done./n", NUM_THREADS);
   
  /* Clean up and exit */ 
  pthread_attr_destroy(&attr); 
  pthread_mutex_destroy(&count_mutex); 
  pthread_cond_destroy(&count_threshold_cv); 
  pthread_exit(NULL); 
} 

操作 wait() 最初称为 P（荷兰语proberen，测试）；
操作 signal() 最初称为 V（荷兰语verhogen，增加）

对信号量有4种操作(#include<semaphore.h>)：
1. 初始化（initialize），也叫做建立（create） int sem_init(sem_t *sem, int pshared, unsigned int value);
2. 等信号（wait），也可叫做挂起（suspend）int sem_wait(sem_t *sem);
3. 给信号（signal）或发信号（post） int sem_post（sem_t *sem）;
4.清理（destroy） int sem_destory(sem_t *sem);