• Java

var object = new Object() {
    volatile int x;
};
new Thread(() -> {
    synchronized (object) {
        int x = object.x;
    }
}).start();
synchronized (object) {
    object.x = 123;
}

• Java

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;
        }
    }
}

• Java

synchronized(lock){
  x = f(x);
}

• Clojure

(def x (atom 0))
(def f inc)
(swap! x f)

• C++

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();
    }
};

• C++

std::atomic<int> x{};

auto local_x = x.load();
while(!x.compare_exchange_strong(local_x, f(local_x))) {
	local_x = x.load();
}

• C++

//declaration
auto mutex = std::mutex{};
auto x = someValue();

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

• C#

lock (x) {
  x = f(x);	
}

• C#

private readonly object m_Sync = new object();

lock(m_Sync)
{
    x = f(x);
}

• D

synchronized x = f(x);

• Dart

x = f(x);

• Fortran

x = f(x)

• Fortran

integer, dimension[*] :: x

critical
  x = f(x)
end critical

• Go

var lock sync.Mutex

lock.Lock()
x = f(x)
lock.Unlock()

• Haskell

putMVar x . f =<< takeMVar x

• JS

let x = f(x)

• PHP

$mutex = Mutex::create();
Mutex::lock($mutex);
$x = f($x);
Mutex::unlock($mutex);
Mutex::destroy($mutex);

• Pascal

var
  loc: TCriticalSection;
begin
  loc.Enter;
  try
    x := f(x);
  finally
    loc.Leave;
  end;
end.

• Perl

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);

• Python

with threading.Lock():
    x = f(x)

• Python

lock = threading.Lock()

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

• Ruby

x = Atomic.new(0)
x.update { |x| f(x) }

• Rust

let mut x = x.lock().unwrap();
*x = f(x);