Manages a shared resource with high-concurrency read access. More...

Collaboration diagram for SharedMetaData:

Public Member Functions
void	read_data (int thread_id)
	Reads the shared data concurrently.

void	write_data (int thread_id, int new_data)
	Updates the shared data exclusively.

Detailed Description

Manages a shared resource with high-concurrency read access.

Uses std::shared_mutex to solve the Readers-Writers problem.
Readers use std::shared_lock (shared ownership).
Writers use std::unique_lock (exclusive ownership).

Definition at line 28 of file ReaderWriterLock.cpp.

Member Function Documentation

◆ read_data()

void SharedMetaData::read_data ( int thread_id )

inline

Reads the shared data concurrently.

Multiple reader threads can execute this method at the same time, provided no writer holds an exclusive lock.
Parameters

thread_id Unique identifier for the reader thread.

Definition at line 40 of file ReaderWriterLock.cpp.

                                  {
        // Acquire shared ownership
        std::shared_lock<std::shared_mutex> reader_lock(rw_mutex);
        
        {
            // Thread-safe logging for the start of the read
            std::lock_guard<std::mutex> log(log_mtx);
            std::cout << "[Reader " << thread_id << "] Reading value: " << shared_resource << std::endl;
        }
 
        // Simulate a time-consuming read operation
        std::this_thread::sleep_for(std::chrono::milliseconds(200)); 
 
        {
            // Thread-safe logging for the end of the read
            std::lock_guard<std::mutex> log(log_mtx);
            std::cout << "[Reader " << thread_id << "] Finished reading." << std::endl;
        }
    }

References log_mtx.

Referenced by main().

Here is the caller graph for this function:

◆ write_data()

void SharedMetaData::write_data	(	int	thread_id,
		int	new_data
	)

inline

Updates the shared data exclusively.

Blocks all incoming readers and waits for existing readers to finish before modifying the shared_resource.
Parameters

thread_id Unique identifier for the writer thread.

new_data The new value to store in the resource.

Definition at line 67 of file ReaderWriterLock.cpp.

                                                 {
        // Acquire exclusive ownership
        std::unique_lock<std::shared_mutex> writer_lock(rw_mutex);
 
        {
            std::lock_guard<std::mutex> log(log_mtx);
            std::cout << ">>> [Writer " << thread_id << "] Writing new value: " << new_data << " <<<" << std::endl;
        }
 
        shared_resource = new_data;     // Update the resource
        
        // Simulate a heavy write operation
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
 
        {
            std::lock_guard<std::mutex> log(log_mtx);
            std::cout << ">>> [Writer " << thread_id << "] Write complete. <<<" << std::endl;
        }
    }