我在pThread库中看到的Mutex锁定的所有教程都使用了Global Mutex Lock：
请参阅：
https://computing.llnl.gov/tutorials/pthreads/#Mutexes
http://www.drdobbs.com/cpp/184401518?pgno=3（对于boost :: thread但相同的上下文）
我想要做的是使用Mutex锁定，其中主文件的全局超出了需要锁定变量的函数的范围。这是一个例子：
Main.cpp的
int main() {
some initilisation code.
tree * tree1;
*Start thread to visualise tree* (see code below)
Mutex Lock:
delete tree1;
tree1 = newTree();
Mutex Unlock
visualiser.cpp
visualise(Tree *) {
Forever:
Mutex Lock:
Check for tree change.
Update tree image.
Display tree image.
Mutex Unlock
我想知道这是否可行：
据我所知，这可能不合理，如果不是，我如何使用extern将全局范围变量传递给visualiser.cpp？
此外，如果我需要将互斥量传递给函数，我将如何进行此操作？
答案 0 :(得分：4)
是的，如果互斥锁在任何线程使用时保持在范围内，则它不必是全局的。你做必须告诉第二个线程互斥锁在哪里，不幸的是没有办法解决这个问题。
传递它与传递任何其他变量没有什么不同。
因此，只需定义它并在第一个线程中初始化它，然后在创建第二个线程时，将其地址作为线程参数传递。
然后，第二个线程可以使用该地址访问互斥锁。
就你的评论而言，你希望函数既可以作为一个线程使用又只是一个普通的函数，我只是因为复杂性而避开它。
你可以做的是将大部分工作放入普通函数中，然后使线程函数成为一个简单的包装器。你甚至可以传入一个互斥指针，如果有效则可以使用，或者如果为NULL则不使用。
有关详细信息，请参阅以下完整程序。首先，一些支持，需要的标题和日志功能：
#include <pthread.h>
#include <stdio.h>
#include <time.h>
static void mylog (int indent, char *s) {
int i;
time_t now = time (NULL);
struct tm *lt = localtime (&now);
printf ("%02d:%02d:%02d ", lt->tm_hour, lt->tm_min, lt->tm_sec);
putchar ('|');
for (i = 0; i < indent; i++) printf ("%-20s|", "");
printf ("%-20s|", s);
for (i = indent + 1; i < 3; i++) printf ("%-20s|", "");
putchar ('\n');
}
接下来，将完成工作的功能。这是以这样的方式构建的，它可以从任何线程调用，如果你想使用它，可以传递一个互斥指针：
static void *myfunction (void *ptr) {
pthread_mutex_t *pMtx = ptr;
mylog (2, "starting");
if (pMtx != NULL) {
mylog (2, "locking mutex");
pthread_mutex_lock (pMtx);
mylog (2, "locked mutex");
}
mylog (2, "sleeping");
sleep (5);
mylog (2, "finished sleeping");
if (pMtx != NULL) {
mylog (2, "unlocking mutex");
pthread_mutex_unlock (pMtx);
}
mylog (2, "stopping");
}
然后是一个实际的线程函数，它实际上是上面工作函数的一个薄包装器。请注意，它通过特定于线程的参数接收互斥锁，并将其传递给工作函数：
static void *mythread (void *ptr) {
mylog (1, "starting");
mylog (1, "call fn with mutex");
myfunction (ptr);
mylog (1, "and back");
mylog (1, "stopping");
}
最后，主要功能。这首先在没有互斥锁的情况下调用工作函数，然后创建一个与另一个线程共享的互斥锁：
int main (void) {
pthread_mutex_t mtx;
pthread_t tid1;
char buff[100];
printf (" |%-20s|%-20s|%-20s|\n", "main", "thread", "workfn");
printf (" |%-20s|%-20s|%-20s|\n", "====", "======", "======");
mylog (0, "starting");
mylog (0, "call fn, no mutex");
myfunction (NULL);
mylog (0, "and back");
mylog (0, "initing mutex");
pthread_mutex_init (&mtx, NULL);
mylog (0, "locking mutex");
pthread_mutex_lock (&mtx);
mylog (0, "locked mutex");
mylog (0, "starting thead");
pthread_create (&tid1, NULL, mythread, &mtx);
mylog (0, "sleeping");
sleep (5);
mylog (0, "sleep done");
mylog (0, "unlocking mutex");
pthread_mutex_unlock (&mtx);
mylog (0, "joining thread");
pthread_join (tid1, NULL);
mylog (0, "joined thread");
mylog (0, "exiting");
return 0;
}
您可以在输出中看到代码如何排序：
|main |thread |workfn |
|==== |====== |====== |
15:07:10 |starting | | |
15:07:10 |call fn, no mutex | | |
15:07:10 | | |starting |
15:07:10 | | |sleeping |
15:07:15 | | |finished sleeping |
15:07:15 | | |stopping |
15:07:15 |and back | | |
15:07:15 |initing mutex | | |
15:07:15 |locking mutex | | |
15:07:15 |locked mutex | | |
15:07:15 |starting thead | | |
15:07:15 |sleeping | | |
15:07:15 | |starting | |
15:07:15 | |call fn with mutex | |
15:07:15 | | |starting |
15:07:15 | | |locking mutex |
15:07:20 |sleep done | | |
15:07:20 |unlocking mutex | | |
15:07:20 |joining thread | | |
15:07:20 | | |locked mutex |
15:07:20 | | |sleeping |
15:07:25 | | |finished sleeping |
15:07:25 | | |unlocking mutex |
15:07:25 | | |stopping |
15:07:25 | |and back | |
15:07:25 | |stopping | |
15:07:25 |joined thread | | |
15:07:25 |exiting | | |
特别注意与使用互斥锁的呼叫相比，没有互斥的直接呼叫是如何起作用的。
答案 1 :(得分：1)
一旦将代码从伪代码转换为具体代码，答案就会变得明显。
例如：
您的可视化工具线程必须“检查树更改。”
你是怎么做到的？您必须拥有可以告诉您此信息的数据结构。这个ds将由主线程更新。
因此，您将互斥锁保留在该数据结构中。它可以是全局的或堆上的
答案 2 :(得分：0)
它实际上不是线程安全传递并且每个线程使用不同的互斥实例化，因为这不会将多个线程访问同步到所有相关线程的公共对象。
通常，每个对象/数据结构实例应该有一个互斥锁，而不是每个线程一个。话虽这么说，对于需要同步的对象具有互斥属性，以及在需要同步的方法内部进行管理，它会更有意义。
关于Global mutex的提及，并考虑到我之前的段落，互斥锁应该有效地对于正在同步的对象和涉及的线程的上下文是全局的。也就是说，相同的互斥锁应该是通用的，并且可供所有这些实体使用。尽管如前所述，但这可以在不使其成为全局变量的情况下实现。