[C言語] Pthread_createで作成したスレッドを終了させる方法

#include <pthread.h>
#include <stdio.h>
void* threadFunction(void* arg) {
    printf("スレッドが開始されました\n");
    // スレッドの処理
    pthread_exit(NULL); // スレッドを終了
}
int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, threadFunction, NULL);
    pthread_join(thread, NULL);
    return 0;
}

#include <pthread.h>
#include <stdio.h>
void* threadFunction(void* arg) {
    printf("スレッドが開始されました\n");
    // スレッドの処理
    return NULL; // スレッドを終了
}
int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, threadFunction, NULL);
    pthread_join(thread, NULL);
    return 0;
}

#include <pthread.h>
#include <stdio.h>
void* threadFunction(void* arg) {
    while (1) {
        printf("スレッドが実行中です\n");
        // スレッドの処理
    }
    return NULL;
}
int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, threadFunction, NULL);
    // スレッドを強制終了
    pthread_cancel(thread);
    pthread_join(thread, NULL);
    return 0;
}

#include <pthread.h>
#include <stdio.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 <pthread.h>
#include <stdio.h>
#include <stdlib.h>
void* threadFunction(void* arg) {
    int* data = (int*)malloc(sizeof(int) * 10); // メモリを確保
    if (data == NULL) {
        perror("メモリの確保に失敗しました");
        pthread_exit(NULL);
    }
    // スレッドの処理
    free(data); // メモリを解放
    return NULL;
}
int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, threadFunction, NULL);
    pthread_join(thread, NULL);
    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
pthread_key_t key;
void destructor(void* data) {
    free(data); // TSDを解放
}
void* threadFunction(void* arg) {
    int* data = (int*)malloc(sizeof(int));
    if (data == NULL) {
        perror("メモリの確保に失敗しました");
        pthread_exit(NULL);
    }
    *data = 42;
    pthread_setspecific(key, data);
    // スレッドの処理
    return NULL;
}
int main() {
    pthread_key_create(&key, destructor);
    pthread_t thread;
    pthread_create(&thread, NULL, threadFunction, NULL);
    pthread_join(thread, NULL);
    pthread_key_delete(key);
    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
void cleanupHandler(void* arg) {
    printf("クリーンアップ処理を実行中\n");
    free(arg); // リソースを解放
}
void* threadFunction(void* arg) {
    int* data = (int*)malloc(sizeof(int));
    if (data == NULL) {
        perror("メモリの確保に失敗しました");
        pthread_exit(NULL);
    }
    pthread_cleanup_push(cleanupHandler, data);
    // スレッドの処理
    pthread_cleanup_pop(1); // クリーンアップハンドラを実行
    return NULL;
}
int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, threadFunction, NULL);
    pthread_join(thread, NULL);
    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define THREAD_POOL_SIZE 4
void* workerFunction(void* arg) {
    int taskNumber = *(int*)arg;
    printf("タスク %d を処理中\n", taskNumber);
    sleep(1); // タスクの処理をシミュレート
    printf("タスク %d が完了しました\n", taskNumber);
    return NULL;
}
int main() {
    pthread_t threadPool[THREAD_POOL_SIZE];
    int tasks[THREAD_POOL_SIZE] = {1, 2, 3, 4};
    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_create(&threadPool[i], NULL, workerFunction, &tasks[i]);
    }
    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_join(threadPool[i], NULL);
    }
    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define NUM_THREADS 4
void* computeFunction(void* arg) {
    int threadId = *(int*)arg;
    printf("スレッド %d が計算を開始\n", threadId);
    // 計算処理をシミュレート
    for (int i = 0; i < 1000000; i++);
    printf("スレッド %d が計算を終了\n", threadId);
    return NULL;
}
int main() {
    pthread_t threads[NUM_THREADS];
    int threadIds[NUM_THREADS];
    for (int i = 0; i < NUM_THREADS; i++) {
        threadIds[i] = i;
        pthread_create(&threads[i], NULL, computeFunction, &threadIds[i]);
    }
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
void* asyncFunction(void* arg) {
    printf("非同期処理を開始\n");
    sleep(3); // 時間のかかる処理をシミュレート
    printf("非同期処理が完了\n");
    return NULL;
}
int main() {
    pthread_t asyncThread;
    pthread_create(&asyncThread, NULL, asyncFunction, NULL);
    printf("メインスレッドで他の処理を実行中\n");
    // メインスレッドの処理
    sleep(1);
    printf("メインスレッドの処理が完了\n");
    pthread_join(asyncThread, NULL);
    return 0;
}