pthread_mutex_lock函数

pthread_mutex_lock函数是一个用于线程同步的函数，它的作用是获取一个互斥锁。互斥锁是一种常用的线程同步机制，用来保护共享资源，避免多个线程同时访问同一资源而导致的数据竞争。

pthread_mutex_lock函数的原型如下：

int pthread_mutex_lock(pthread_mutex_t *mutex);

其中，mutex是一个指向互斥锁的指针。

pthread_mutex_lock函数的作用是获取互斥锁，如果当前互斥锁已经被其他线程占用，则调用线程会被阻塞，直到互斥锁被释放为止。当函数成功获取互斥锁时，返回值为0；否则，返回一个非零错误码。

需要注意的是，pthread_mutex_lock函数获取互斥锁后，需要在适当的时候释放互斥锁，以允许其他线程获取锁并访问共享资源。可以使用pthread_mutex_unlock函数来释放互斥锁。

相关问题

pthread_mutex_lock 函数怎么用

`pthread_mutex_lock` 是一个线程同步的函数，用于锁定互斥量（mutex），保证同一时刻只有一个线程能够访问共享资源。

函数原型如下：

#include <pthread.h>

int pthread_mutex_lock(pthread_mutex_t *mutex);

参数 `mutex` 是一个指向需要加锁的互斥量的指针。

函数返回值为 0 表示成功加锁，否则返回错误码。

下面是一个简单的例子，使用 `pthread_mutex_lock` 来保证线程同步：

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *thread_func(void *arg) {
    int *p = (int *)arg;

    pthread_mutex_lock(&mutex);
    printf("Thread %d is running...\n", *p);
    pthread_mutex_unlock(&mutex);

    return NULL;
}

int main() {
    int i;
    pthread_t tid[5];

    for (i = 0; i < 5; ++i) {
        pthread_create(&tid[i], NULL, thread_func, &i);
    }

    for (i = 0; i < 5; ++i) {
        pthread_join(tid[i], NULL);
    }

    return 0;
}

在上面的例子中，我们创建了 5 个线程，它们都会执行 `thread_func` 函数。由于我们使用了互斥量来保证同一时刻只有一个线程能够访问共享资源，因此每个线程输出的时候都会先加锁，然后再输出，最后再解锁。这样就能够保证线程同步，避免了竞争条件的问题。

pthread_mutex_lock函数的使用实例

`pthread_mutex_lock`是POSIX线程库中的一个函数，用于锁定一个互斥锁（mutex），确保在同一时刻只有一个线程能访问共享资源。这个函数常用于保护数据的一致性和并发控制。

下面是一个简单的使用实例：

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

// 共享资源，这里假设它是个全局整型变量
int shared_resource = 0;

// 创建互斥锁
pthread_mutex_t mutex;
int init_lock() {
    if (pthread_mutex_init(&mutex, NULL) != 0) {
        perror("Mutex initialization failed");
        return -1;
    }
    return 0;
}

void* worker_function(void* arg) {
    int my_id = *(int*)arg;
    pthread_mutex_lock(&mutex); // 获取锁
    printf("Worker %d is accessing the resource: %d\n", my_id, shared_resource);
    // 对共享资源进行操作...
    pthread_mutex_unlock(&mutex); // 释放锁
    return NULL;
}

int main() {
    if (init_lock() != 0) {
        return -1;
    }

    // 创建两个工作线程
    pthread_t thread1, thread2;
    int args[] = {0, 1}; // 线程ID作为参数传递
    if (pthread_create(&thread1, NULL, worker_function, &args[0]) != 0) {
        perror("Thread creation failed");
        return -1;
    }
    if (pthread_create(&thread2, NULL, worker_function, &args[1]) != 0) {
        perror("Thread creation failed");
        return -1;
    }

    // 等待线程完成
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    pthread_mutex_destroy(&mutex); // 销毁互斥锁
    return 0;
}

在这个例子中，主线程初始化了互斥锁并创建了两个子线程。每个子线程在访问`shared_resource`前都会尝试获取锁，确保同一时间只有一个线程可以修改它。当完成操作后，线程会释放锁，允许其他线程继续执行。