Page History

Compound operations are operations that consist of more than one discrete operation. Expressions that include postfix or prefix increment (++), postfix or prefix decrement (--), or compound assignment operators always result in compound operations. Compound assignment expressions use operators such as *=, /=, %=, +=, -=, <<=, >>=, ^= and , and |=. Compound operations on shared variables must be performed atomically to prevent data races.

Noncompliant Code Example (Logical Negation)

#include <stdbool.h>
 
static 

bool flag = 

false;
 
void toggle_flag(void) {
  flag = !flag;
}
 

bool get_flag(void) {
  return flag;
}

Execution of this code may result in a data race because because the value of of flag is is read, negated, and written back.

Consider, for example, two threads that call toggle_flag(). The expected effect of toggling flag twice is that it is restored to its original value. However, the following scenario leaves flag in the incorrect state:

As a result, the effect of the call by t ₂ is not reflected in flag; the program behaves as if toggle_flag() was called only once, not twice.

Noncompliant Code Example (Bitwise Negation)

The toggle_flag() method may also use the compound assignment operator ^= to negate the current value of flag.

Compliant Solution (Mutex)

This compliant solution restricts access to flag under a mutex lock:

#include <threads.h>
#include <stdbool.h>
 
static 

bool flag = false;
mtx_t flag_mutex;

/* Initialize flag_mutex */
bool init_mutex(int type) {
  /* Check mutex type */
  if (thrd_success != mtx_init(&flag_mutex, type)) {
    return false;  /* Report error */
  }
  return true;
}
 
void toggle_flag(void) {
  if (thrd_success != mtx_lock(&flag_mutex)) {
    /* Handle error */
  }
  flag 

= 

!flag;
  if (thrd_success != mtx_unlock(&flag_mutex)) {
    /* Handle error */
  }
}
 
bool get_flag(void) {
  

bool temp_flag;

This code is also not thread-safe. A data race exists because ^= is a nonatomic compound operation.

Compliant Solution (Mutex)

This compliant solution restricts access to flag under a mutex lock.

  if (thrd_success != mtx_lock(&flag_mutex)) {
    /* Handle error */
  }
  temp_flag = flag;
  if (thrd_success != mtx_unlock(&flag_mutex)) {
    /* Handle error */
  }
  return temp_flag;
}

This solution guards reads and writes to the the flag field field with a lock on the instance, that is, this. Furthermore, synchronization flag_mutex. This lock ensures that changes to flag are visible to all threads. Now, only two execution orders are possible, one of which is shown in the following scenario. In one execution order, t₁ obtains the mutex and completes the operation before t ₂ can acquire the mutex, as shown here:

The second other execution order involves the same operations, but is similar, except that t ₂ starts and finishes before t ₁. 
Compliance with rule LCK00-J. Use private final lock objects to synchronize classes that may interact with untrusted code can reduce the likelihood of misuse by ensuring that untrusted callers cannot access the lock object. 

Compliant Solution (

atomic_compare_exchange_weak() )

This compliant solution uses atomic variables and a compare-and-exchange operation to guarantee that the correct value is stored in flag. All updates are visible to other threads.

#include <stdatomic.h>
#include <stdbool.h>
 
static atomic_bool flag;

void init_flag(void) {
  atomic_init(&flag, false);
}
void toggle_flag(void) {
  bool old_flag = atomic_load(&flag);
  bool new_flag;
  do {
    new_flag = !old_flag;
  } while (!atomic_compare_exchange_weak(&flag, &old_flag, new_flag));
}
  
bool get_flag(void) {
  return atomic_load(&flag);
}

An alternative solution is to use the atomic_flag data type for managing Boolean values atomically

In this compliant solution, the getFlag() method is not synchronized, and flag is declared as volatile. This solution is compliant because the read of flag in thegetFlag() method is an atomic operation and the volatile qualification assures visibility. The toggle() method still requires synchronization because it performs a nonatomic operation.

This approach must not be used for getter methods that perform any additional operations other than returning the value of a volatile field without use of synchronization. Unless read performance is critical, this technique may lack significant advantages over synchronization [Goetz 2006].

Compliant Solution (Read-Write Lock)

This compliant solution uses a read-write lock to ensure atomicity and visibility.

Read-write locks allow shared state to be accessed by multiple readers or a single writer but never both. According to Goetz [Goetz 2006]

In practice, read-write locks can improve performance for frequently accessed read-mostly data structures on multiprocessor systems; under other conditions they perform slightly worse than exclusive locks due to their greater complexity.

Profiling the application can determine the suitability of read-write locks.

Compliant Solution (AtomicBoolean)

This compliant solution declares flag to be of type AtomicBoolean.

The flag variable is updated using the compareAndSet() method of the AtomicBoolean class. All updates are visible to other threads.

Noncompliant Code Example (Addition of Primitives)

In this noncompliant code example, multiple threads can invoke the setValuesset_values() method to set the a and b fields. Because this class code fails to test for integer overflow, users of the Adder class must this code must also ensure that the arguments to the setValuesset_values() method can be added without overflow . (See rule NUM00-J. Detect or prevent integer see INT32-C. Ensure that operations on signed integers do not result in overflow for more information.)

).

static int a;
static int b;
 
int get_sum(void) {
  return a + b;
}
 
void set_values(int new_a, int new_b) {
  a = new_a;
  b = new_b;
}

The  get_sumThe getSum() method contains a race condition. For example, when a and b currently have the values 0 and Integer.MAX_VALUE and INT_MAX, respectively, and one thread calls getSumget_sum() while another calls setValues(Integer.MAX_VALUEset_values(INT_MAX, 0), the getSumget_sum() method might return either 0 or Integer.INT_MAX_VALUE, or it might overflow. Overflow will occur when the first thread reads a and b after the second thread has set the value of a to Integer.MAX_VALUE, INT_MAX but before it has set the value of b to 0.

Note that declaring the variables as volatile fails to resolve the issue because these compound operations involve reads and writes of multiple variables.

Noncompliant Code Example (Addition of Atomic Integers)

In this noncompliant code example,  a and  and b are are replaced with atomic integers.

#include <stdatomic.h>

static atomic_int a;
static atomic_int b;

void init_ab(void) {
  atomic_init(&a, 0);
  atomic_init(&b, 0);
}

int get_sum(void) {
  return atomic_load(&a) + atomic_load(&b);
}
 
void set_values(int new_a, int new_b) {
  atomic_store(&a, new_a);
  atomic_store(&b, new_b);
}

Compliant Solution (_Atomic struct)

This compliant solution uses an atomic struct, which guarantees that both numbers are read and written together.

#include <stdatomic.h>
  
static _Atomic struct ab_s {
  int a, b;
} ab;
 
void init_ab(void) {
  struct ab_s new_ab = {0, 0};
  atomic_init(&ab, new_ab);
}
 
int get_sum(void) {
  struct ab_s new_ab = atomic_load(&ab);
  return new_ab.a + new_ab.b;
}
 
void set_values(int new_a, int new_b) {
  struct ab_s new_ab = {new_a, new_b};
  atomic_store(&ab, new_ab);
}

On most modern platforms, this will compile to be lock-free.

Compliant Solution (

Mutex)

This compliant solution synchronizes the setValues() and getSum() methods to ensure atomicity.

protects the set_values() and get_sum() methods with a mutex to ensure atomicity:

#include <threads.h>
#include <stdbool.h>

static int a;
static int b;
mtx_t flag_mutex;

/* Initialize everything */
bool init_all(int type) {
  /* Check mutex type */
  a = 0;
  b = 0;
  if (thrd_success != mtx_init(&flag_mutex, type)) {
    return false;  /* Report error */
  }
  return true;
}
 
int get_sum(void) {
  if (thrd_success != mtx_lock(&flag_mutex)) {
    /* Handle error */
  }
  int sum = a + b;
  if (thrd_success != mtx_unlock(&flag_mutex)) {
    /* Handle error */
  }
  return sum;
}
 
void set_values(int new_a, int new_b) {
  if (thrd_success != mtx_lock(&flag_mutex)) {
    /* Handle error */
  }
  a = new_a;
  b = new_b;
  if (thrd_success != mtx_unlock(&flag_mutex)) {
    /* Handle error */
  }
}

Thanks to the mutex, it is now possible to add overflow checking to the get_sum()  function The operations within the synchronized methods are now atomic with respect to other synchronized methods that lock on that object's monitor (that is, it's intrinsic lock). It is now possible, for example, to add overflow checking to the synchronized getSum() method without introducing the possibility of a race condition.

Risk Assessment

When operations on shared variables are not atomic, unexpected results can be produced. For example, information can be disclosed inadvertently because one user can receive information about other users.

Automated Detection

Some available static analysis tools can detect the instances of nonatomic update of a concurrently shared value. The result of the update is determined by the interleaving of thread execution. These tools can detect the instances where thread-shared data is accessed without holding an appropriate lock, possibly causing a race condition.

Related Guidelines

Tool	Version	Checker	Description
CodeSonar	Include Page CodeSonar_V CodeSonar_V	CONCURRENCY.DATARACE	Data Race

Related Guidelines

Bibliography

Bibliography

Image Added   Image Added   Image Added Image Removed      Image Removed      Image Removed