procs, कांटा(), और म्यूटेक्स

Question

मैं समानांतर में चल रही एन प्रक्रियाएं बनाना चाहता हूं और उन्हें एक म्यूटेक्स लॉक करना है, काउंटर बढ़ाएं, और फिर अनलॉक करें और बाहर निकलें।

यहाँ मेरी कोड है:

#include <stdio.h> 
#include <stdlib.h> 
#include <sys/wait.h> 
#include <sys/types.h> 
#include <sys/mman.h> 
#include <unistd.h> 
#include <pthread.h> 

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, -1, 0); 
    *x = 0; 

    printf("Creating %d children\n", n); 

    for(i = 0; i < n; i++) { 
    if (pid != 0) 
     pid = fork(); 
    } 

    if (pid == 0) { 
    pthread_mutex_lock(&mutex); 
    *x = *x + 1; 
    printf("[CHLD] PID: %d PPID: %d X: %d\n", getpid(), getppid(), *x); 
    pthread_mutex_unlock(&mutex); 
    exit(0); 
    } 

    wait(&status); 

    printf("[PRNT] PID: %d X: %d\n", getpid(), *x); 
    munmap(x, sizeof *x); 

    return 0; 
} 

10000 ./procs लेकिन साथ वापस नहीं करता है एक्स = 10000 मुझे लगता है कि इस वजह से म्युटेक्स प्रक्रियाओं के बीच साझा नहीं है, लेकिन क्या करने के लिए सही रास्ता है म्यूटेक्स साझा करें?

Answer 1

pthread_mutex का उपयोग कर टिप्पणी में मेरे उदाहरण का एक बंदरगाह यहां दिया गया है। पहली बार मैंने यह किया है, लेकिन काम करने लगता है:

#include <stdio.h> 
#include <assert.h> 
#include <unistd.h> 
#include <stdbool.h> 
#include <fcntl.h> 
#include <sys/mman.h> 
#include <pthread.h> 

typedef struct 
{ 
    bool done; 
    pthread_mutex_t mutex; 
} shared_data; 

static shared_data* data = NULL; 

void initialise_shared() 
{ 
    // place our shared data in shared memory 
    int prot = PROT_READ | PROT_WRITE; 
    int flags = MAP_SHARED | MAP_ANONYMOUS; 
    data = mmap(NULL, sizeof(shared_data), prot, flags, -1, 0); 
    assert(data); 

    data->done = false; 

    // initialise mutex so it works properly in shared memory 
    pthread_mutexattr_t attr; 
    pthread_mutexattr_init(&attr); 
    pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); 
    pthread_mutex_init(&data->mutex, &attr); 
} 

void run_child() 
{ 
    while (true) 
    { 
     puts("child waiting. .. "); 
     usleep(500000); 

     pthread_mutex_lock(&data->mutex); 
     if (data->done) { 
      pthread_mutex_unlock(&data->mutex); 
      puts("got done!"); 
      break; 
     } 
     pthread_mutex_unlock(&data->mutex); 
    } 

    puts("child exiting .."); 
} 

void run_parent(pid_t pid) 
{ 
    puts("parent sleeping .."); 
    sleep(2); 

    puts("setting done .."); 
    pthread_mutex_lock(&data->mutex); 
    data->done = true; 
    pthread_mutex_unlock(&data->mutex); 

    waitpid(pid, NULL, NULL); 

    puts("parent exiting .."); 
} 

int main(int argc, char** argv) 
{ 
    initialise_shared(); 

    pid_t pid = fork(); 
    if (!pid) { 
     run_child(); 
    } 
    else { 
     run_parent(pid); 
    } 

    munmap(data, sizeof(data)); 
    return 0; 
}