Tag: 互斥

procs，fork（）和mutexes: 我想创建并行运行的n个进程，让它们锁定互斥锁，递增计数器，然后解锁并退出。这是我的代码： #include #include #include #include #include #include #include pthread_mutex_t mutex; int main(int argc, char **argv) { if (argc != 2) return 0; int n = atoi(argv[1]); int i = 0; int status = 0; pthread_mutex_init(&mutex, NULL); pid_t pid = 1; static int *x; x = mmap(NULL, sizeof *x, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, […]

与struct指针共享内存互斥: 我正在寻找一些关于我是否正确执行以下操作的反馈。我正在努力移植一些Windows实时代码，这些代码大量使用了命名的互斥锁。它需要一些搜索，但我遇到一些东西，说你可以使用共享内存作为linux中的互斥，使用shm open。我不能在这里包含所有代码，但我将需要一些反馈的关键区域放在一起。我的问题是如果我正确设置共享内存区域和互斥锁，以及我的指针是否设置正确，以及如何利用它来锁定/解锁。 volatile struct GenQ { volatile pthread_mutex_t *qMutexId volatile sem_t qSemId volatile int nexton volatile int nextoff } typedef struct Node{ void *qid char shmname[80] sem_t *semid pthread_mutex_t *mutexID struct node *next struct node *prev } void * init (const char *qname) { struct GenQ *myq; char mtxstr[80]; pthread_mutex_t *mutexQueAccess; […]

使用条件变量和互斥量来同步C中的线程: 根据评论者的要求编辑。该程序创建两个线程。每个线程从两个特定输入文件中的一个读取，每个输入文件包含一行字母或每行代码一个’0’。线程应该将字母读入全局字符数组，然后打印出来。问题是，在达到’0’时，活动线程必须将控制转移到另一个线程，该线程在该线路上不应该为’0’。（我们确信，如果文件1在一行上有一个’0’，那么相应行上的文件2就有一个字母。多个零可以互相跟随，多个字母也可以。）文件一 h 0 h 0 h 0 h 0 h 0 文件二 0 i 0 i 0 i 0 i 0 i 我正在尝试使用pthread互斥锁定/解锁以及信号并等待使其工作。但是，我一直处于僵局状态。有两个线程。目前，它们彼此镜像意味着它们执行相同的操作，只是使用不同的文件和相反的条件。线程示例： char final[1001]; pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t condition1 = PTHREAD_COND_INITIALIZER; pthread_cond_t condition2 = PTHREAD_COND_INITIALIZER; int w = 1; void *get() { //start […]

Pthread同步：两个文本文件的返回和读取: 我正在编写一个创建两个线程的程序。每个线程负责读取一个文本文件，每行有一个字符。第一种格式如下： h 0 h 0 … 第二个格式如下： 0 i 0 i 0 i 有时可能会有多个字母在彼此之后，或者在彼此之后有多个零。但是，可以肯定的是，如果一个文件的一行上有一个字母，则第二个文件的相应行将为0，反之亦然。线程应该继续将文件输入读入全局char数组，直到它们达到零。此时，他们允许其他线程接管。他们一直来回走，直到两个文件完全被读取。在这一点上，当我跑步的时候，我得到的变化是：（1）很多h后跟很多我或（2）（正确答案）连续的hihihi流，或者（3）有时很多我跟着很多h。所以，我知道我的同步方法已关闭。这是我的一个线程的示例:(注意两个线程完全相同，除了正在打开的文件。） void *getMessage1() { FILE *studentOne = fopen(“Student1”, “r”); size_t howManyChars; char *placeHolderChars; int count = 1; while (count 0) { placeHolderChars[1] = ‘\0’; } strcat(message,placeHolderChars); } free(placeHolderChars); if(feof(studentOne)) { pthread_mutex_unlock(&lock); […]

虚假唤醒后的互斥状态: 考虑使用pthreads这个基本的multithreading程序。我们有一个主线程，创建另一个做一些工作的线程。 bool done = false; mutex m; condition c; void foo() { pthread_mutex_lock(&m); //while(!done) { pthread_cond_wait(&c, &m); // Spuriously wakeup while child is doing work. // child thread has NOT unlocked the mutex yet // Do I now own the mutex? // or am I waiting for child to unlock it? //} pthread_mutex_unlock(&m); } […]

使用pthread_cond_wait和pthread_cond_signal保证屈服: 假设我有一个带有3个POSIX线程的C程序，共享一个全局变量，互斥量和条件变量，其中两个执行以下伪代码： …process data… pthread_mutex_lock( &mutex ); variable = data_ptr; pthread_cond_signal( &cond ); pthread_mutex_unlock( &mutex ); 第三次运行： while(1) { while( variable == NULL ) { pthread_mutex_wait( &cond, &mutex ); } printf( “Data is %d”, *variable ); } 假设第三个线程将看到前两个中的每一个的数据是否安全？换句话说，如果一个线程在互斥锁和一个条件变量上作用，是否可以安全地假设它是下一个获取锁定的信号，而不是一个其他可能正在等待的线程。锁？

pthread互斥的必要性: 我有一个int array[100] ，我想要5个线程来计算所有数组元素的总和。每个线程在其专用范围内迭代20个元素，并将总和写入全局sum变量。这是必需的互斥体吗？由于所有线程都从独立源读取，因此不需要同步。 for(i=offset; i<offset+range; i++){ // not used pthread_mutex_lock(&mutex); sum += array[i]; // not used pthread_mutex_unlock(&mutex); } 这会导致不可预测的行为，还是操作系统实际上会处理这个问题？在这种情况下，是否可以省略互斥锁？我注意到没有它，这些算法运行得更快。

thrd_busy和mtx_lock（）/ mtx_timedlock（）: 我有关于C1x互斥量的以下问题（§7.25.4）：在哪种情况下mtx_lock()返回thrd_busy而不是阻塞？在哪些情况下mtx_timedlock()返回thrd_busy ？请注意， thrd_busy在§7.25.1¶5中定义为“ 当测试和返回函数请求的资源已被使用时 ”。我希望thrd_busy只能由mtx_trylock()返回，或者当用mtx_try或mtx_try | mtx_recursive调用时，最多也只能由mtx_trylock()返回mtx_try | mtx_recursive mtx_try | mtx_recursive互斥锁，但绝对不是来自mtx_timedlock() ，它需要一个支持超时的互斥锁，即mtx_timed或mtx_timed | mtx_recursive mtx_timed | mtx_recursive互斥。这只是草案中的公正和疏忽吗？或者我错过了什么？

可以在没有硬件支持的软件中实现测试和设置吗？: 这是用软件编写的测试和设置： boolean TestAndSet(boolean *target) { boolean rv = *target; *target = TRUE; return rv; } 和 do { while(TestAndSetLock(&lock)) ; // do nothing // critical section lock = FALSE; // remainder section } while(TRUE); 我们可以在CPU中使用不支持硬件级别的测试和设置的机制吗？如果是这样，primefaces性如何得到保证？

是否需要互斥锁将不同的偏移量分配到已分配的堆内存中: 我正在框架中放置一个生成二进制数据表的工具。我计划让这个multithreading充分利用我所拥有的24个核心。（我估计在一个线程中生成数据的时间大约为50天）。我过去使用带有套接字通信的服务器/客户端设计完成了这项工作，因为我需要在多台计算机上进行分发。这一次，我正在研究单机/multithreading方法，并试图找出如何以正确的方式做到这一点。主线程将处理每个子线程的任务分配并确定到分配的内存中的偏移量。每个线程将写入分配的内存中的唯一地址范围。因为这些块在记录之间永远不会重叠，所以没有两个线程会尝试写入相同的偏移量。 void computeRecord(void *taskInput) { struct TaskData *taskData = (TaskData *)(taskInput); RecordData data; // A huge long computation block to populate data // (4-5 second run time) long record_id = taskData->record_id; char *buffer = taskData->start_buffer; // mutex lock needed here ?? int n_bytes = sizeof(RecordData) memcpy( (char *)(buffer+record_id*n_bytes), […]