C言語における「atomic_compare_exchange_strong_explicit」関数: 詳細解説


atomic_compare_exchange_strong_explicit 関数は、C言語においてスレッドセーフなメモリ更新操作を実現するための強力なツールです。この関数は、特定のメモリ位置の値を比較し、一致した場合のみ新しい値に更新します。この操作は原子操作として実行されるため、複数のスレッドが同時にこの関数を実行しても、データ競合が発生することはありません。


int atomic_compare_exchange_strong_explicit(
  volatile void *ptr,
  atomic_value_t *expected,
  atomic_value_t *desired,
  memory_order success_order,
  memory_order failure_order);


  • ptr: 更新対象のメモリ位置へのポインタ
  • expected: 比較対象の値
  • desired: 更新後の値
  • success_order: 更新成功時のメモリ順序
  • failure_order: 更新失敗時のメモリ順序


  1. 関数は、ptr が指すメモリ位置の値を expected と比較します。
  2. 一致した場合、ptr の値を desired に更新し、1 を返します。
  3. 一致しない場合、ptr の値を変更せず、0 を返します。


  • success_order: 更新成功時に、ptr の新しい値と他のスレッドが読み書きするメモリ領域との間のメモリ順序を制御します。

int counter = 0;

void increment_counter() {
  atomic_value_t expected = ATOMIC_VAR_INIT(0);
  atomic_value_t desired = ATOMIC_VAR_INIT(1);

  while (atomic_compare_exchange_strong_explicit(
      &counter, &expected, &desired,
      memory_order_release, memory_order_acquire));

  // counter は確実に 1 増えています

この例では、increment_counter 関数は counter 変数の値をスレッドセーフに1増やします。


  • atomic_compare_exchange_strong_explicit 関数は、C11規格で導入された比較的新しい関数です。古いコンパイラでは使用できない場合があります。
  • この関数は、複雑なメモリ操作に使用できますが、誤った使用はデータ競合を引き起こす可能性があります。使用前に、メモリ順序に関する知識が必要です。


  • atomic_compare_exchange_strong_explicit 関数は、x86アーキテクチャ上では cmpxchg 命令を使用して実装されています。
  • この関数は、ARMアーキテクチャ上では ldarexstrex 命令を使用して実装されています。
  • 詳細な動作は、アーキテクチャとコンパイラによって異なる場合があります。



#include <stdio.h>
#include <stdlib.h>
#include <atomic.h>

int main() {
  int counter = 0;

  // スレッド 1
  int thread1_id = 1;
  void *thread1(void *arg) {
    for (int i = 0; i < 1000; i++) {
      printf("Thread %d: counter = %d\n", thread1_id, counter);
    return NULL;

  // スレッド 2
  int thread2_id = 2;
  void *thread2(void *arg) {
    for (int i = 0; i < 1000; i++) {
      printf("Thread %d: counter = %d\n", thread2_id, counter);
    return NULL;

  // スレッドの作成と実行
  pthread_t thread1_handle, thread2_handle;
  pthread_create(&thread1_handle, NULL, thread1, NULL);
  pthread_create(&thread2_handle, NULL, thread2, NULL);

  // スレッドの終了を待機
  pthread_join(thread1_handle, NULL);
  pthread_join(thread2_handle, NULL);

  // 最終的な counter の値を出力
  printf("Final counter value: %d\n", counter);

  return 0;

このコードは、2つのスレッドが同時に counter 変数の値を1増やすことを示しています。atomic_int_inc 関数は、counter の値をスレッドセーフに1増やすために使用されます。


import threading
import time

def increment_counter(counter):
  while True:
    old_value = counter.value
    new_value = old_value + 1

    # Compare and swap the counter value
    if counter.compare_and_swap(old_value, new_value):

    # Retry if the value has changed since we read it

counter = threading.Value(0)

# Create and start threads
threads = []
for i in range(10):
  thread = threading.Thread(target=increment_counter, args=(counter,))

# Wait for all threads to finish
for thread in threads:

# Print the final counter value
print("Final counter value:", counter.value)

このコードは、10個のスレッドが同時に counter 変数の値を1増やすことを示しています。compare_and_swap メソッドは、counter の値を比較し、一致した場合のみ新しい値に更新するために使用されます。


import java.util.concurrent.atomic.AtomicInteger;

public class CounterExample {
  private static final AtomicInteger counter = new AtomicInteger(0);

  public static void main(String[] args) {
    // Create and start threads
    for (int i = 0; i < 10; i++) {
      new Thread(() -> {
        for (int j = 0; j < 100; j++) {

    // Wait for all threads to finish
    try {
    } catch (InterruptedException e) {

    // Print the final counter value
    System.out.println("Final counter value: " + counter.get());

このコードは、10個のスレッドが同時に counter 変数の値を1増やすことを示しています。AtomicInteger クラスは、スレッドセーフな整数値操作を提供します。


const { Worker } = require('worker_threads');

const counter = new SharedAtomics.Int32(0);

// Create and start workers
const workers = [];
for (let i = 0; i < 10; i++) {
  const worker = new Worker('./worker.js', { workerData: { counter } });

// Wait for all workers to finish

Sure, here are some other ways to achieve atomic compare-and-swap operations in C:

Using the __sync_bool_compare_and_swap function:

This function is part of the GNU Compiler Collection (GCC) and is available on platforms that support GCC. It works similarly to the atomic_compare_exchange_strong_explicit function but does not require the use of atomic value types.

#include <stdio.h>
#include <atomic.h>

int main() {
  int counter = 0;

  while (!__sync_bool_compare_and_swap(&counter, 0, 1)) {
    // Retry if the value has changed since we read it

  printf("Counter incremented to 1\n");

  return 0;

Using custom assembly code:

For more fine-grained control over the atomic compare-and-swap operation, you can use custom assembly code. This approach is more complex but can be more efficient and tailored to specific hardware architectures.

; Assume counter is stored in memory location 'counter_address'

mov EAX, [counter_address] ; Load current counter value into EAX
mov ECX, 0 ; Set desired value to 1 in ECX
lock cmpxchg [counter_address], ECX ; Compare and swap counter value

jz success ; Jump to 'success' label if the swap was successful
jmp retry ; Jump to 'retry' label if the swap failed

  ; The swap was successful. Continue program execution here.

  ; The swap failed. Retry the operation.

Using platform-specific libraries:

Some platforms provide their own atomic compare-and-swap functions or libraries. For example, on Windows, you can use the InterlockedCompareExchange function from the Win32 API.

#include <Windows.h>

int main() {
  LONG counter = 0;

  while (InterlockedCompareExchange(&counter, 1, 0) != 0) {
    // Retry if the value has changed since we read it

  printf("Counter incremented to 1\n");

  return 0;


  • The choice of method depends on the specific requirements of your application, the platform you are targeting, and your programming preferences.
  • Custom assembly code can offer the best performance but requires more expertise and is less portable.
  • Platform-specific libraries can provide good performance and portability but may not be available on all platforms.
  • Using standardized functions like atomic_compare_exchange_strong_explicit or __sync_bool_compare_and_swap ensures portability and compatibility with different compilers and architectures.

Additional notes:

  • Atomic compare-and-swap operations are essential for achieving thread-safe memory access in multithreaded applications.
  • Proper use of these operations can prevent data races and ensure consistent data access across threads.
  • The specific implementation details may vary depending on the programming language, platform, and compiler.

I hope this helps! Let me know if you have any other questions.




C言語とFortranには、多くの共通するキーワードがあります。以下に、いくつかの例を示します。制御構文: if else for while do endifelseforwhiledoendデータ型: integer real character logical

C言語における extern キーワードのサンプルコード

extern の役割:オブジェクトの宣言: extern は、オブジェクトの存在を宣言しますが、その定義は別のソースファイルで行います。スコープの制御: extern は、オブジェクトのスコープをファイル全体に拡張します。重複定義の防止: extern は、異なるソースファイルでオブジェクトを重複定義することを防ぎます。

typeof_unqual の代替方法:型キャスト、マクロ、C++ の std::decay

C言語における typeof_unqual キーワードは、オペランドの型を 修飾子なしの型名 で取得するために使用されます。これは、型推論やジェネリックプログラミングなどの高度なプログラミング技法を可能にする強力なツールです。typeof_unqual の役割



include ディレクティブを使いこなして、C言語プログラミングをレベルアップ

#include ディレクティブは、以下の形式で記述されます。ファイル名 には、インクルードするファイルの名前を指定します。ヘッダーファイルの種類C言語には、標準ヘッダーファイルとユーザー定義ヘッダーファイルの2種類があります。標準ヘッダーファイル: 標準ライブラリを提供するファイルです。< と > で囲んで指定します。例:<stdio

wctype 以外の文字列処理方法:標準ライブラリ、正規表現、自作関数

wctypeの役割wctypeは、ワイド文字を特定のカテゴリに分類するためのハンドルを取得します。カテゴリには、以下のようなものがあります。英数字 (alnum)文字 (alpha)空白文字 (blank)制御文字 (cntrl)数字 (digit)

複数の例外設定をまとめて取得! C言語 Numerics ライブラリの fegetexceptflag 関数


C言語で空白文字を判定:iswspace 関数

概要機能: 指定された文字が空白文字かどうかを判定ヘッダファイル: <wctype. h>プロトタイプ:引数: wc: 判定対象のワイド文字引数:wc: 判定対象のワイド文字戻り値: 空白文字の場合: 0 以外 空白文字でない場合: 0

C言語 Numerics ライブラリの威力を見よ!sqrtl 関数を使った応用例

目次sqrtl関数とは?sqrtl関数の詳細sqrtl関数の使い方sqrtl関数の注意点sqrtl関数の例題sqrtl 関数は、long double 型の引数の平方根を計算する関数です。long double 型は、double 型よりも高い精度で数値を表現することができます。