我是多线程/进程编程的新手，这是我需要澄清的事情。
进程A的代码
pthread_mutex_lock()
pthread_create(fooAPI(sharedResource)) //fooAPI creates another thread with shared resource that shares across processes.
pthread_mutex_unlock()
使用上述伪代码，如果互斥锁未解锁，进程B能否访问sharedResource？
如何正确地从进程B访问共享资源？
是否有任何清晰的可视化图表说明互斥锁、线程和进程之间的关系？
您需要调用pthread_mutex_lock来保护互斥锁，如下所示:
pthread_mutex_lock(&mutex);
pthread_mutex_lock(mutex)的任何其他调用都不会返回，直到你在该线程中调用了pthread_mutex_unlock。因此，如果你尝试调用pthread_create，你将能够创建一个新线程，而该线程将能够（错误地）使用共享资源。你应该从你的fooAPI函数中调用pthread_mutex_lock，这将导致函数等待直到共享资源可用。
所以你会有类似这样的代码：
#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的过程留给读者自己完成。 :-)
顺便提醒一下，mutex必须具有PTHREAD_PROCESS_SHARED属性设置，以便pthread可以跨进程工作。
以下是一段代码片段，可以帮助您理解互斥锁的概念。请尝试在代码上进行干运行（通过更改等待时间和处理时间，您可以进一步建立自己的理解）。
代码如下：
#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;
}
compute()）。如果没有创建线程，则仍然在主线程上（其中main()执行）。现在，如果您需要使线程在后台执行某些操作，则需要在绑定方法上保持该执行状态，直到满足某个非退出条件（即不要让绑定方法退出，直到您要求关闭）。现在，当向线程发出退出信号时，它应该退出（清理等），否则它将继续执行您所需的操作。 - parasrish
pthread_mutex_lock()锁定线程”之类的内容，以使问题更易搜索并且具有更清晰的开头？ - Gabriel Staplesmtx_lock()vspthread_mutex_lock()- Gabriel Staples