kcenon::thread::policies::mutex_sync_policy Class Reference

Synchronization policy using mutex and condition variable. More...

#include <sync_policies.h>

Collaboration diagram for kcenon::thread::policies::mutex_sync_policy:

Public Types
using	policy_tag = sync_policy_tag

Public Member Functions
	mutex_sync_policy ()
	Construct mutex sync policy.
	~mutex_sync_policy ()=default
	Destructor.
	mutex_sync_policy (const mutex_sync_policy &)=delete
mutex_sync_policy &	operator= (const mutex_sync_policy &)=delete
	mutex_sync_policy (mutex_sync_policy &&)=delete
mutex_sync_policy &	operator= (mutex_sync_policy &&)=delete
auto	enqueue (std::unique_ptr< job > &&value) -> common::VoidResult
	Enqueue a job.
auto	dequeue () -> common::Result< std::unique_ptr< job > >
	Dequeue a job (blocking)
auto	try_dequeue () -> common::Result< std::unique_ptr< job > >
	Try to dequeue a job (non-blocking)
auto	empty () const -> bool
	Check if queue is empty.
auto	size () const -> std::size_t
	Get queue size (exact)
auto	clear () -> void
	Clear all jobs from queue.
auto	stop () -> void
	Stop the queue.
auto	is_stopped () const -> bool
	Check if queue is stopped.
auto	set_notify (bool notify) -> void
	Set notify flag.

Static Public Member Functions
static constexpr auto	get_capabilities () -> queue_capabilities
	Queue capabilities for mutex sync policy.

Private Attributes
std::mutex	mutex_
std::condition_variable	condition_
std::deque< std::unique_ptr< job > >	queue_
std::atomic< bool >	notify_
std::atomic< bool >	stop_

Detailed Description

Synchronization policy using mutex and condition variable.

Provides exact size/empty operations with full blocking support. Suitable for scenarios requiring accurate queue state or blocking waits.

Thread Safety

• All operations are thread-safe using mutex protection
• Supports blocking dequeue with condition variable

Performance Characteristics

• Enqueue: O(1), may block on contention
• Dequeue: O(1), may block on contention or empty queue

Definition at line 47 of file sync_policies.h.

Member Typedef Documentation

policy_tag

using kcenon::thread::policies::mutex_sync_policy::policy_tag = sync_policy_tag

Definition at line 49 of file sync_policies.h.

Constructor & Destructor Documentation

mutex_sync_policy() [1/3]

kcenon::thread::policies::mutex_sync_policy::mutex_sync_policy ( )

inline

Construct mutex sync policy.

Definition at line 69 of file sync_policies.h.

: notify_(true), stop_(false) {}

~mutex_sync_policy()

kcenon::thread::policies::mutex_sync_policy::~mutex_sync_policy ( )

default

Destructor.

mutex_sync_policy() [2/3]

kcenon::thread::policies::mutex_sync_policy::mutex_sync_policy ( const mutex_sync_policy & )

delete

mutex_sync_policy() [3/3]

kcenon::thread::policies::mutex_sync_policy::mutex_sync_policy ( mutex_sync_policy && )

delete

Member Function Documentation

clear()

auto kcenon::thread::policies::mutex_sync_policy::clear ( ) -> void

inline

Clear all jobs from queue.

Definition at line 159 of file sync_policies.h.

                         {
        std::lock_guard<std::mutex> lock(mutex_);
        queue_.clear();
    }

References mutex_, and queue_.

dequeue()

auto kcenon::thread::policies::mutex_sync_policy::dequeue ( ) -> common::Result<std::unique_ptr<job>>

inlinenodiscard

Dequeue a job (blocking)

Returns

Result containing the job or error

Definition at line 106 of file sync_policies.h.

                                                                     {
        std::unique_lock<std::mutex> lock(mutex_);
 
        condition_.wait(lock, [this] {
            return !queue_.empty() || stop_.load(std::memory_order_relaxed);
        });
 
        if (queue_.empty()) {
            return common::error_info{-121, "queue is stopped or empty", "thread_system"};
        }
 
        auto value = std::move(queue_.front());
        queue_.pop_front();
        return value;
    }

References condition_, mutex_, queue_, and stop_.

empty()

auto kcenon::thread::policies::mutex_sync_policy::empty ( ) const -> bool

inlinenodiscard

Check if queue is empty.

Returns

true if empty, false otherwise

Definition at line 142 of file sync_policies.h.

                                             {
        std::lock_guard<std::mutex> lock(mutex_);
        return queue_.empty();
    }

References mutex_, and queue_.

enqueue()

auto kcenon::thread::policies::mutex_sync_policy::enqueue ( std::unique_ptr< job > && value ) -> common::VoidResult

inlinenodiscard

Enqueue a job.

Parameters

value

Job to enqueue

Returns

VoidResult indicating success or error

Definition at line 87 of file sync_policies.h.

                                                                               {
        if (!value) {
            return common::error_info{-105, "cannot enqueue null job", "thread_system"};
        }
 
        std::lock_guard<std::mutex> lock(mutex_);
        queue_.push_back(std::move(value));
 
        if (notify_.load(std::memory_order_relaxed)) {
            condition_.notify_one();
        }
 
        return common::ok();
    }

References condition_, mutex_, notify_, and queue_.

get_capabilities()

static constexpr auto kcenon::thread::policies::mutex_sync_policy::get_capabilities ( ) -> queue_capabilities

inlinestaticnodiscardconstexpr

Queue capabilities for mutex sync policy.

Definition at line 54 of file sync_policies.h.

                                                                                 {
        return queue_capabilities{
            .exact_size = true,
            .atomic_empty_check = true,
            .lock_free = false,
            .wait_free = false,
            .supports_batch = true,
            .supports_blocking_wait = true,
            .supports_stop = true
        };
    }

Referenced by kcenon::thread::policies::adaptive_sync_policy::get_capabilities().

Here is the caller graph for this function:

is_stopped()

auto kcenon::thread::policies::mutex_sync_policy::is_stopped ( ) const -> bool

inlinenodiscard

Check if queue is stopped.

Returns

true if stopped, false otherwise

Definition at line 176 of file sync_policies.h.

                                                  {
        return stop_.load(std::memory_order_acquire);
    }

References stop_.

operator=() [1/2]

mutex_sync_policy & kcenon::thread::policies::mutex_sync_policy::operator= ( const mutex_sync_policy & )

delete

operator=() [2/2]

mutex_sync_policy & kcenon::thread::policies::mutex_sync_policy::operator= ( mutex_sync_policy && )

delete

set_notify()

auto kcenon::thread::policies::mutex_sync_policy::set_notify ( bool notify ) -> void

inline

Set notify flag.

Parameters

notify

Whether to notify on enqueue

Definition at line 184 of file sync_policies.h.

                                         {
        notify_.store(notify, std::memory_order_relaxed);
    }

References notify_.

size()

auto kcenon::thread::policies::mutex_sync_policy::size ( ) const -> std::size_t

inlinenodiscard

Get queue size (exact)

Returns

Number of jobs in queue

Definition at line 151 of file sync_policies.h.

                                                 {
        std::lock_guard<std::mutex> lock(mutex_);
        return queue_.size();
    }

References mutex_, and queue_.

stop()

auto kcenon::thread::policies::mutex_sync_policy::stop ( ) -> void

inline

Stop the queue.

Definition at line 167 of file sync_policies.h.

                        {
        stop_.store(true, std::memory_order_release);
        condition_.notify_all();
    }

References condition_, and stop_.

try_dequeue()

auto kcenon::thread::policies::mutex_sync_policy::try_dequeue ( ) -> common::Result<std::unique_ptr<job>>

inlinenodiscard

Try to dequeue a job (non-blocking)

Returns

Result containing the job or error

Definition at line 126 of file sync_policies.h.

                                                                         {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (queue_.empty()) {
            return common::error_info{-121, "queue is empty", "thread_system"};
        }
 
        auto value = std::move(queue_.front());
        queue_.pop_front();
        return value;
    }

References mutex_, and queue_.

Member Data Documentation

condition_

std::condition_variable kcenon::thread::policies::mutex_sync_policy::condition_

private

Definition at line 190 of file sync_policies.h.

Referenced by dequeue(), enqueue(), and stop().

mutex_

std::mutex kcenon::thread::policies::mutex_sync_policy::mutex_

mutableprivate

Definition at line 189 of file sync_policies.h.

Referenced by clear(), dequeue(), empty(), enqueue(), size(), and try_dequeue().

notify_

std::atomic<bool> kcenon::thread::policies::mutex_sync_policy::notify_

private

Definition at line 192 of file sync_policies.h.

Referenced by enqueue(), and set_notify().

queue_

std::deque<std::unique_ptr<job> > kcenon::thread::policies::mutex_sync_policy::queue_

private

Definition at line 191 of file sync_policies.h.

Referenced by clear(), dequeue(), empty(), enqueue(), size(), and try_dequeue().

stop_

std::atomic<bool> kcenon::thread::policies::mutex_sync_policy::stop_

private

Definition at line 193 of file sync_policies.h.

Referenced by dequeue(), is_stopped(), and stop().

---

The documentation for this class was generated from the following file:

• include/kcenon/thread/policies/sync_policies.h