38

我是多线程/进程编程的新手。所以这是我需要澄清的。

处理 A 代码

pthread_mutex_lock()
    pthread_create(fooAPI(sharedResource)) //fooAPI creates another thread with shared resource that shares across processes.
pthread_mutex_unlock()

sharedResource使用上面的伪代码，如果互斥锁没有解锁，进程B是否可以访问？

如何正确访问进程 B 中的 sharedResource？

是否有任何清晰的可视化图表来解释互斥锁、线程和进程之间的关系？

4

4 回答 4

65

您需要做的是调用 pthread_mutex_lock 来保护互斥锁，如下所示：

pthread_mutex_lock(&mutex);

一旦你这样做了，在你调用这个线程pthread_mutex_lock(mutex)之前，任何其他的调用都不会返回。pthread_mutex_unlock因此，如果您尝试调用 pthread_create，您将能够创建一个新线程，并且该线程将能够（错误地）使用共享资源。您应该pthread_mutex_lock从您的fooAPI函数中调用，这将导致函数等待共享资源可用。

所以你会有这样的事情：

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

int sharedResource = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* fooAPI(void* param)
{
    pthread_mutex_lock(&mutex);
    printf("Changing the shared resource now.\n");
    sharedResource = 42;
    pthread_mutex_unlock(&mutex);
    return 0;
}

int main()
{
    pthread_t thread;

    // Really not locking for any reason other than to make the point.
    pthread_mutex_lock(&mutex);
    pthread_create(&thread, NULL, fooAPI, NULL);
    sleep(1);
    pthread_mutex_unlock(&mutex);

    // Now we need to lock to use the shared resource.
    pthread_mutex_lock(&mutex);
    printf("%d\n", sharedResource);
    pthread_mutex_unlock(&mutex);
}

编辑：跨进程使用资源遵循相同的基本方法，但您需要将内存映射到其他进程。下面是一个使用 shmem 的例子：

#include <stdio.h>
#include <unistd.h>
#include <sys/file.h>
#include <sys/mman.h>
#include <sys/wait.h>

struct shared {
    pthread_mutex_t mutex;
    int sharedResource;
};

int main()
{
    int fd = shm_open("/foo", O_CREAT | O_TRUNC | O_RDWR, 0600);
    ftruncate(fd, sizeof(struct shared));

    struct shared *p = (struct shared*)mmap(0, sizeof(struct shared),
        PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

    p->sharedResource = 0;

    // Make sure it can be shared across processes
    pthread_mutexattr_t shared;
    pthread_mutexattr_init(&shared);
    pthread_mutexattr_setpshared(&shared, PTHREAD_PROCESS_SHARED);

    pthread_mutex_init(&(p->mutex), &shared);

    int i;
    for (i = 0; i < 100; i++) {
        pthread_mutex_lock(&(p->mutex));
        printf("%d\n", p->sharedResource);
        pthread_mutex_unlock(&(p->mutex));
        sleep(1);
    }

    munmap(p, sizeof(struct shared*));
    shm_unlink("/foo");
}

编写程序以更改 p->sharedResource 留给读者作为练习。:-)

顺便说一句，忘了注意，互斥锁必须设置 PTHREAD_PROCESS_SHARED 属性，这样 pthread 才能跨进程工作。

于 2013-02-15T04:15:11.637 回答
4

Q1.) 假设进程 B 尝试获取您在进程 A 中锁定的同一个互斥锁的所有权（您将其留在伪代码之外），那么不，进程 B 在互斥锁被锁定时无法访问 sharedResource，因为它将等待锁定互斥锁直到它被进程 A 释放。当互斥锁被锁定时（或发生错误时！），它将从 mutex_lock() 函数返回

Q2.) 在进程 B 中，确保始终锁定互斥锁，访问共享资源，然后解锁互斥锁。此外，检查 mutex_lock( pMutex ) 例程的返回码，以确保您确实拥有该互斥锁，并且只有在您已锁定该互斥锁时才解锁该互斥锁。从过程 A 中执行相同的操作。

访问互斥体时，两个进程基本上应该做同样的事情。
lock() 如果锁成功，则 { access sharedResource unlock() }

Q3.) 是的，有很多图表：=) https://www.google.se/search?q=mutex+thread+process&rlz=1C1AFAB_enSE487SE487&um=1&ie=UTF-8&hl=en&tbm=isch&source=og&sa=N&tab=wi&ei =ErodUcSmKqf54QS6nYDoAw&biw=1200&bih=1730&sei=FbodUbPbB6mF4ATarIBQ

于 2013-02-15T04:37:39.083 回答
3

一个进程至少包含一个线程（想想 main 函数）。多线程代码只会产生更多线程。互斥锁用于在共享资源周围创建锁，以避免数据损坏/意外/不需要的行为。基本上，它提供了异步设置中的顺序执行——其要求源于对共享数据结构的非常量非原子操作。

生动地描述了人们（线程）排队去洗手间（共享资源）时的互斥锁。当一个人（线程）在使用浴室时放松自己（非常量非原子操作），他/她应该确保门是锁定的（互斥锁），否则可能会导致被抓到（不需要的行为） )

于 2013-02-15T04:41:11.817 回答
3

下面的代码片段将帮助您理解互斥锁解锁概念。尝试对代码进行空运行。（进一步通过改变等待时间和处理时间，你可以建立你的理解）。

供您参考的代码：

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

void in_progress_feedback(int);

int global = 0;
pthread_mutex_t mutex;
void *compute(void *arg) {

    pthread_t ptid = pthread_self();
    printf("ptid : %08x \n", (int)ptid);    

    int i;
    int lock_ret = 1;   
    do{

        lock_ret = pthread_mutex_trylock(&mutex);
        if(lock_ret){
            printf("lock failed(%08x :: %d)..attempt again after 2secs..\n", (int)ptid,  lock_ret);
            sleep(2);  //wait time here..
        }else{  //ret =0 is successful lock
            printf("lock success(%08x :: %d)..\n", (int)ptid, lock_ret);
            break;
        }

    } while(lock_ret);

        for (i = 0; i < 10*10 ; i++) 
        global++;

    //do some stuff here
    in_progress_feedback(10);  //processing-time here..

    lock_ret = pthread_mutex_unlock(&mutex);
    printf("unlocked(%08x :: %d)..!\n", (int)ptid, lock_ret);

     return NULL;
}

void in_progress_feedback(int prog_delay){

    int i=0;
    for(;i<prog_delay;i++){
    printf(". ");
    sleep(1);
    fflush(stdout);
    }

    printf("\n");
    fflush(stdout);
}

int main(void)
{
    pthread_t tid0,tid1;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&tid0, NULL, compute, NULL);
    pthread_create(&tid1, NULL, compute, NULL);
    pthread_join(tid0, NULL);
    pthread_join(tid1, NULL);
    printf("global = %d\n", global);
    pthread_mutex_destroy(&mutex);
          return 0;
}
于 2015-09-07T11:56:34.020 回答