#include <windows.h>
#include <stdio.h>
#include <stdlib.h>  
#include <string.h>
#include <time.h> 
#include <mutex> 

#define TEST 1000000 // до скольки считать

HANDLE event = NULL;
HANDLE mutex = NULL;
CRITICAL_SECTION cs;
std::mutex stdmtx;

int cnt_event = 0;
int cnt_mutex = 0;
int cnt_cs = 0;
int cnt_stdmtx = 0;

DWORD WINAPI test_event(LPVOID p)
{
	while(cnt_event < TEST) {
		WaitForSingleObject(event, INFINITE);
		cnt_event++;
		SetEvent(event);
	}
	return 0;
}

DWORD WINAPI test_mutex(LPVOID p)
{
	while(cnt_mutex < TEST) {
		WaitForSingleObject(mutex, INFINITE); 
		cnt_mutex++;
		ReleaseMutex(mutex);
	}
	return 0;
}

DWORD WINAPI test_cs(LPVOID p)
{
	while(cnt_cs < TEST) {
		EnterCriticalSection(&cs);
		cnt_cs++;
		LeaveCriticalSection(&cs);
	}
	return 0;
}

DWORD WINAPI test_stdmtx(LPVOID p)
{
	while(cnt_stdmtx < TEST) {
		stdmtx.lock();
		cnt_stdmtx++;
		stdmtx.unlock();
	}
	return 0;
}

int main(int argc, char* argv[])
{
	{
		mutex = CreateMutex(NULL, TRUE, NULL);
		HANDLE th1 = CreateThread(NULL, 0, &test_mutex, NULL, 0, NULL);
		HANDLE th2 = CreateThread(NULL, 0, &test_mutex, NULL, 0, NULL);
		clock_t start = clock();
		ReleaseMutex(mutex);
		WaitForSingleObject(th1, INFINITE);
		WaitForSingleObject(th2, INFINITE);
		printf("Mutex %d msec %d count\n", clock() - start, cnt_mutex);
		CloseHandle(mutex);
		CloseHandle(th1);
		CloseHandle(th2);
	}
	{
		event = CreateEvent(NULL, FALSE, FALSE, NULL);
		HANDLE th1 = CreateThread(NULL, 0, &test_event, NULL, 0, NULL);
		HANDLE th2 = CreateThread(NULL, 0, &test_event, NULL, 0, NULL);
		clock_t start = clock();
		SetEvent(event);
		WaitForSingleObject(th1, INFINITE);
		WaitForSingleObject(th2, INFINITE);
		printf("Event %d msec %d count\n", clock() - start, cnt_event);
		CloseHandle(event);
		CloseHandle(th1);
		CloseHandle(th2);
	}
	{
		stdmtx.lock();
		HANDLE th1 = CreateThread(NULL, 0, &test_stdmtx, NULL, 0, NULL);
		HANDLE th2 = CreateThread(NULL, 0, &test_stdmtx, NULL, 0, NULL);
		clock_t start = clock();
		stdmtx.unlock();
		WaitForSingleObject(th1, INFINITE);
		WaitForSingleObject(th2, INFINITE);
		printf("STD::Mutex %d msec %d count\n", clock() - start, cnt_stdmtx);
		CloseHandle(th1);
		CloseHandle(th2);
	}
	{
		InitializeCriticalSectionAndSpinCount(&cs, 4000);
		EnterCriticalSection(&cs);
		HANDLE th1 = CreateThread(NULL, 0, &test_cs, NULL, 0, NULL);
		HANDLE th2 = CreateThread(NULL, 0, &test_cs, NULL, 0, NULL);
		clock_t start = clock();
		LeaveCriticalSection(&cs);
		WaitForSingleObject(th1, INFINITE);
		WaitForSingleObject(th2, INFINITE);
		printf("CS %d msec %d count\n", clock() - start, cnt_cs);
		DeleteCriticalSection(&cs);
		CloseHandle(th1);
		CloseHandle(th2);
	}
	system("pause");
}

DWORD WINAPI test_cs(LPVOID p)
{
	static int th_count = 0;
	int my_num = th_count;
	th_count++;
	int cnt = 0;
	while(cnt_cs < TEST) {
		EnterCriticalSection(&cs);
		if(cnt_cs % th_count == my_num) {
			cnt_cs++;
			cnt++;
		}
		LeaveCriticalSection(&cs);
	}
	EnterCriticalSection(&cs);
	printf("local %d count\n", cnt);
	LeaveCriticalSection(&cs);

	return 0;
}

DWORD WINAPI test_cs(LPVOID p)
{
	int cnt = 0;
	while(cnt_cs < TEST) {
		EnterCriticalSection(&cs);
		cnt_cs++;
		cnt++;
		LeaveCriticalSection(&cs);
	}
	EnterCriticalSection(&cs);
	printf("local %d count\n", cnt);
	LeaveCriticalSection(&cs);
	return 0;
}

thread 2 count 1007663
thread 1 count 370236
thread 3 count 365356
No lock 4 msec 1000000 count
thread 2 count 497213
thread 1 count 251662
thread 3 count 251126
STD::Mutex 167 msec 1000001 count
thread 1 count 285231
thread 2 count 287346
thread 3 count 427424
Mutex 135 msec 1000001 count
thread 2 count 486152
thread 1 count 462504
thread 3 count 51346
Spinlock 105 msec 1000002 count
thread 3 count 400041
thread 1 count 300265
thread 2 count 299694
Semaphore 586 msec 1000000 count

#include <stdio.h>
#include <stdlib.h>  
#include <string.h>
#include <time.h> 
#include <mutex> 
#include <thread> 
#include <pthread.h>
#include <sys/time.h>
#include <semaphore.h>
#include <errno.h>
#include <stdint.h>

uint32_t now_msec()
{
	struct timeval tv_sec;
	gettimeofday(&tv_sec, NULL);
	return (uint32_t)(((tv_sec.tv_sec & 0x1FFFFF) * 1000 + (tv_sec.tv_usec / 1000)) & 0xFFFFFFFF);
}

void sleep(int msec)
{
    struct timespec t, ost;
    t.tv_sec  =  msec / 1000;
    t.tv_nsec = (msec % 1000) * 1000000;
    nanosleep (&t, NULL);
}

#define TEST 1000000
#define THREAD 3

std::mutex stdmtx;
pthread_mutex_t mutex;
pthread_spinlock_t spinlock;
sem_t sem;

volatile int cnt_nolock = -1;
int cnt_stdmtx = 0;
int cnt_mutex = 0;
int cnt_spinlock = 0;
int cnt_sem = 0;

void test_nolock(int id)
{
	while(cnt_nolock == -1);
	int cnt = 0;
	while(cnt_nolock < TEST) {
		cnt_nolock++;
		cnt++;
	}
	stdmtx.lock();
	printf("thread %d count %d\n", id, cnt);
	stdmtx.unlock();
}

void test_stdmtx(int id)
{
	int cnt = 0;
	while(cnt_stdmtx < TEST) {
		stdmtx.lock();
		cnt_stdmtx++;
		cnt++;
		stdmtx.unlock();
	}
	stdmtx.lock();
	printf("thread %d count %d\n", id, cnt);
	stdmtx.unlock();
}

void test_mutex(int id)
{
	int cnt = 0;
	while(cnt_mutex < TEST) {
		if(pthread_mutex_lock(&mutex) != 0) break;
		cnt_mutex++;
		cnt++;
		pthread_mutex_unlock(&mutex);
	}
	pthread_mutex_lock(&mutex);
	printf("thread %d count %d\n", id, cnt);
	pthread_mutex_unlock(&mutex);
}


void test_spinlock(int id)
{
	int cnt = 0;
	while(cnt_spinlock < TEST) {
		if(pthread_spin_lock(&spinlock) != 0) break;
		cnt_spinlock++;
		cnt++;
		pthread_spin_unlock(&spinlock);
	}
	pthread_spin_lock(&spinlock);
	printf("thread %d count %d\n", id, cnt);
	pthread_spin_unlock(&spinlock);
}

void test_sem(int id)
{
	int cnt = 0;
	while(cnt_sem < TEST) {
		if(sem_wait(&sem) != 0) break;
		cnt_sem++;
		cnt++;
		sem_post(&sem);
	}
	sem_wait(&sem);
	printf("thread %d count %d\n", id, cnt);
	sem_post(&sem);
}

int main(int argc, char* argv[])
{
	if(1){
		std::thread th[THREAD];
		for(int i = 0; i < THREAD; i++) th[i] = std::thread(test_nolock, i+1);
		sleep(100);
		int start = now_msec();
		cnt_nolock = 0;
		for(int i = 0; i < THREAD; i++) th[i].join();
		printf("No lock %d msec %d count\n", now_msec() - start, cnt_nolock);
	}
	if(1){
		stdmtx.lock();
		std::thread th[THREAD];
		for(int i = 0; i < THREAD; i++) th[i] = std::thread(test_stdmtx, i+1);
		sleep(1000);
		int start = now_msec();
		stdmtx.unlock();
		for(int i = 0; i < THREAD; i++) th[i].join();
		printf("STD::Mutex %d msec %d count\n", now_msec() - start, cnt_stdmtx);
	}
	if(1){
		pthread_mutex_init(&mutex, NULL);
		pthread_mutex_lock(&mutex);
		std::thread th[THREAD];
		for(int i = 0; i < THREAD; i++) th[i] = std::thread(test_mutex, i+1);
		sleep(1000);
		int start = now_msec();
		pthread_mutex_unlock(&mutex);
		for(int i = 0; i < THREAD; i++) th[i].join();
		printf("Mutex %d msec %d count\n", now_msec() - start, cnt_mutex);
		pthread_mutex_destroy(&mutex);
	}
	if(1){
		pthread_spin_init(&spinlock, PTHREAD_PROCESS_PRIVATE);
		pthread_spin_lock(&spinlock);
		std::thread th[THREAD];
		for(int i = 0; i < THREAD; i++) th[i] = std::thread(test_spinlock, i+1);
		sleep(1000);
		int start = now_msec();
		pthread_spin_unlock(&spinlock);
		for(int i = 0; i < THREAD; i++) th[i].join();
		printf("Spinlock %d msec %d count\n", now_msec() - start, cnt_spinlock);
		pthread_spin_destroy(&spinlock);
	}
	if(1){
		sem_init(&sem, 0, 1);
		sem_wait(&sem);
		std::thread th[THREAD];
		for(int i = 0; i < THREAD; i++) th[i] = std::thread(test_sem, i+1);
		sleep(1000);
		int start = now_msec();
		sem_post(&sem);
		for(int i = 0; i < THREAD; i++) th[i].join();
		printf("Semaphore %d msec %d count\n", now_msec() - start, cnt_sem);
		sem_destroy(&sem);
	}
}

thread 1 count 999743
thread 3 count 311464
thread 2 count 334119
No lock 2 msec 1000001 count

thread 1 count 308920
thread 2 count 299365
thread 3 count 391717
STD::Mutex 86 msec 1000002 count

thread 3 count 321740
thread 2 count 380536
thread 1 count 297725
Mutex 83 msec 1000001 count

thread 3 count 998849
thread 1 count 706
thread 2 count 447
Spinlock 79 msec 1000002 count

thread 1 count 288612
thread 2 count 460147
thread 3 count 251242
Semaphore 116 msec 1000001 count