linux 多线程 主线程

#include <pthread.h>
#include <stdio.h>

int shared_data = 0;
pthread_mutex_t mutex;

void* thread_func(void* arg) {
    pthread_mutex_lock(&mutex);
    shared_data++;
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t threads[10];
    pthread_mutex_init(&mutex, NULL);

    for (int i = 0; i < 10; i++) {
        pthread_create(&threads[i], NULL, thread_func, NULL);
    }

    for (int i = 0; i < 10; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("Shared data: %d\n", shared_data);
    pthread_mutex_destroy(&mutex);
    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;

void* thread1_func(void* arg) {
    pthread_mutex_lock(&mutex1);
    sleep(1);
    pthread_mutex_lock(&mutex2);
    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
    return NULL;
}

void* thread2_func(void* arg) {
    pthread_mutex_lock(&mutex2);
    sleep(1);
    pthread_mutex_lock(&mutex1);
    pthread_mutex_unlock(&mutex1);
    pthread_mutex_unlock(&mutex2);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    pthread_create(&thread1, NULL, thread1_func, NULL);
    pthread_create(&thread2, NULL, thread2_func, NULL);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define MAX_THREADS 5

typedef struct {
    void (*func)(void*);
    void* arg;
} Task;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
Task task_queue[MAX_THREADS];
int task_count = 0;

void* worker_thread(void* arg) {
    while (1) {
        pthread_mutex_lock(&mutex);
        while (task_count == 0) {
            pthread_cond_wait(&cond, &mutex);
        }
        Task task = task_queue[--task_count];
        pthread_mutex_unlock(&mutex);

        task.func(task.arg);
    }
    return NULL;
}

void add_task(void (*func)(void*), void* arg) {
    pthread_mutex_lock(&mutex);
    task_queue[task_count].func = func;
    task_queue[task_count].arg = arg;
    task_count++;
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);
}

void example_task(void* arg) {
    int* num = (int*)arg;
    printf("Task %d executed\n", *num);
}

int main() {
    pthread_t threads[MAX_THREADS];

    for (int i = 0; i < MAX_THREADS; i++) {
        pthread_create(&threads[i], NULL, worker_thread, NULL);
    }

    for (int i = 0; i < 10; i++) {
        int* num = malloc(sizeof(int));
        *num = i;
        add_task(example_task, num);
    }

    for (int i = 0; i < MAX_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}