[C言語] pthreadの使い方とは？基本的なスレッド処理を解説

#include <stdio.h>
#include <pthread.h>
// スレッドが実行する関数
void* threadFunction(void* arg) {
   printf("スレッドが実行されています。\n");
   return NULL;
}
int main() {
   pthread_t thread;
   // スレッドの作成
   if (pthread_create(&thread, NULL, threadFunction, NULL) != 0) {
       printf("スレッドの作成に失敗しました。\n");
       return 1;
   }
   // メインスレッドの処理
   printf("メインスレッドが実行されています。\n");
   // スレッドの終了を待つ
   pthread_join(thread, NULL);
   return 0;
}

メインスレッドが実行されています。
スレッドが実行されています。

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
// スレッドが実行する関数
void* printMessage(void* arg) {
   char* message = (char*)arg;
   printf("スレッドメッセージ: %s\n", message);
   return NULL;
}
int main() {
   pthread_t thread;
   const char* message = "こんにちは、スレッド！";
   // スレッドの作成
   int result = pthread_create(&thread, NULL, printMessage, (void*)message);
   if (result != 0) {
       printf("スレッドの作成に失敗しました。\n");
       return 1;
   }
   // メインスレッドのメッセージ
   printf("メインスレッドメッセージ: スレッドが作成されました。\n");
   // スレッドの終了を待つ
   pthread_join(thread, NULL);
   return 0;
}

メインスレッドメッセージ: スレッドが作成されました。
スレッドメッセージ: こんにちは、スレッド！

pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 1024 * 1024); // スタックサイズを1MBに設定
pthread_create(&thread, &attr, printMessage, (void*)message);
pthread_attr_destroy(&attr); // 属性オブジェクトの破棄

int pthread_join(pthread_t thread, void **retval);

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
// スレッド1が実行する関数
void* threadFunction1(void* arg) {
   printf("スレッド1が実行されています。\n");
   sleep(2); // 2秒間待機
   printf("スレッド1が終了します。\n");
   return NULL;
}
// スレッド2が実行する関数
void* threadFunction2(void* arg) {
   printf("スレッド2が実行されています。\n");
   sleep(3); // 3秒間待機
   printf("スレッド2が終了します。\n");
   return NULL;
}
int main() {
   pthread_t thread1, thread2;
   // スレッド1の作成
   if (pthread_create(&thread1, NULL, threadFunction1, NULL) != 0) {
       printf("スレッド1の作成に失敗しました。\n");
       return 1;
   }
   // スレッド2の作成
   if (pthread_create(&thread2, NULL, threadFunction2, NULL) != 0) {
       printf("スレッド2の作成に失敗しました。\n");
       return 1;
   }
   // スレッド1の終了を待機
   pthread_join(thread1, NULL);
   // スレッド2の終了を待機
   pthread_join(thread2, NULL);
   printf("全てのスレッドが終了しました。\n");
   return 0;
}

スレッド1が実行されています。
スレッド2が実行されています。
スレッド1が終了します。
スレッド2が終了します。
全てのスレッドが終了しました。

#include <stdio.h>
#include <pthread.h>
// スレッドが実行する関数
void* detachedThread(void* arg) {
   printf("デタッチされたスレッドが実行されています。\n");
   // スレッドの処理
   return NULL;
}
int main() {
   pthread_t thread;
   // スレッドの作成
   if (pthread_create(&thread, NULL, detachedThread, NULL) != 0) {
       printf("スレッドの作成に失敗しました。\n");
       return 1;
   }
   // スレッドをデタッチ状態に設定
   pthread_detach(thread);
   printf("メインスレッドが終了します。\n");
   return 0;
}

デタッチされたスレッドが実行されています。
メインスレッドが終了します。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
// 長時間実行されるスレッド関数
void* longRunningThread(void* arg) {
   printf("長時間実行されるスレッドが開始されました。\n");
   while (1) {
       // 処理を継続
   }
   return NULL;
}
int main() {
   pthread_t thread;
   // スレッドの作成
   if (pthread_create(&thread, NULL, longRunningThread, NULL) != 0) {
       printf("スレッドの作成に失敗しました。\n");
       return 1;
   }
   // 3秒後にスレッドをキャンセル
   sleep(3);
   pthread_cancel(thread);
   printf("スレッドをキャンセルしました。\n");
   // スレッドの終了を待機
   pthread_join(thread, NULL);
   return 0;
}

長時間実行されるスレッドが開始されました。
スレッドをキャンセルしました。

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
// カウンターの共有変数
int counter = 0;
// ミューテックスの宣言と初期化
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
// スレッドが実行する関数
void* incrementCounter(void* arg) {
   for (int i = 0; i < 100000; i++) {
       // ミューテックスをロック
       pthread_mutex_lock(&counter_mutex);
       // 共有変数のインクリメント
       counter++;
       // ミューテックスをアンロック
       pthread_mutex_unlock(&counter_mutex);
   }
   return NULL;
}
int main() {
   pthread_t threads[10];
   // 10個のスレッドを作成
   for (int i = 0; i < 10; i++) {
       if (pthread_create(&threads[i], NULL, incrementCounter, NULL) != 0) {
           printf("スレッドの作成に失敗しました。\n");
           return 1;
       }
   }
   // 全てのスレッドの終了を待機
   for (int i = 0; i < 10; i++) {
       pthread_join(threads[i], NULL);
   }
   // 最終的なカウンターの値を表示
   printf("最終的なカウンターの値: %d\n", counter);
   // ミューテックスの破棄
   pthread_mutex_destroy(&counter_mutex);
   return 0;
}

最終的なカウンターの値: 1000000

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#define BUFFER_SIZE 5
// バッファ
int buffer[BUFFER_SIZE];
int count = 0;
// ミューテックスと条件変数の宣言
pthread_mutex_t buffer_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t not_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t not_empty = PTHREAD_COND_INITIALIZER;
// 生産者スレッドの関数
void* producer(void* arg) {
   for (int i = 1; i <= 10; i++) {
       // ミューテックスをロック
       pthread_mutex_lock(&buffer_mutex);
       // バッファが満杯の場合、空になるまで待機
       while (count == BUFFER_SIZE) {
           pthread_cond_wait(¬_full, &buffer_mutex);
       }
       // データをバッファに追加
       buffer[count++] = i;
       printf("生産者がデータ %d を生成しました。バッファのサイズ: %d\n", i, count);
       // 消費者に通知
       pthread_cond_signal(¬_empty);
       // ミューテックスをアンロック
       pthread_mutex_unlock(&buffer_mutex);
       sleep(1); // 生産の遅延をシミュレーション
   }
   return NULL;
}
// 消費者スレッドの関数
void* consumer(void* arg) {
   for (int i = 1; i <= 10; i++) {
       // ミューテックスをロック
       pthread_mutex_lock(&buffer_mutex);
       // バッファが空の場合、データが入るまで待機
       while (count == 0) {
           pthread_cond_wait(¬_empty, &buffer_mutex);
       }
       // データをバッファから消費
       int data = buffer[--count];
       printf("消費者がデータ %d を消費しました。バッファのサイズ: %d\n", data, count);
       // 生産者に通知
       pthread_cond_signal(¬_full);
       // ミューテックスをアンロック
       pthread_mutex_unlock(&buffer_mutex);
       sleep(2); // 消費の遅延をシミュレーション
   }
   return NULL;
}
int main() {
   pthread_t producer_thread, consumer_thread;
   // 生産者スレッドの作成
   if (pthread_create(&producer_thread, NULL, producer, NULL) != 0) {
       printf("生産者スレッドの作成に失敗しました。\n");
       return 1;
   }
   // 消費者スレッドの作成
   if (pthread_create(&consumer_thread, NULL, consumer, NULL) != 0) {
       printf("消費者スレッドの作成に失敗しました。\n");
       return 1;
   }
   // スレッドの終了を待機
   pthread_join(producer_thread, NULL);
   pthread_join(consumer_thread, NULL);
   // ミューテックスと条件変数の破棄
   pthread_mutex_destroy(&buffer_mutex);
   pthread_cond_destroy(¬_full);
   pthread_cond_destroy(¬_empty);
   printf("生産者と消費者の処理が完了しました。\n");
   return 0;
}

生産者がデータ 1 を生成しました。バッファのサイズ: 1
消費者がデータ 1 を消費しました。バッファのサイズ: 0
生産者がデータ 2 を生成しました。バッファのサイズ: 1
生産者がデータ 3 を生成しました。バッファのサイズ: 2
消費者がデータ 3 を消費しました。バッファのサイズ: 1
生産者がデータ 4 を生成しました。バッファのサイズ: 2
生産者がデータ 5 を生成しました。バッファのサイズ: 3
消費者がデータ 5 を消費しました。バッファのサイズ: 2
...
生産者と消費者の処理が完了しました。

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#define MAX_RESOURCES 3
int available_resources = MAX_RESOURCES;
// ミューテックスと条件変数の宣言
pthread_mutex_t resource_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t resource_cond = PTHREAD_COND_INITIALIZER;
// リソースを取得する関数
void acquire_resources(int thread_id) {
   pthread_mutex_lock(&resource_mutex);
   while (available_resources < 1) {
       printf("スレッド %d がリソースの解放を待っています。\n", thread_id);
       pthread_cond_wait(&resource_cond, &resource_mutex);
   }
   available_resources--;
   printf("スレッド %d がリソースを取得しました。利用可能なリソース: %d\n", thread_id, available_resources);
   pthread_mutex_unlock(&resource_mutex);
}
// リソースを解放する関数
void release_resources(int thread_id) {
   pthread_mutex_lock(&resource_mutex);
   available_resources++;
   printf("スレッド %d がリソースを解放しました。利用可能なリソース: %d\n", thread_id, available_resources);
   pthread_cond_signal(&resource_cond);
   pthread_mutex_unlock(&resource_mutex);
}
// スレッドが実行する関数
void* threadFunction(void* arg) {
   int thread_id = *(int*)arg;
   acquire_resources(thread_id);
   // リソースを使用中
   printf("スレッド %d がリソースを使用中です。\n", thread_id);
   sleep(2); // リソース使用のシミュレーション
   release_resources(thread_id);
   return NULL;
}
int main() {
   pthread_t threads[5];
   int thread_ids[5];
   // 5つのスレッドを作成
   for (int i = 0; i < 5; i++) {
       thread_ids[i] = i + 1;
       if (pthread_create(&threads[i], NULL, threadFunction, &thread_ids[i]) != 0) {
           printf("スレッド %d の作成に失敗しました。\n", i + 1);
           return 1;
       }
   }
   // 全てのスレッドの終了を待機
   for (int i = 0; i < 5; i++) {
       pthread_join(threads[i], NULL);
   }
   // ミューテックスと条件変数の破棄
   pthread_mutex_destroy(&resource_mutex);
   pthread_cond_destroy(&resource_cond);
   printf("全てのスレッドが終了しました。\n");
   return 0;
}

スレッド 1 がリソースを取得しました。利用可能なリソース: 2
スレッド 1 がリソースを使用中です。
スレッド 2 がリソースを取得しました。利用可能なリソース: 1
スレッド 2 がリソースを使用中です。
スレッド 3 がリソースを取得しました。利用可能なリソース: 0
スレッド 3 がリソースを使用中です。
スレッド 4 がリソースの解放を待っています。
スレッド 5 がリソースの解放を待っています。
スレッド 1 がリソースを解放しました。利用可能なリソース: 1
スレッド 4 がリソースを取得しました。利用可能なリソース: 0
スレッド 4 がリソースを使用中です。
スレッド 2 がリソースを解放しました。利用可能なリソース: 1
スレッド 5 がリソースを取得しました。利用可能なリソース: 0
スレッド 5 がリソースを使用中です。
スレッド 3 がリソースを解放しました。利用可能なリソース: 1
スレッド 4 がリソースを解放しました。利用可能なリソース: 2
スレッド 5 がリソースを解放しました。利用可能なリソース: 3
全てのスレッドが終了しました。

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#define ARRAY_SIZE 1000000
#define THREAD_COUNT 4
// 配列
int array[ARRAY_SIZE];
// 部分和を格納する配列
long long partial_sums[THREAD_COUNT];
// スレッドが実行する関数
void* compute_partial_sum(void* arg) {
   int thread_id = *(int*)arg;
   int start = (ARRAY_SIZE / THREAD_COUNT) * thread_id;
   int end = (thread_id == THREAD_COUNT - 1) ? ARRAY_SIZE : start + (ARRAY_SIZE / THREAD_COUNT);
   long long sum = 0;
   for (int i = start; i < end; i++) {
       sum += array[i];
   }
   partial_sums[thread_id] = sum;
   printf("スレッド %d が部分和 %lld を計算しました。\n", thread_id, sum);
   return NULL;
}
int main() {
   pthread_t threads[THREAD_COUNT];
   int thread_ids[THREAD_COUNT];
   // 配列にデータを初期化
   for (int i = 0; i < ARRAY_SIZE; i++) {
       array[i] = 1; // 各要素を1に設定
   }
   // スレッドの作成
   for (int i = 0; i < THREAD_COUNT; i++) {
       thread_ids[i] = i;
       if (pthread_create(&threads[i], NULL, compute_partial_sum, &thread_ids[i]) != 0) {
           printf("スレッド %d の作成に失敗しました。\n", i);
           return 1;
       }
   }
   // スレッドの終了を待機
   for (int i = 0; i < THREAD_COUNT; i++) {
       pthread_join(threads[i], NULL);
   }
   // 全体の和を計算
   long long total_sum = 0;
   for (int i = 0; i < THREAD_COUNT; i++) {
       total_sum += partial_sums[i];
   }
   printf("全体のカウンターの値: %lld\n", total_sum);
   return 0;
}

スレッド 0 が部分和 250000 を計算しました。
スレッド 1 が部分和 250000 を計算しました。
スレッド 2 が部分和 250000 を計算しました。
スレッド 3 が部分和 250000 を計算しました。
全体のカウンターの値: 1000000