Wolfram Language & System Documentation Center

CriticalSection

CriticalSection[var,expr]

acquires the lock var for parallel computation, evaluates expr, then releases the lock var.

CriticalSection[{var₁,var₂,…},expr]

locks all variables var_i simultaneously.

Details

At most one instance of a critical section with the same lock variable is allowed to run concurrently on any parallel kernel.
Variables used as locks should not have a value in the master kernel.
WithLock[var,expr] is equivalent to CriticalSection[var,expr].

Examples

open all close all

Basic Examples (1)

Protect a block of code from interference by other threads:

Wolfram Language code: SetSharedVariable[xs];Clear[xslock];

Wolfram Language code:

xs = 0;
ParallelDo[CriticalSection[xslock, xs = xs + 1], {10}];
xs

Without protecting access to the update code, subkernels may overwrite results:

Wolfram Language code:

xs = 0;
ParallelDo[xs = xs + 1, {10}];
xs

Scope (2)

Lock variables can be of the form sym[index]:

Wolfram Language code: ParallelTable[CriticalSection[{locks[Mod[i, 2]]}, i], {i, 10}]

Use two indexed lock variables to protect the source and destination indices of an update operation:

Wolfram Language code:

Clear[locks];size = 10; bins = ConstantArray[0, size];
SetSharedVariable[bins]

Wolfram Language code:

ParallelDo[
	With[{i = RandomInteger[{1, size - 1}]}, CriticalSection[{locks[i], locks[i + 1]}, bins[[i]]++;bins[[i + 1]]--]], {100}];
bins

Wolfram Language code: Total[%]

Applications (1)

Separate read and write operations are not thread-safe:

Wolfram Language code: n = 0;SetSharedVariable[n]

Wolfram Language code: ParallelEvaluate[n = n + 1]

Wolfram Language code: n

Use CriticalSection to make a whole code section atomic:

Wolfram Language code: n = 0;SetSharedVariable[n];Clear[nlock]

Wolfram Language code: ParallelEvaluate[CriticalSection[nlock, n = n + 1]]

Wolfram Language code: n

Properties & Relations (3)

Locks are acquired by writing the kernel's ID into the lock variable:

Wolfram Language code: Monitor[ParallelEvaluate[CriticalSection[lock, Pause[0.5];$KernelID]], lock]

Shared functions can be used for synchronization in place of a critical section:

Wolfram Language code:

mlist = {};
include[e_] := (mlist = Union[mlist, {e}];)
SetSharedFunction[include]

Wolfram Language code: ParallelDo[include[RandomInteger[10]], {10}]

Wolfram Language code: mlist

Less efficient is the use of a shared variable and critical section:

Wolfram Language code:

slist = {};SetSharedVariable[slist];
Clear[lock]

Wolfram Language code: ParallelDo[e = RandomInteger[10];CriticalSection[lock, slist = Union[slist, {e}]], {10}]

Wolfram Language code: slist

WithLock works the same way as CriticalSection does with symbols:

Wolfram Language code: SetSharedVariable[xs];

Wolfram Language code:

xs = 0;
ParallelDo[WithLock[xslock, xs = xs + 1], {10}];
xs

Possible Issues (1)

Lock variables must not have a value before being used in a critical section:

Wolfram Language code: Clear[lock]

Wolfram Language code: ParallelEvaluate[CriticalSection[lock, Print[$KernelID]]]

The deadlock that occurs when the lock variable does have a value can be broken with an abort:

Wolfram Language code: lock = 5;

Wolfram Language code: ParallelEvaluate[CriticalSection[lock, Print[$KernelID]]]

Neat Examples (1)

The dining philosophers, deadlock-free:

Wolfram Language code: rp := Pause[RandomReal[4]];

Wolfram Language code:

PrintTemporary[Dynamic[Array[forks, $KernelCount]]];
Clear[forks];forks[_] := Null;
With[{nf = $KernelCount}, 
	ParallelTable[
	With[{i1 = i, i2 = Mod[i + 1, nf, 1]}, 
	Do[Print[i, " thinking"];rp;Print[i, " hungry"];
	CriticalSection[{forks[i1], forks[i2]}, Print[i, " eating"];rp], 
	{2}]], 
	{i, nf}]];