c - 互斥锁在解锁之前是否会阻止访问？

Question

假设此C代码:

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

pthread_mutex_t lock;  
int a = 0;

void *myThreadFun(void *vargp) 
{ 
   pthread_mutex_lock(&lock); 
   a = 5;
   while (1) sleep(1);
   pthread_mutex_unlock(&lock);
   return NULL; 
} 

int main() 
{
   pthread_mutex_init(&lock, NULL);
   pthread_t thread_id; 
   pthread_create(&thread_id, NULL, myThreadFun, NULL);
   while (1){
    a = 6;
    sleep(1); 
    printf("%d\n", a);
   }       
   pthread_join(thread_id, NULL); 
}

第一个输出是 5，但后续输出均为 6。那个怎么样？ myThreadFun创建一个锁，并进入无限循环，并且永远不会解锁，那么 main如何覆盖 a？
lock之间的任何内容都将受到保护？即如果我在 myThreadFun中有更多变量要保护，我只是将它们放在相同的锁之间？

锁是否会阻止访问直到被解锁，或者直到完成自己的读/写操作才阻止访问？即防止部分读写？

Answer 1

myThreadFun creates a lock and goes in an infinite loop and never unlocks

是的，但是那把锁是用来干什么的呢？没有。除线程外，没有其他人会尊重锁。 main程序在不请求任何锁定的情况下访问变量。该程序对锁应该保护 a变量这一事实一无所知。它可以真正用于任何事情。鉴于所有线程都在关键区域的开始处进行锁定并在结束时进行解锁，因此锁仅可防止代码的关键区域同时被多个线程执行。

如果要使其行为正确，则必须正确使用锁，并在与变量交互的代码的每个部分都将其锁定/释放。像这样(在 main中):

while (1) {
    pthread_mutex_lock(&lock);
    a = 6;
    sleep(1);
    printf("%d\n", a);
    pthread_mutex_unlock(&lock);
}

Does a lock block access until it's unlocked, or it block access only until its own read/write is done? i.e to prevent a partial read and write?

锁对读/写，代码或变量一无所知。锁只是具有两个状态的对象:锁定或解锁。如果其状态为未锁定，则可以将其锁定。如果其状态为锁定，则只有在发生解锁时它才能被锁定(并且请求锁定会导致线程等待直到锁定被解锁)。

This still prints 6. I want it to print 5. I want to lock a in a thread so no other thread can touch it.

这是一个不同的问题。您需要在此处执行的操作是确保要启动的线程可以在主线程之前访问 a变量。如果要获得此结果，则需要将两者同步。换句话说，您希望 main程序等待，直到线程将变量锁定。

这可以通过不同的方式来实现。这是一个使用信号量的工作示例(有关更多信息，请参见 man sem_overview )。 注意，虽然看起来可以使用另一个互斥锁而不是信号量实现以下目的，但事实并非如此。互斥锁和信号量之间的主要区别在于，互斥锁只能由锁定它的同一线程来解锁，而信号量则可以由不同的线程自由地锁定或解锁。

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

sem_t sem_main;
pthread_mutex_t lock_var_a;
int a = 0;

void *myThreadFun(void *vargp)
{
    pthread_mutex_lock(&lock_var_a);

    // Signal main that I acquired the lock.
    sem_post(&sem_main);

    a = 5;
    while (1) {
        printf("Thread: a = %d\n", a);
        sleep(1);
    }

    pthread_mutex_unlock(&lock_var_a);

    return NULL;
}

int main()
{
    sem_init(&sem_main, 0, 0);
    pthread_mutex_init(&lock_var_a, NULL);

    pthread_t thread_id;
    pthread_create(&thread_id, NULL, myThreadFun, NULL);

    // Wait for thread to acquire the lock.
    sem_wait(&sem_main);

    while (1){
        pthread_mutex_lock(&lock_var_a);

        // This code will never be executed.
        a = 6;
        printf("Main: a = %d\n", a);
        sleep(1);

        pthread_mutex_unlock(&lock_var_a);
    }

    pthread_join(thread_id, NULL);
}

在上面的示例程序中， main将等待线程获取锁，然后继续。结果输出将是:

Thread: a = 5
Thread: a = 5
Thread: a = 5
...