Logo

Programming-Idioms

This language bar is your friend. Select your favorite languages!

Idiom #33 Atomically read and update variable

Assign to the variable x the new value f(x), making sure that no other thread may modify x between the read and the write. 

(def x (atom 0))
(def f inc)
(swap! x f)
#include <atomic>
#include <mutex>
using namespace std;
template <typename T>
struct object {
    T x;
    atomic<T*> p {&x};
    mutex m;
    object(T x) { set(x); }
    void set(T x) {
        lock_guard g {m};
        *p.load() = x;
    }
    T get() {
        lock_guard g {m};
        return *p.load();
    }
};
#include <mutex>
//declaration
auto mutex = std::mutex{};
auto x = someValue();

//use
{
	auto lock = std::unique_lock{mutex};
	x = f(x);
}

#include <atomic>
std::atomic<int> x{};

auto local_x = x.load();
while(!x.compare_exchange_strong(local_x, f(local_x))) {
	local_x = x.load();
}
private readonly object m_Sync = new object();

lock(m_Sync)
{
    x = f(x);
}
lock (x) {
  x = f(x);	
}
synchronized x = f(x);
x = f(x);
x = f(x)
integer, dimension[*] :: x

critical
  x = f(x)
end critical
import "sync"
var lock sync.Mutex

lock.Lock()
x = f(x)
lock.Unlock()
import Control.Concurrent.MVar
putMVar x . f =<< takeMVar x

let x = f(x)
synchronized(lock){
  x = f(x);
}
var object = new Object() {
    volatile int x;
};
new Thread(() -> {
    synchronized (object) {
        int x = object.x;
    }
}).start();
synchronized (object) {
    object.x = 123;
}
class Example<T> {
    volatile T x;
    Object m = new Object();
    void set(T x) {
        synchronized (m) {
            this.x = x;
        }
    }
    T get() {
        synchronized (m) {
            return x;
        }
    }
}
$mutex = Mutex::create();
Mutex::lock($mutex);
$x = f($x);
Mutex::unlock($mutex);
Mutex::destroy($mutex);
uses syncobjs;
var
  loc: TCriticalSection;
begin
  loc.Enter;
  try
    x := f(x);
  finally
    loc.Leave;
  end;
end.
use threads;
use threads::shared;
my $x :shared;
$x = 0;

sub my_task {
   my $id = shift;
   for (1 .. 5) {
      sleep 2*rand();
      { # lock scope
         lock($x);
         print "thread $id found $x\n";
         $x = $id;
         sleep 2*rand();
      }
   }
}

threads->create('my_task', $_) for 1 .. 3;
sleep 5 while threads->list(threads::running);

import threading
lock = threading.Lock()

lock.acquire()
try:
	x = f(x)
finally:
	lock.release()
import threading
with threading.Lock():
    x = f(x)

require 'atomic'
x = Atomic.new(0)
x.update { |x| f(x) }
let mut x = x.lock().unwrap();
*x = f(x);
New implementation...
< > ⌨
programming-idioms.org 
(def x (atom 0))
(def f inc)
(swap! x f)
using namespace std;
template <typename T>
struct object {
    T x;
    atomic<T*> p {&x};
    mutex m;
    object(T x) { set(x); }
    void set(T x) {
        lock_guard g {m};
        *p.load() = x;
    }
    T get() {
        lock_guard g {m};
        return *p.load();
    }
};
//declaration
auto mutex = std::mutex{};
auto x = someValue();

//use
{
	auto lock = std::unique_lock{mutex};
	x = f(x);
}

std::atomic<int> x{};

auto local_x = x.load();
while(!x.compare_exchange_strong(local_x, f(local_x))) {
	local_x = x.load();
}
private readonly object m_Sync = new object();

lock(m_Sync)
{
    x = f(x);
}
lock (x) {
  x = f(x);	
}
synchronized x = f(x);
x = f(x);
x = f(x)
integer, dimension[*] :: x

critical
  x = f(x)
end critical
var lock sync.Mutex

lock.Lock()
x = f(x)
lock.Unlock()
putMVar x . f =<< takeMVar x

let x = f(x)
synchronized(lock){
  x = f(x);
}
var object = new Object() {
    volatile int x;
};
new Thread(() -> {
    synchronized (object) {
        int x = object.x;
    }
}).start();
synchronized (object) {
    object.x = 123;
}
class Example<T> {
    volatile T x;
    Object m = new Object();
    void set(T x) {
        synchronized (m) {
            this.x = x;
        }
    }
    T get() {
        synchronized (m) {
            return x;
        }
    }
}
$mutex = Mutex::create();
Mutex::lock($mutex);
$x = f($x);
Mutex::unlock($mutex);
Mutex::destroy($mutex);
var
  loc: TCriticalSection;
begin
  loc.Enter;
  try
    x := f(x);
  finally
    loc.Leave;
  end;
end.
my $x :shared;
$x = 0;

sub my_task {
   my $id = shift;
   for (1 .. 5) {
      sleep 2*rand();
      { # lock scope
         lock($x);
         print "thread $id found $x\n";
         $x = $id;
         sleep 2*rand();
      }
   }
}

threads->create('my_task', $_) for 1 .. 3;
sleep 5 while threads->list(threads::running);

lock = threading.Lock()

lock.acquire()
try:
	x = f(x)
finally:
	lock.release()
with threading.Lock():
    x = f(x)

x = Atomic.new(0)
x.update { |x| f(x) }
let mut x = x.lock().unwrap();
*x = f(x);