这是我上一个问题（ pthread mutex (un)locking over differentthreads ）的后续问题。我对如何处理这里的问题和答案感到困惑，所以我重新尝试:o)
我试图通过进程和线程处理互斥体，并使用互斥体属性 PTHREAD_PROCESS_SHARED 来安排它。我添加了一个小示例（基于我上一篇文章中 Paolo 的示例），它演示了我的问题：
#include <stddef.h>
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <semaphore.h>
pthread_mutex_t m;
sem_t s1, s2;
void print(const char *s, int err)
{
printf("%s %d %s\n", s, err, strerror(err));
}
void *start_t1(void *arg)
{
sem_wait(&s1); // <-t2
print("t1: unlock ", pthread_mutex_unlock(&m));
sem_post(&s2); //->t2
}
void *start_t2(void *arg)
{
sem_wait(&s2); // <-main
print("t2: lock ", pthread_mutex_lock(&m));
sem_post(&s1); // ->t1
sem_wait(&s2); // <-t1
sem_post(&s1); // ->main
}
void main(void)
{
pthread_mutexattr_t …我有 16 个从一个父线程生成的线程。我正在通过在父级中调用 pthread_join 等待子级完成执行。然而，之后我在每个子线程中调用 pthread_detach。我想知道父母是否仍然会等待孩子们完成执行。在手册页中，它对 pthread_detach 说：“当分离的线程终止时，其资源会自动释放回系统，而不需要另一个线程加入终止的线程。”
我正在学习 POSIX 线程，我的教授已经开始教授第一个读写器问题。这是我关于解决问题的伪代码（仅适用于第一种情况：读者的偏好）。
semaphore rw_mutex = 1; /* semaphore common to both reader & writer */
semaphore mutex = 1; /* semaphore for reading (reader lock) */
int read_count = 0; /* track number of readers in CS */
Writer:
do {
lock(rw_mutex);
/* ensure no writer or reader can enter */
...
/* writing is performed */
...
unlock(rw_mutex);
/* release lock */
} while (true);
Reader:
do
{
lock(mutex);
/* first update read_count atomically */
read_count++;
if (read_count …我正在编写一个程序，它有一个写入线程和几个读取线程，用于写入/读取磁盘上的文件。我希望写入/读取不会同时发生。我发现了很多使用pthread互斥锁在写入/读取期间保护内存阵列的示例，例如将受保护的内存数组声明为易失性。
volatile int array[NUMBER];
pthread_mutex_t locks[NUMBER];
pthread_mutex_lock(&locks[index]);
array[acct] -= SOME_NUMBER;
pthread_mutex_unlock(&locks[index]);
但我找不到使用 pthread 保护磁盘上文件的示例。
volatile FILE* array[NUMBER]; ??
有人能指出我正确的方向吗？我希望写/读线程不会同时访问磁盘上的文件。
编辑：我阅读了更多内容，根据这篇文章，多线程似乎不适用于磁盘 IO。
我试图在 while 循环条件下检查 pthread_cond_t 类型的变量的值。
该变量在节点结构中定义，形式如下：
pthread_cond_t cv;
当我尝试使用此方法检查其值时，!=或者== NULL出现无法完成此操作的错误。这是我尝试检查时的样子：
while(!node->cv) {
其中node是指向包含 cv 的结构的指针。
我收到错误“一元感叹号的参数类型错误，因为我猜它不是布尔值。有没有办法检查这个条件变量是否有值？
当我增加NTHREADS时，以下代码运行速度会变慢。为什么使用更多的线程会使程序运行速度变慢？有什么办法可以解决吗？有人说这是虚假分享，但我不太明白这个概念。
该程序基本上计算从1到100000000的总和。使用多线程的想法是将数字列表分成几个块，并并行计算每个块的总和以使计算更快。
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define LENGTH 100000000
#define NTHREADS 2
#define NREPEATS 10
#define CHUNCK (LENGTH / NTHREADS)
typedef struct {
size_t id;
long *array;
long result;
} worker_args;
void *worker(void *args) {
worker_args *wargs = (worker_args*) args;
const size_t start = wargs->id * CHUNCK;
const size_t end = wargs->id == NTHREADS - 1 ? LENGTH : (wargs->id+1) * CHUNCK;
for (size_t i = start; i < end; ++i) {
wargs->result += wargs->array[i]; …我必须在多个线程期间消耗测量时间。我必须得到这样的输出：
Starting Time | Thread Number
00000000000 | 1
00000000100 | 2
00000000200 | 3
首先，我使用了 gettimeofday 但我看到有一些负数，然后我做了一些研究并了解到 gettimeofday 无法可靠地测量经过的时间。然后我决定使用clock_gettime(CLOCK_MONOTONIC)。
然而，有一个问题。当我用秒来测量时间时，我无法精确地测量时间。当我使用纳秒时， end.tv_nsec 变量的长度不能超过 9 位数字（因为它是一个长变量）。这意味着，当它必须移动到第 10 位时，它仍然保持在 9 位，并且实际上数字变小，导致经过的时间为负数。
这是我的代码：
long elapsedTime;
struct timespec end;
struct timespec start2;
//gettimeofday(&start2, NULL);
clock_gettime(CLOCK_MONOTONIC,&start2);
while(c <= totalCount)
{
if(strcmp(algorithm,"FCFS") == 0)
{
printf("In SErunner count=%d \n",count);
if(count > 0)
{
printf("Count = %d \n",count);
it = deQueue();
c++;
tid = it->tid;
clock_gettime(CLOCK_MONOTONIC,&end);
usleep( 1000*(it->value));
elapsedTime = ( end.tv_sec - start2.tv_sec);
printf("Process of thread …我正在尝试使用命令在linux中编译ac文件
\ngcc filename.c \xe2\x80\x93o filename -Wall -Werror -pthreads -std=c99\n我收到以下错误
\ngcc: error: \xe2\x80\x93o: No such file or directory\ngcc: error: filename: No such file or directory\ngcc: error: unrecognized command line option \xe2\x80\x98-pthreads\xe2\x80\x99\n我不知道为什么。有什么解决办法吗？
\n在学习了常规线程之后，我正在学习 pthreads。通常，当我们使用布尔线程对象时，我们将其声明为易失性对象，如下所示volatile bool thread_lock;：我们是否也需要在 pthread 对象上执行此操作，特别是在pthread_mutex_t需要时或它自己处理它？
我查看了该pthread_mutex_t声明，发现它没有 易失性声明。
应该是volatile pthread_mutex_t my_obj;还是pthread_mutex_t my_obj;
我为这个糟糕的标题道歉，只是想找人确认我没有疯。
我最近偶然发现了一些已经使用多年而没有人抱怨的代码。我调查它的原因是因为我在大量修改此代码库时遇到此错误：
pthread_mutex_lock.c:90: ___pthread_mutex_lock: Assertion `mutex->__data.__owner == 0' failed.
经过一番挖掘，我发现互斥锁的使用（对我来说）非常奇怪。在本质上：
lock_guard我相信这在很多方面都是未定义的行为，但我收到了一些反对意见，认为应该改变它，因为我正在努力一致且最小化地重现这个确切的错误。
我假设这是为了让互斥体首先被循环线程解锁（从解锁状态，线程还没有要lock_guard处理的数据），然后锁定，并且大部分时间都会被锁定，而lock_guard偶尔会尝试锁定，并且必须等待循环解锁它，此时它可以处理其数据，lock_guard超出范围，并且锁定返回到循环线程。
我认为导致我的错误的是；通过我的修改，线程lock_guard获取数据的速度比预期的要快，因此lock_guard触发了该情况，然后循环线程尝试解锁另一个线程互斥体。
我在寻找：
lock_guard我搜索了代码库，互斥体只使用了 4 次，我可以看到：当它被声明时，当它被使用时，当lock_guard它被解锁时，然后被锁定，所以我的 MRE 很短，我认为它基本上有它需要的一切。演示如何使用该互斥锁：
#include <iostream>
#include <thread>
#include <mutex>
#include <unistd.h>
std::mutex data_mtx;
void lg_thread(){
std::lock_guard<std::mutex> guard(data_mtx);
usleep(10e6);
}
int main(int argc, char const* argv[]){
std::thread t1(lg_thread);
usleep(10000);
for (int i = 0; i …