[C言語] 基本的なマルチスレッド処理を解説

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

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

#include <stdio.h>
#include <pthread.h>
int sharedResource = 0; // 共有リソース
pthread_mutex_t mutex;  // ミューテックス
void* increment(void* arg) {
    pthread_mutex_lock(&mutex); // ミューテックスをロック
    sharedResource++;
    printf("スレッドがリソースを更新: %d\n", sharedResource);
    pthread_mutex_unlock(&mutex); // ミューテックスをアンロック
    return NULL;
}
int main() {
    pthread_t thread1, thread2;
    pthread_mutex_init(&mutex, NULL); // ミューテックスの初期化
    pthread_create(&thread1, NULL, increment, NULL);
    pthread_create(&thread2, NULL, increment, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_mutex_destroy(&mutex); // ミューテックスの破棄
    printf("最終的なリソースの値: %d\n", sharedResource);
    return 0;
}

スレッドがリソースを更新: 1
スレッドがリソースを更新: 2
最終的なリソースの値: 2

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
sem_t semaphore; // セマフォ
void* task(void* arg) {
    sem_wait(&semaphore); // セマフォを待機
    printf("スレッドがリソースを使用中\n");
    sem_post(&semaphore); // セマフォを解放
    return NULL;
}
int main() {
    pthread_t thread1, thread2;
    sem_init(&semaphore, 0, 1); // セマフォの初期化
    pthread_create(&thread1, NULL, task, NULL);
    pthread_create(&thread2, NULL, task, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    sem_destroy(&semaphore); // セマフォの破棄
    return 0;
}

スレッドがリソースを使用中
スレッドがリソースを使用中

#include <stdio.h>
#include <pthread.h>
int ready = 0; // 条件を示す変数
pthread_mutex_t mutex;
pthread_cond_t cond;
void* waitForCondition(void* arg) {
    pthread_mutex_lock(&mutex);
    while (!ready) {
        pthread_cond_wait(&cond, &mutex); // 条件変数を待機
    }
    printf("条件が満たされました\n");
    pthread_mutex_unlock(&mutex);
    return NULL;
}
void* signalCondition(void* arg) {
    pthread_mutex_lock(&mutex);
    ready = 1;
    pthread_cond_signal(&cond); // 条件変数に通知
    pthread_mutex_unlock(&mutex);
    return NULL;
}
int main() {
    pthread_t thread1, thread2;
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);
    pthread_create(&thread1, NULL, waitForCondition, NULL);
    pthread_create(&thread2, NULL, signalCondition, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

条件が満たされました

#include <stdio.h>
#include <pthread.h>
void* threadFunction(void* arg) {
    printf("スレッドが実行されています\n");
    return NULL;
}
int main() {
    pthread_t thread;
    pthread_attr_t attr;
    // スレッド属性の初期化
    pthread_attr_init(&attr);
    // スレッドをデタッチ状態に設定
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    // スレッドの生成
    pthread_create(&thread, &attr, threadFunction, NULL);
    // スレッド属性の破棄
    pthread_attr_destroy(&attr);
    printf("メインスレッドが終了します\n");
    return 0;
}

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

#include <stdio.h>
#include <pthread.h>
void* threadFunction(void* arg) {
    printf("スレッドが実行されています\n");
    return NULL;
}
int main() {
    pthread_t thread;
    // スレッドの生成
    pthread_create(&thread, NULL, threadFunction, NULL);
    // スレッドの結合
    pthread_join(thread, NULL);
    printf("メインスレッドが終了します\n");
    return 0;
}

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

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void* threadFunction(void* arg) {
    while (1) {
        printf("スレッドが実行中...\n");
        sleep(1);
    }
    return NULL;
}
int main() {
    pthread_t thread;
    // スレッドの生成
    pthread_create(&thread, NULL, threadFunction, NULL);
    // 3秒後にスレッドをキャンセル
    sleep(3);
    pthread_cancel(thread);
    // スレッドの結合
    pthread_join(thread, NULL);
    printf("メインスレッドが終了します\n");
    return 0;
}

スレッドが実行中...
スレッドが実行中...
スレッドが実行中...
メインスレッドが終了します

#include <stdio.h>
#include <pthread.h>
pthread_mutex_t resource1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t resource2 = PTHREAD_MUTEX_INITIALIZER;
void* threadFunction1(void* arg) {
    pthread_mutex_lock(&resource1);
    pthread_mutex_lock(&resource2);
    printf("スレッド1がリソースを使用中\n");
    pthread_mutex_unlock(&resource2);
    pthread_mutex_unlock(&resource1);
    return NULL;
}
void* threadFunction2(void* arg) {
    pthread_mutex_lock(&resource1);
    pthread_mutex_lock(&resource2);
    printf("スレッド2がリソースを使用中\n");
    pthread_mutex_unlock(&resource2);
    pthread_mutex_unlock(&resource1);
    return NULL;
}
int main() {
    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, threadFunction1, NULL);
    pthread_create(&thread2, NULL, threadFunction2, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    return 0;
}

スレッド1がリソースを使用中
スレッド2がリソースを使用中

#include <stdio.h>
#include <pthread.h>
int sharedCounter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* increment(void* arg) {
    for (int i = 0; i < 100000; i++) {
        pthread_mutex_lock(&mutex);
        sharedCounter++;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}
int main() {
    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, increment, NULL);
    pthread_create(&thread2, NULL, increment, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    printf("最終的なカウンターの値: %d\n", sharedCounter);
    return 0;
}

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

#include <stdio.h>
#include <pthread.h>
#define ARRAY_SIZE 1000000
#define NUM_THREADS 4
int array[ARRAY_SIZE];
long long sum = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* partialSum(void* arg) {
    int start = *(int*)arg;
    int end = start + ARRAY_SIZE / NUM_THREADS;
    long long localSum = 0;
    for (int i = start; i < end; i++) {
        localSum += array[i];
    }
    pthread_mutex_lock(&mutex);
    sum += localSum;
    pthread_mutex_unlock(&mutex);
    return NULL;
}
int main() {
    pthread_t threads[NUM_THREADS];
    int threadArgs[NUM_THREADS];
    // 配列の初期化
    for (int i = 0; i < ARRAY_SIZE; i++) {
        array[i] = 1; // すべての要素を1に設定
    }
    // スレッドの生成
    for (int i = 0; i < NUM_THREADS; i++) {
        threadArgs[i] = i * (ARRAY_SIZE / NUM_THREADS);
        pthread_create(&threads[i], NULL, partialSum, &threadArgs[i]);
    }
    // スレッドの結合
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    printf("配列の合計: %lld\n", sum);
    return 0;
}

配列の合計: 1000000

#include <stdio.h>
#include <pthread.h>
#define NUM_FILES 3
void* readFile(void* arg) {
    char* filename = (char*)arg;
    FILE* file = fopen(filename, "r");
    if (file == NULL) {
        printf("ファイルを開くことができません: %s\n", filename);
        return NULL;
    }
    char buffer[256];
    while (fgets(buffer, sizeof(buffer), file) != NULL) {
        printf("%s: %s", filename, buffer);
    }
    fclose(file);
    return NULL;
}
int main() {
    pthread_t threads[NUM_FILES];
    char* filenames[NUM_FILES] = {"file1.txt", "file2.txt", "file3.txt"};
    // スレッドの生成
    for (int i = 0; i < NUM_FILES; i++) {
        pthread_create(&threads[i], NULL, readFile, filenames[i]);
    }
    // スレッドの結合
    for (int i = 0; i < NUM_FILES; i++) {
        pthread_join(threads[i], NULL);
    }
    return 0;
}

file1.txt: ファイル1の内容
file2.txt: ファイル2の内容
file3.txt: ファイル3の内容

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <pthread.h>
#define PORT 8080
#define BUFFER_SIZE 1024
void* handleClient(void* arg) {
    int clientSocket = *(int*)arg;
    char buffer[BUFFER_SIZE];
    int bytesRead;
    while ((bytesRead = read(clientSocket, buffer, sizeof(buffer))) > 0) {
        write(clientSocket, buffer, bytesRead); // エコー
    }
    close(clientSocket);
    return NULL;
}
int main() {
    int serverSocket, clientSocket;
    struct sockaddr_in serverAddr, clientAddr;
    socklen_t addrLen = sizeof(clientAddr);
    pthread_t thread;
    serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket == -1) {
        perror("ソケットの作成に失敗しました");
        exit(EXIT_FAILURE);
    }
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    serverAddr.sin_port = htons(PORT);
    if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        perror("バインドに失敗しました");
        close(serverSocket);
        exit(EXIT_FAILURE);
    }
    if (listen(serverSocket, 5) < 0) {
        perror("リッスンに失敗しました");
        close(serverSocket);
        exit(EXIT_FAILURE);
    }
    printf("サーバーがポート%dで待機中...\n", PORT);
    while ((clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &addrLen)) >= 0) {
        pthread_create(&thread, NULL, handleClient, &clientSocket);
        pthread_detach(thread); // スレッドをデタッチ状態に設定
    }
    close(serverSocket);
    return 0;
}

サーバーがポート8080で待機中...