Hand tearing read-write lock performance test

测试代码

基本思路：
先用CountDownLatch (详见下节,Concurrency appliance) Synchronized child thread creation,然后,Press the timer once,开始测试.
再用另一个CountDownLatch Synchronized child threads to complete tasks,Finally press the timer again.

配置:
1个写线程,7个读线程.同时,Internal control read and write times,In order to easily reflect the performance of the read-write lock and the performance of the mutex lock,You can directly adjust the limit times of the inner loop.

粗略的结果：
When the number of writes is much less than the number of reads,The performance of read-write locks is higher than that of mutex locks.
When the number of writes is about the same as the number of reads,Mutex locks perform slightly better than read-write locks.

But after turning on code optimization,Only the number of writers is about two orders of magnitude less than the number of readers,The performance of read-write locks has only begun to be reflected.

CountDownLatch startLatch(1);
CountDownLatch endLatch(8);
ReadWriteLock mtx;

int g_count = 0;

void write_something() {
    
	startLatch.wait();

	int count = 1000; // thread_local
	do {
    
		WriterLockGuard lock(::mtx);
		g_count++;
	} while (--count);

	endLatch.down();
}

void read_something() {
    
	startLatch.wait();

	int count = 100000; // thread_local
	do {
    

#ifndef TEST_RWLOCK
		WriterLockGuard lock(::mtx);
#else
		ReaderLockGuard lock(::mtx);
#endif

	} while (--count);

	endLatch.down();
}

int main()
{
    	
	using namespace std::chrono;
	std::vector<std::thread> threads;

	
	for (int i = 0; i != 7; ++i) {
    
		threads.push_back(thread(read_something));
	}

	for (int i = 0; i != 1; ++i) {
    
		threads.push_back(thread(write_something));
	}

	startLatch.down();
	auto start = std::chrono::system_clock::now();

	endLatch.wait();
	auto end = std::chrono::system_clock::now();
	
	cout << (g_count == 1000) << endl;
	cout << duration_cast<milliseconds>(end - start).count() << " ms" << endl;

	for (auto &th : threads) {
    
		th.join();
	}

	return 0;
}

Read-write lock implementation code

互斥锁 + Condition variables implement read-write locks

class ReadWriteLock {
    
	std::atomic<int> nwait_;
	std::condition_variable isNotWriter_;
	std::mutex mtx_;

public:
	void reader_lock() {
    
		unique_lock<std::mutex> localGuard(mtx_);

		while (nwait_ < 0) {
    
			isNotWriter_.wait(localGuard);
		}

		nwait_++;
	}

	void reader_unlock() {
    
		lock_guard<std::mutex> localGuard(mtx_);
		
		if (--nwait_ == 0) isNotWriter_.notify_one();
	}

	void writer_lock() {
    
		unique_lock<std::mutex> localGuard(mtx_);

		while (nwait_ != 0) {
    
			isNotWriter_.wait(localGuard);
		}

		--nwait_;

		assert(nwait_ == -1);
	}

	void writer_unlock() {
    
		lock_guard<std::mutex> localGuard(mtx_);
		++nwait_;
		assert(nwait_ == 0);
		isNotWriter_.notify_all();
	}
};

Double mutexes implement read-write locks

class ReadWriteLock {
    
	int nwait_;
	std::mutex rmtx_;
	std::mutex wmtx_;

public:

	ReadWriteLock() :nwait_(0) {
    }

	void reader_lock() {
    
		lock_guard<std::mutex> localGuard(rmtx_);
		++nwait_;
		if (nwait_ == 1) wmtx_.lock();

	}

	void reader_unlock() {
    
		lock_guard<std::mutex> localGuard(rmtx_);
		--nwait_;
		if (nwait_ == 0) wmtx_.unlock();
	}

	void writer_lock() {
    
		wmtx_.lock();

	}

	void writer_unlock() {
    
		wmtx_.unlock();
	}
};

Concurrency appliance

CountDownLatch

javaCommon synchronization tools, It is usually used for sub-threads to aggregate to the main thread after all tasks are completed

class CountDownLatch {
    
	size_t count_ = 0;
	std::mutex   mtx_;
	std::condition_variable cond_;

public:
	CountDownLatch(size_t count):count_(count) {
    
		assert(count >= 1);
	}

	void down() {
    
		unique_lock<std::mutex>  localGurad(mtx_);
		if (--count_ == 0) cond_.notify_all();
	}

	void wait() {
    
		unique_lock<std::mutex>  localGurad(mtx_);
		while (count_ != 0) cond_.wait(localGurad);
	}
};

LocalGuard

Some clever useRALLMechanism for thread synchronization tools

读写锁相关

WriterLockGuard：

class WriterLockGuard {
    
	ReadWriteLock &lock_;
public:
	WriterLockGuard(ReadWriteLock& lock) :lock_(lock) {
    
		lock_.writer_lock();
	}

	~WriterLockGuard() {
    
		lock_.writer_unlock();
	}
};

ReaderLockGuard:

class ReaderLockGuard {
    
	ReadWriteLock &lock_;
public:
	ReaderLockGuard(ReadWriteLock& lock) :lock_(lock){
    
		lock_.reader_lock();
	}

	~ReaderLockGuard() {
    
		lock_.reader_unlock();
	}
};

更多参考

Readers–writer lock