Roscas de bloqueo Mutex

Q1.) Suponiendo que el proceso B intenta tomar posesión del mismo mutex que bloqueó en el proceso A (lo dejó fuera de su pseudocódigo) entonces no, el proceso B no puede acceder a sharedResource mientras el mutex está bloqueado, ya que se quedará esperando para bloquear el mutex hasta que sea liberado por el proceso A. Regresará de la función mutex_lock () cuando el mutex esté bloqueado (o cuando ocurra un error!)

Q2.) En el Proceso B, asegúrese de bloquear siempre el mutex, acceder al recurso compartido y, a continuación, desbloquear el mutex. Además, verifique el código de retorno de la rutina mutex_lock( pMutex) para asegurarse de que realmente posee el mutex, y SOLO desbloquee el mutex si lo ha bloqueado. Haga lo mismo desde el proceso A.

Ambos procesos deberían hacer básicamente lo mismo al acceder al mutex.
bloqueo() Si el bloqueo tiene éxito, entonces { acceso a sharedResource desbloquear() }

Q3.) Sí, hay muchos diagramas: =) https://www.google.se/search?q=mutex+thread+process&rlz=1C1AFAB_enSE487SE487&um=1&ie=UTF-8&hl=en&tbm=isch&source=og&sa=N&tab=wi&ei=ErodUcSmKqf54QS6nYDoAw&biw=1200&bih=1730&sei=FbodUbPbB6mF4ATarIBQ

Un proceso consiste en al menos un hilo (piense en la función principal). El código multihilo solo generará más hilos. Los mutexes se utilizan para crear bloqueos alrededor de los recursos compartidos para evitar la corrupción de datos / comportamiento inesperado / no deseado. Básicamente, proporciona la ejecución secuencial en una configuración asíncrona, cuyo requisito se deriva de operaciones no atómicas no constantes en estructuras de datos compartidas.

Una descripción vívida de lo que los mutexes serían el caso de las personas (hilos) hacer cola para visitar el baño (recurso compartido). Mientras una persona (hilo) está usando el baño aliviándose (operación no-constante no-atómica), él/ella debe asegurarse de que la puerta está cerrada (mutex), de lo contrario podría llevar a ser atrapado en pleno monty (comportamiento no deseado)

A continuación, el fragmento de código, le ayudará a comprender el concepto mutex-lock-unlock. Prueba el código. (además, al variar el tiempo de espera y el tiempo de proceso, puede desarrollar su comprensión).

Código para su referencia:

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

void in_progress_feedback(int);

int global = 0;
pthread_mutex_t mutex;
void *compute(void *arg) {

    pthread_t ptid = pthread_self();
    printf("ptid : %08x \n", (int)ptid);    

    int i;
    int lock_ret = 1;   
    do{

        lock_ret = pthread_mutex_trylock(&mutex);
        if(lock_ret){
            printf("lock failed(%08x :: %d)..attempt again after 2secs..\n", (int)ptid,  lock_ret);
            sleep(2);  //wait time here..
        }else{  //ret =0 is successful lock
            printf("lock success(%08x :: %d)..\n", (int)ptid, lock_ret);
            break;
        }

    } while(lock_ret);

        for (i = 0; i < 10*10 ; i++) 
        global++;

    //do some stuff here
    in_progress_feedback(10);  //processing-time here..

    lock_ret = pthread_mutex_unlock(&mutex);
    printf("unlocked(%08x :: %d)..!\n", (int)ptid, lock_ret);

     return NULL;
}

void in_progress_feedback(int prog_delay){

    int i=0;
    for(;i<prog_delay;i++){
    printf(". ");
    sleep(1);
    fflush(stdout);
    }

    printf("\n");
    fflush(stdout);
}

int main(void)
{
    pthread_t tid0,tid1;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&tid0, NULL, compute, NULL);
    pthread_create(&tid1, NULL, compute, NULL);
    pthread_join(tid0, NULL);
    pthread_join(tid1, NULL);
    printf("global = %d\n", global);
    pthread_mutex_destroy(&mutex);
          return 0;
}