instructions ● std::atomic - provides load / store / compare_exchange ● std::atomic::is_always_lock_free ● Load and Store of aligned 8 bytes ● CAS ( old-expected, new-value ) - atomic Compare And std::atomic - atomic access not interrupted, if T is too large the std::atomic<> will use internal lock to provide atomic access to type T. if T is small enough and the atomic<> implementation supports

reliable sources such as Boost.Lockfree? ● Writing such a fifo is a fairly gentle introduction to lock free programming. ● There are some interesting performance optimizations that can be made. ● You net/home/lock-free-algorithms/queues/unbounded-spsc-queue https://www.dpdk.org/ 3● Single producer: one producer (aka writer) thread ● Single consumer: one consumer (aka reader) thread ● Lock-free: it were connected end-to-end. The oldest entry is processed first. 4 Single Producer Single Consumer Lock-Free Wait-Free Fifo5 Read message from network Handle message Write response to network

Deferred reclamation, i.e., garbage collection in C++ Some assumed knowledge • You’ve heard of lock-free programming and know what a compare_exchange is • You know roughly what atomic does and what Deferred reclamation, i.e., garbage collection in C++ Some assumed knowledge • You’ve heard of lock-free programming and know what a compare_exchange is • You know roughly what atomic does and what danielanderson.net Why is this important?8 Daniel Anderson -- danielanderson.net Why is this important?9 Lock-freedom Daniel Anderson -- danielanderson.net10 Daniel Anderson -- danielanderson.net std::shared_ptr11

net3 What we’ll learn today • Very quick review of concurrency and lock-free programming • Review the “bread and butter” of lock-free design patterns • Define wait-free algorithms, understand the definition • You’ve heard of lock-free programming and know what a compare_exchange is Daniel Anderson -- danielanderson.net4 Our motivating problem • Required by std::weak_ptr::lock • Also, very useful std::lock_guard g_{m}; if (counter > 0) { counter++; return true; } return false; } bool decrement() { std::lock_guard g_{m};

std::for_each(std::execution::par, v.begin(), v.end(), [&sum, &mtx](std::int64_t x){ std::scoped_lock lock(mtx); sum += x; }); Loops to algorithms https://godbolt.org/z/on4KoejqxCppCon std::for_each(std::execution::par, v.begin(), v.end(), [&sum, &mtx](std::int64_t x){ std::scoped_lock lock(mtx); sum += x; }); Loops to algorithms Abysmal performance! Don’t do this! Only one thread at a time can lock or acquire the mutexCppCon 2023 75 David Olsen - Back to Basics: Concurrency MUTEXES An airplane lavatory Anyone can go in and lock the door Has exclusive use of

content, _ := repl.Str() fmt.Println(content) // "PONG" } 连接服务器器 执⾏行行命令并获取回复 将回复转换为字符串串 锁 lock 锁 锁是⼀一种同步机制， 它可以保证⼀一项资源在任何时候只能被⼀一个进程使⽤用， 如果有其他进程想要 使⽤用相同的资源， 那么它们就必须等待， 直到正在使⽤用资源的进程放弃使⽤用权为⽌止。 锁未被获取，程序可以通过为其设置值来获取锁。 键 “LOCK_KEY” 值 nil 未 加 锁 ⽅方法⼀一 —— 使⽤用字符串串 将⼀一个字符串串键⽤用作锁，如果这个键有值，那么说明锁已被获取；反之，如果键没有值，那么说明 锁未被获取，程序可以通过为其设置值来获取锁。 键 “LOCK_KEY” 值 nil 键 “LOCK_KEY” 值 “LOCKING” 未 加 锁 已 ，如果键已经有值，那么默认使⽤用新值去覆盖旧值 DEL key 实现代码 const lock_key = "LOCK_KEY" const lock_value = "LOCK_VALUE" func acquire(client *redis.Client) bool { current_value, _ := client.Cmd("GET", lock_key).Str() if current_value

：上锁，防止多个线程同时进入某一代码段 • 调用 std::mutex 的 lock() 时，会检测 mutex 是否已经上锁。 • 如果没有锁定，则对 mutex 进行上锁。 • 如果已经锁定，则陷入等待，直到 mutex 被 另一个线程解锁后，才再次上锁。 • 而调用 unlock() 则会进行解锁操作。 • 这样，就可以保证 mtx.lock() 和 mtx.unlock() 之间的代码段，同一时间只有一个线程在执行 同学在用了， B 同学就不能进去，要等 A 同学用完了才能进 去。 std::lock_guard ：符合 RAII 思想的上锁和解锁 • 根据 RAII 思想，可将锁的持有视为资源 ，上锁视为锁的获取，解锁视为锁的释放 。 • std::lock_guard 就是这样一个工具类，他 的构造函数里会调用 mtx.lock() ，解构函 数会调用 mtx.unlock() 。从而退出函数作 用域时能够自动解锁，避免程序员粗心不 用域时能够自动解锁，避免程序员粗心不 小心忘记解锁。 std::unique_lock ：也符合 RAII 思想，但自由度更高 • std::lock_guard 严格在解构时 unlock() ，但是 有时候我们会希望提前 unlock() 。这时可以用 std::unique_lock ，他额外存储了一个 flag 表 示是否已经被释放。他会在解构检测这个 flag ，如果没有释放，则调用

n reading and writing to shared-ValueSolving a Data Race ● Fixing Data Races ○ We can use a ‘lock’ to protect data, so that only one thread at a time can thus access the memory. ○ In C++, we have of code. ○ Thus, the operation is ‘atomic’ in the sense that only 1 operation can happen while the lock is held. ○ Analogy: ■ Think about having exactly 1 key to your home, and you always carry the key the house. ■ When the person enters, they lock the door ■ When the person leaves, they can pass on the key to someone else to enter, who will also lock the door when they enter. 75std::mutex (1/2)

jbonofre jbonofre 4096 Dec 3 13:02 lib -rw-r--r-- 1 jbonofre jbonofre 0 Dec 3 13:02 lock drwxr-xr-x 1 jbonofre jbonofre 4096 Dec 3 12:51 system lftp karaf@localhost:/> Apache Maven logging . Standard Java logging is used initially by the Main class and org.apache.karaf.main.lock.Lock implementations. In order to configure the logging level, please set the system property karaf solution. Karaf provides failover capability using either a simple lock file or a JDBC locking mechanism. In both cases, a container-level lock system allows bundles to be preloaded into the slave Karaf instance

O’Dwyer 2020-09-18Outline ● What is a data race and how do we fix it? [3–12] ● C++11 mutex and RAII lock types [13–23] Questions? ● condition_variable [24–28] ● Static initialization and once_flag to solve the problem is std::mutex. std::mutex mtx; mtx.lock(); std::thread threadB = std::thread([&](){ mtx.lock(); mtx.unlock(); printf("Hello from B\n"); }); printf("Hello coffeeshop bathroom key. When Alice holds the key, Bob can’t enter (and vice versa). mutex’s .lock() method “acquires” the bathroom key (waiting in line for it, if necessary). The .unlock() method