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 |=
. Compound operations on shared variables must be performed atomically to prevent data races.
Noncompliant Code Example (Logical Negation)
This noncompliant code example declares a shared _Bool
flag
variable and provides a toggle_flag()
method that negates the current value of flag
.
static _Bool flag = 0; void toggle_flag() { flag = !flag; } _Bool get_flag() { return flag; }
Execution of this code may result in a data race because the value of flag
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:
Time | flag= | Thread | Action |
---|---|---|---|
1 | true | t1 | reads the current value of |
2 | true | t2 | reads the current value of |
3 | true | t1 | toggles the temporary variable in the cache to false |
4 | true | t2 | toggles the temporary variable in the different cache to false |
5 | false | t1 | writes the cache variable's value to |
6 | false | t2 | writes the different cache variable's value to |
As a result, the effect of the call by t2 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
.
static _Bool flag = 0; void toggle_flag() { flag ^= 1; } _Bool get_flag() { return 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.
static _Bool flag = 0; mtx_t flag_mutex; int result; /* initialize flag_mutex */ if ((result = mtx_init(&flag_mutex, mtx_plain)) == thrd_error) { /* handle error */ } void toggle_flag() { int result; if ((result = mtx_lock(&flag_mutex)) != thrd_success) { /* handle error */ } flag ^= 1; if ((result = mtx_unlock(&flag_mutex)) != thrd_success) { /* handle error */ } } _Bool get_flag() { int result; _Bool temp_flag; if ((result = mtx_lock(&flag_mutex)) != thrd_success) { /* handle error */ } temp_flag = flag; if ((result = mtx_unlock(&flag_mutex)) != thrd_success) { /* handle error */ } return temp_flag; }
This solution guards reads and writes to the flag
field with a lock on the 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:
Time | flag= | Thread | Action |
---|---|---|---|
1 | true | t1 | reads the current value of |
2 | true | t1 | toggles the cache variable to false |
3 | false | t1 | writes the cache variable's value to |
4 | false | t2 | reads the current value of |
5 | false | t2 | toggles the different cache variable to true |
6 | true | t2 | writes the different cache variable's value to |
The second execution order involves the same operations, but t2 starts and finishes before t1.
Noncompliant Code Example (atomic boolean)
This noncompliant code example declares flag
to be of type _Atomic _Bool
.
static _Atomic _Bool flag = 0; void toggle_flag() { _Bool temp_flag = atomic_load(&flag); temp_flag = !temp_flag; atomic_store( &flag, temp_flag); } _Bool get_flag() { return atomic_load(&flag); }
This code suffers from the same potential race condition as the first noncompliant code example.
Compliant Solution (atomic boolean)
This compliant solution declares flag
to be of type _Atomic _Bool
.
static _Atomic _Bool flag = 0; void toggle_flag() { _Bool temp_flag = atomic_load(&flag); temp_flag = !temp_flag; _bool dummy = 1; atomic_compare_exchange_strong( &flag, &dummy, temp_flag); } _Bool get_flag() { return atomic_load(&flag); }
The flag
variable is updated using the atomic_compare_exchange_strong()
method of the atomic boolean variable. All updates are visible to other threads.
Noncompliant Code Example (Addition of Primitives)
In this noncompliant code example, multiple threads can invoke the setValues()
method to set the a
and b
fields. Because this class fails to test for integer overflow, users of the Adder
class must ensure that the arguments to the setValues()
method can be added without overflow. (See rule NUM00-J. Detect or prevent integer overflow for more information.)
final class Adder { private int a; private int b; public int getSum() { return a + b; } public void setValues( int a, int b) { this .a = a; this .b = b; } } |
The getSum()
method contains a race condition. For example, when a
and b
currently have the values 0
and Integer.MAX_VALUE
, respectively, and one thread calls getSum()
while another calls setValues(Integer.MAX_VALUE, 0)
, the getSum()
method might return either 0
or Integer.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
, 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 b
are replaced with atomic integers.
final class Adder { private final AtomicInteger a = new AtomicInteger(); private final AtomicInteger b = new AtomicInteger(); public int getSum() { return a.get() + b.get(); } public void setValues( int a, int b) { this .a.set(a); this .b.set(b); } } |
The simple replacement of the two int
fields with atomic integers fails to eliminate the race condition because the compound operation a.get() + b.get()
is still non-atomic.
Compliant Solution (Addition)
This compliant solution synchronizes the setValues()
and getSum()
methods to ensure atomicity.
final class Adder { private int a; private int b; public synchronized int getSum() { // Check for overflow return a + b; } public synchronized void setValues( int a, int b) { this .a = a; this .b = b; } } |
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.
Rule | Severity | Likelihood | Remediation Cost | Priority | Level |
---|---|---|---|---|---|
VNA02-J | medium | probable | medium | P8 | L2 |
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
CWE-667. Improper locking | |
| CWE-413. Improper resource locking |
| CWE-366. Race condition within a thread |
| CWE-567. Unsynchronized access to shared data in a multithreaded context |
Bibliography
[API 2006] | Class |
Item 66. Synchronize access to shared mutable data | |
2.3, Locking | |
[JLS 2005] | |
| §17.4.5, Happens-Before Order |
| §17.4.3, Programs and Program Order |
| §17.4.8, Executions and Causality Requirements |
[Lea 2000] | Section 2.2.7, The Java Memory Model |
| Section 2.1.1.1, Objects and Locks |