LeetCode 刷题

#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// 初始化互斥锁
pthread_mutex_init(&mutex, NULL);

// 在需要保护的代码块前加锁
pthread_mutex_lock(&mutex);
// 访问共享资源
// ...
// 访问完毕后解锁
pthread_mutex_unlock(&mutex);

// 在使用完后销毁
pthread_mutex_destroy(&mutex);

#include <pthread.h>

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

// 初始化读写锁
pthread_rwlock_init(&rwlock, NULL);

// 在需要读取共享资源的代码块前加读锁
pthread_rwlock_rdlock(&rwlock);
// 读取共享资源
// ...
// 读取完毕后释放读锁
pthread_rwlock_unlock(&rwlock);

// 在需要写入共享资源的代码块前加写锁
pthread_rwlock_wrlock(&rwlock);
// 写入共享资源
// ...
// 写入完毕后释放写锁
pthread_rwlock_unlock(&rwlock);

// 在使用完读写锁后销毁
pthread_rwlock_destroy(&rwlock);

#include <pthread.h>

// 定义自旋锁
pthread_spinlock_t spinlock = PTHREAD_PROCESS_PRIVATE;

// 初始化自旋锁
pthread_spin_init(&spinlock, PTHREAD_PROCESS_PRIVATE);

// 加锁，如果锁已被其他线程占用，则该函数会一直循环忙等待直到获取到锁
pthread_spin_lock(&spinlock);
// 访问共享资源
// ...
// 解锁，使其他线程可以获取锁并访问共享资源
pthread_spin_unlock(&spinlock);

// 销毁自旋锁
pthread_spin_destroy(&lock);

#include <pthread.h>

// 定义互斥锁和条件变量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

// 初始化互斥锁和条件变量
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);

// 加锁
pthread_mutex_lock(&mutex);

while (条件不满足预期条件) {
    // 释放锁，并等待条件变量通知——从而唤醒该线程继续执行
    pthread_cond_wait(&cond, &mutex);
}

// 条件满足（由另一个线程控制），继续执行，访问共享资源
// ...
// 解锁
pthread_mutex_unlock(&mutex);

// 在使用完后销毁
pthread_cond_destroy(&cond);
pthread_mutex_destroy(&mutex);

//----------------------------------------------

// 在其他线程中通知条件变量
// ...
// 加锁
pthread_mutex_lock(&mutex);
// 访问共享资源
// ...
// 解锁后再发送通知
pthread_mutex_unlock(&mutex);

// 发送条件变量通知其它等待的线程
pthread_cond_signal(&cond);

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

#define BUFFER_SIZE (4)

int buffer[BUFFER_SIZE];
int count = 0;  // 产品余量
pthread_mutex_t mutex;
pthread_cond_t cond;

void* producer(void* arg) {
    int flag = 0, i = 0;
    while (1) {
        pthread_mutex_lock(&mutex);

        // 预期条件是 buffer 不能满（当 buffer 满时为条件不满足预期）
        while (BUFFER_SIZE == count) {
            if (0 == flag) {
                printf("    Buffer full...\n");
                flag = 1;
            }
            pthread_cond_wait(&cond, &mutex);
        }

        flag = 0;
        buffer[count++] = i++;
        printf("Producer produced: %d\n", i);

        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&cond);  // 释放锁，并通知条件变量
    }

    return NULL;
}

void* consumer(void* arg) {
    int flag = 0, i = 0;
    while (1) {
        pthread_mutex_lock(&mutex);

        // 预期条件是 buffer 不能空（当 buffer 空时为条件不满足预期）
        while (0 == count) {
            if (0 == flag) {
                printf("    Buffer empty...\n");
                flag = 1;
            }
            pthread_cond_wait(&cond, &mutex);
        }

        flag = 0;
        int value = buffer[--count];
        printf("Consumer consumed: %d\n", value);

        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&cond);  // 释放锁，并通知条件变量
    }

    return NULL;
}

int main(int argc, char* argv[]) {
    pthread_t producer_thread, consumer_thread;

    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);

    pthread_join(producer_thread, (void**)(0));
    pthread_join(consumer_thread, (void**)(0));

    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);

    return 0;
}

#include <pthread.h>

// 定义屏障
pthread_barrier_t barrier;
int thread_nums = 5;

// 初始化屏障
pthread_barrier_init(&barrier, NULL, thread_nums);

// 在每个线程中执行以下代码
pthread_barrier_wait(&barrier); // 等待屏障

// 所有线程都到达屏障后，继续执行以下代码
// ...

// 在使用完后销毁
pthread_barrier_destroy(&barrier);

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

// 定义屏障
pthread_barrier_t barrier;
int thread_nums = 5;

// 线程函数
void* thread_func(void* ptr) {
    printf("Thread #%lu, param %d operation\n", pthread_self(), *(int*)ptr);

    // 等待屏障
    pthread_barrier_wait(&barrier);

    // 所有线程都到达屏障后，继续执行以下代码
    printf("Thread %lu, %d continues after the barrier\n", pthread_self(), *(int*)ptr);
    free(ptr);

    return NULL;
}

int main() {
    pthread_t threads[thread_nums];

    // 初始化屏障
    pthread_barrier_init(&barrier, NULL, thread_nums);

    // 创建线程
    for (int i = 0; i < thread_nums; i++) {
        int* ptr = (int*)malloc(sizeof(int));
        *ptr = i;
        pthread_create(&threads[i], NULL, thread_func, (void*)ptr);
    }

    // 等待线程结束
    for (int i = 0; i < thread_nums; i++) {
        pthread_join(threads[i], (void**)(0));
    }

    // 销毁屏障
    pthread_barrier_destroy(&barrier);

    return 0;
}