Использование общей переменной 10 pthreads

проблема заключается в следующем коде:

for(i = 0; i < 10; i++) 
{             
  params.id = i;             
 if(pthread_create(&threads[i], NULL, hello, &params));     
} 

ваши параметры.значение id продолжает обновляться в основном потоке, в то время как вы передаете один и тот же указатель на все потоки.

пожалуйста, создайте отдельную память для параметров, динамически выделяя ее и передавая в разные потоки для решения проблемы.

EDIT1: Ваше использование мьютекса для защиты также является неправильной идеей. Хотя ваш мьютекс, если он используется в main при настройке id также, может сделать обновление взаимоисключающим,но вы не можете получить желаемый результат. Вместо получения значений от 0 .. 9 в разных потоках вы можете получить все 9 или несколько потоков могут печатать одинаковые значения.

таким образом, использование синхронизации потоков не такая хорошая идея для выходного, который вы ожидаете. Если вам все еще нужно использовать одну переменную param между всеми потоками и получить вывод от 0 до 9 из каждого потока, лучше переместить pthread_join в первый цикл. Этот гарантирует, что каждый поток создается, печатает значение и затем возвращается до того, как основной порождает следующий поток. В этом случае вам также не нужен мьютекс.

EDIT2: Что касается обновленного вопроса, то где спрашивается, что не нужно печатать цифры 0..9 в последовательности печать может быть случайной, но только один раз проблема все еще остается той же более или менее.

теперь, скажем, значение params.id первый 0 и поток 0 получил созданный, теперь, поток 0 должен распечатать его перед обновлением в основном потоке, иначе, когда поток 0 обращается к нему, значение params.id стал бы 1, и вы никогда не получите свой уникальный набор значений. Итак, как убедиться, что поток 0 печатает его, прежде чем он будет обновлен в main, двумя способами:

• обеспечить поток 0 выполняет и печать до основного обновления значение
• используйте переменные условия & сигнализировать для обеспечения что главный поток ждет для поток 0 для завершения печати перед обновлением значения (см. в ответ Арджуна ниже для более подробной информации)

по моему честному мнению, вы выбрали неправильную проблему для обучения синхронизации и общей памяти. Вы можете попробовать это с некоторыми хорошими проблемами, такими как" производитель-потребитель", где вам действительно нужна синхронизация для работы.

проблема в том, что вы изменяете параметры.id "незащищенный" в основном. Эта модификация в main также должна быть защищена мьютексом. Вы можете защитить этот доступ, локализовав его, создав функции getId() и setId (), которые будут блокировать мьютекс и защищать доступ к идентификатору следующим образом. Это, скорее всего, все равно даст сообщенную проблему, так как в зависимости от того, когда поток вызывает getData (), он будет иметь то или иное значение. Чтобы решить эту проблему, вы можете добавить incrementId() функция и вызовите ее из функции hello ().

struct params {
        pthread_mutex_t mutex;
        int id;
};

typedef struct params params_t;

int getId(params_t *p)
{
    int id;
    pthread_mutex_lock(&(p->mutex));
    id = p->id;
    pthread_mutex_unlock(&(p->mutex));

    return id;

}

void setId(params_t *p, int val)
{
    pthread_mutex_lock(&(p->mutex));
    p->id = val;
    pthread_mutex_unlock(&(p->mutex));
}

void incrementId(params_t *p)
{
    pthread_mutex_lock(&(p->mutex));
    p->id++;
    pthread_mutex_unlock(&(p->mutex));
}

void* hello(void* arg){
    params_t *p = (params_t*)(arg);
    incrementId(p);
    int id = getId(p);

    // This could possibly be quite messy since it
    // could print the data for multiple threads at once
    printf("Hello from %d\n", id);
}


int main() {
    pthread_t threads[10];
    params_t params;
    params.id = 0;
    pthread_mutex_init (&params.mutex , NULL);

    int i;
    for(i = 0; i < 10; i++) {
            if(pthread_create(&threads[i], NULL, hello, &params));
    }

    for(i = 0; i < 10; i++) {
            pthread_join(threads[i], NULL);
    }

    return 0;
}

лучший способ получить уникальный идентификатор потока - определить метод hello следующим образом:

void* hello(void* arg){
    pthread_t threadId = pthread_self();
    printf("Hello from %d\n", threadId);
}

и чтобы избежать проблемы со всеми потоками, пытающимися печатать сразу, вы можете сделать следующее:

void* hello(void* arg){
    params_t *p = (params_t*)(arg);
    pthread_mutex_lock(&(p->mutex));

    p->id++;
    int id = p->id;
    printf("Hello from %d\n", id);

    pthread_mutex_unlock(&(p->mutex));
}

самый простой способ получить желаемый результат - изменить ваш следующим образом:

int main() {
    pthread_t threads[10];
    params_t params;
    pthread_mutex_init (&params.mutex , NULL);

    int i;
    for(i = 0; i < 10; i++) {
            params.id = i;
            if(pthread_create(&threads[i], NULL, hello, &params));
            pthread_join(threads[i], NULL); //wait for thread to finish
    }

    /*for(i = 0; i < 10; i++) {
            pthread_join(threads[i], NULL);
    }*/

    return 0;
}

вывод:

Hello from 0
...
Hello from 9

EDIT: вот синхронизация для исправленного вопроса:

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

struct params {
    pthread_mutex_t* mutex;
    int id;
};

typedef struct params params_t;

void* hello(void* arg){
    int id = 0;
    params_t* params = (params_t*)arg;
    if(params != 0)
    {
        id = params->id;
        delete params;
        params = 0;
    }
    printf("Hello from %d\n", id);
}


int main() {
    pthread_t threads[10];
    params_t* params = 0;
    pthread_mutex_t main_mutex;
    pthread_mutex_init (&main_mutex , NULL);

    int i;
    for(i = 0; i < 10; i++) {
        params = new params_t(); //create copy of the id to pass to each thread -> each thread will have it's own copy of the id
        params->id = i;
        params->mutex = &main_mutex;
        if(pthread_create(&threads[i], NULL, hello, params));
    }

    for(i = 0; i < 10; i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

каждый поток должен иметь собственную копию идентификатора, чтобы другие потоки не изменяли идентификатор до его печати.

Я просто помещаю это здесь, чтобы предоставить другое решение этой проблемы - это не связано с мьютексами - нет синхронизации - нет условий и т. д. Основной dfference является то, что мы используем pthread_detach для автоматического освобождения ресурсов потока по завершении.

#include <pthread.h> 
#include <stdio.h>
#include <stdlib.h>   
#include <unistd.h> 

#define NUMTHREADS 10        

typedef struct params {    
    int id;     
} params_t;                                                                     

void* hello(void *arg)  
{ 
    params_t *p = (params_t*)arg;     
    int status; 
    status = pthread_detach(pthread_self());      
    if (status !=0 )     
    {       
        printf("detaching thread\n");     
        abort();      
     }                                                                           

     printf("Hello from %d\n", p->id);   
     free(p);    
     return NULL;  
 }                     

int main()   
{ 
    pthread_t thread;    
    params_t *par;     
    int i, status;                                                              
    for (i=0; i<NUMTHREADS; i++)    
    {     
        par = (params_t*)malloc(sizeof(params_t));       
        if (par == NULL)    
        {       
            printf("allocating params_t");   
            abort();     
         }                                                                       

        par->id = i;  
        status = pthread_create(&thread, NULL, hello, par);   
        if (status != 0)    
            exit(1);     
    }      
    /* DO some more work ...*/                                                       
    sleep(3);                                                                         
    exit(0);  
}