CustomRWLock.cpp File Reference

Manual implementation of a Readers-Writers Lock with Writer Preference. More...

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <chrono>

Include dependency graph for CustomRWLock.cpp:

Go to the source code of this file.

Classes
class	RWLock
	A custom synchronization primitive for the Readers-Writers problem. More...

Functions
void	readerTask (RWLock *rw, int id)
	Simulates a reader's lifecycle.
void	writerTask (RWLock *rw, int id)
	Simulates a writer's lifecycle.
int	main (void)
	Entry point for the custom RWLock demonstration. Creates a mix of reader and writer threads to demonstrate starvation protection.

Variables
std::mutex	log_mtx
	Global mutex to prevent console output interleaving. Standard output is not thread-safe; this ensures log messages remain legible.

Detailed Description

Manual implementation of a Readers-Writers Lock with Writer Preference.

• Unlike std::shared_mutex, this implementation explicitly tracks waiting writers to prevent "Reader Starvation," ensuring writers aren't blocked forever by a continuous stream of concurrent readers.

Definition in file CustomRWLock.cpp.

Function Documentation

main()

int main

(

void

)

Entry point for the custom RWLock demonstration. Creates a mix of reader and writer threads to demonstrate starvation protection.

Definition at line 144 of file CustomRWLock.cpp.

               {
    RWLock rw;
    std::vector<std::thread> threads;
 
    for(int i=1; i<=50; i++) {
        threads.emplace_back(readerTask, &rw, i);
    }
 
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    
    for(int i=1; i<=2; i++) {
        threads.emplace_back(writerTask, &rw, i);
    }
    
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    
    for(int i=1001; i<=1100; i++) {
        threads.emplace_back(readerTask, &rw, i);
    }
 
    for(auto& t : threads) {
        if(t.joinable())
            t.join();
    }
 
    std::cout << "All metadata operations completed." << std::endl;
    return 0;
}

References readerTask(), and writerTask().

Here is the call graph for this function:

readerTask()

void readerTask	(	RWLock *	rw,
		int	id
	)

Simulates a reader's lifecycle.

Parameters

rw	Pointer to the shared RWLock instance.
id	Unique identifier for the reader thread.

Definition at line 101 of file CustomRWLock.cpp.

                                    {
    rw->lock_read();
    {
        std::lock_guard<std::mutex> log_lock(log_mtx);
        std::cout << "[Reader " << id << "] Start Reading..." << std::endl;
    }
 
    std::this_thread::sleep_for(std::chrono::milliseconds(200));
 
    {
        std::lock_guard<std::mutex> log_lock(log_mtx);
        std::cout << "[Reader " << id << "] Finished Reading." << std::endl;
    }
    rw->unlock_read();
}

References RWLock::lock_read(), log_mtx, and RWLock::unlock_read().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

writerTask()

void writerTask	(	RWLock *	rw,
		int	id
	)

Simulates a writer's lifecycle.

Parameters

rw	Pointer to the shared RWLock instance.
id	Unique identifier for the writer thread.

Definition at line 122 of file CustomRWLock.cpp.

                                    {
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
 
    rw->lock_write();
    {
        std::lock_guard<std::mutex> log_lock(log_mtx);
        std::cout << ">>> [Writer " << id << "] EXCLUSIVE WRITE START <<<" << std::endl;
    }
    
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
 
    {
        std::lock_guard<std::mutex> log_lock(log_mtx);
        std::cout << ">>> [Writer " << id << "] EXCLUSIVE WRITE END <<<" << std::endl;
    }
    rw->unlock_write();
}

References RWLock::lock_write(), log_mtx, and RWLock::unlock_write().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

log_mtx

std::mutex log_mtx

Global mutex to prevent console output interleaving. Standard output is not thread-safe; this ensures log messages remain legible.

Definition at line 19 of file CustomRWLock.cpp.

Referenced by readerTask(), and writerTask().