"More C++ Idioms" - Wikibook Updates

More C++ Idioms/Contents

Dzejmson — Sun, 04 Jun 2023 00:28:28 GMT

add thread-safe copy on write idiom

← Older revision		Revision as of 00:28, 4 June 2023
Line 22:		Line 22:
	# [[More C++ Idioms/Copy-and-swap\|Copy-and-swap]] {{stage short\|75%\|10 August 2007}}		# [[More C++ Idioms/Copy-and-swap\|Copy-and-swap]] {{stage short\|75%\|10 August 2007}}
	# [[More C++ Idioms/Copy-on-write\|Copy-on-write]] {{stage short\|100%\|20 May 2009}}		# [[More C++ Idioms/Copy-on-write\|Copy-on-write]] {{stage short\|100%\|20 May 2009}}
			# [[More C++ Idioms/Thread-safe Copy-on-write\|Thread-safe Copy-on-write]] {{stage short\|100%\|20 May 2009}}
	# [[More C++ Idioms/Counted Body\|Intrusive reference counting (Counted Body)]] {{stage short\|75%\|16 November 2007}}		# [[More C++ Idioms/Counted Body\|Intrusive reference counting (Counted Body)]] {{stage short\|75%\|16 November 2007}}
	# [[More C++ Idioms/Covariant Return Types\|Covariant Return Types]] TODO		# [[More C++ Idioms/Covariant Return Types\|Covariant Return Types]] TODO

More C++ Idioms/Thread-safe Copy-on-write

Dzejmson — Sun, 04 Jun 2023 00:26:55 GMT

add thread safe copy on write

← Older revision		Revision as of 00:26, 4 June 2023
Line 23:		Line 23:
	// constructors...		// constructors...

			// fast access without locks
	RefPtr read() const		RefPtr read() const
	{		{
Line 28:		Line 29:
	}		}

			// overwrites current data
⚫	// with mutex it can be called by multiple threads at once
	void update(~~new_data~~ T)		void update(T new_data)
	{		{
		⚫	// with mutex it can be called by multiple threads at once
	std::lock_guard<std::mutex> lock(write_mut);		std::lock_guard<std::mutex> lock(write_mut);
	auto new_ptr = std::shared_ptr<std::string>(new T(std::move(new_data)));		auto new_ptr = std::shared_ptr<std::string>(new T(std::move(new_data)));
			std::atomic_store(&data, new_ptr);
			}

			// adds data to a existing collection
			template <typename U>
			void add_item(U new_data)
			{
			std::lock_guard<std::mutex> lock(write_mut);
			auto data_copy = *this->read();
			data_copy.insert(new_data)
			auto new_ptr = std::shared_ptr<std::string>(new T(std::move(data_copy)));
	std::atomic_store(&data, new_ptr);		std::atomic_store(&data, new_ptr);
	}		}

More C++ Idioms/Thread-safe Copy-on-write

Dzejmson — Sun, 04 Jun 2023 00:20:22 GMT

added thread safe copy on write article

New page

=<center>Thread-safe Copy-on-write</center>=
=== Intent ===
Allow concurrent access to shared objects without mutual exclusion on the fast, reading path.

=== Also Known As ===
=== Motivation ===

Many applications perform dynamic configuration changes on separate thread causing implementing changes non-trivial. This idiom is an alternative to popular mutual exclusion in situation where reads are common and writes are rare. The reading is fast and relies on always valid shared pointer and the writes first copy the object, then atomically update the pointer.

=== Solution and Sample Code ===

<syntaxhighlight lang="cpp">
#pragma once

#include <memory>
#include <atomic>
#include <thread>

template <class T>
class ThreadSafeCowPtr
{
public:
// constructors...

RefPtr read() const
{
return std::atomic_load(&data);
}

// with mutex it can be called by multiple threads at once
void update(new_data T)
{
std::lock_guard<std::mutex> lock(write_mut);
auto new_ptr = std::shared_ptr<std::string>(new T(std::move(new_data)));
std::atomic_store(&data, new_ptr);
}

private:
RefPtr m_sp;
std::mutex write_mut;
};

</syntaxhighlight>

Mutex would not be required in single consumer, single producer scenario.
=== Known Uses ===
*

=== Related Idioms ===

=== References ===
* [[wikipedia:Copy-on-write]]

{{BookCat}}

← Older revision		Revision as of 00:28, 4 June 2023
Line 22:		Line 22:
	# [[More C++ Idioms/Copy-and-swap\|Copy-and-swap]] {{stage short\|75%\|10 August 2007}}		# [[More C++ Idioms/Copy-and-swap\|Copy-and-swap]] {{stage short\|75%\|10 August 2007}}
	# [[More C++ Idioms/Copy-on-write\|Copy-on-write]] {{stage short\|100%\|20 May 2009}}		# [[More C++ Idioms/Copy-on-write\|Copy-on-write]] {{stage short\|100%\|20 May 2009}}
			# [[More C++ Idioms/Thread-safe Copy-on-write\|Thread-safe Copy-on-write]] {{stage short\|100%\|20 May 2009}}
	# [[More C++ Idioms/Counted Body\|Intrusive reference counting (Counted Body)]] {{stage short\|75%\|16 November 2007}}		# [[More C++ Idioms/Counted Body\|Intrusive reference counting (Counted Body)]] {{stage short\|75%\|16 November 2007}}
	# [[More C++ Idioms/Covariant Return Types\|Covariant Return Types]] TODO		# [[More C++ Idioms/Covariant Return Types\|Covariant Return Types]] TODO