Molto più chiaro adesso.

Scusa se vado di fretta nella risposta, l'argomento mi piace ma non ho tantissimo tempo.

Devi utilizzare delle primitive fornite dal sistema operativo che permettano la comunicazione di processi paralleli.

Purtroppo il C come linguaggio non fornisce assolutamente dei meccanismi di sincronizzazione, a differenza di molti linguaggi moderni come ad esempio Java.

Ad ogni modo ogni sistema operativo fornisce delle librerie multithreading di comunicazione / sincronizzazione tra processi.

Uno dei più noti meccanismi di sincronizzazione è chiamato MUTEX.

un MUTEX è un intero che può avere due valori, Acceso/Spento, 1/0 quello che vuoi.

Il sistema operativo mette a disposizione delle funzioni per governare questo mutex e garantisce che queste operazioni siano ATOMICHE, ovvero se un processo chiede accesso ad un MUTEX tutti gli altri non possono accedervi fintanto che l'insieme di operazioni necessarie alla gestione del MUTEX non sono completate, mentre invece se tu controlli una variabile globale con un meccanismo tipo semaforo=semaforo+1 in assembly avrai una roba del tipo

1) Carica semaforo in un registro
2) In un altro registro metti 1
3) Somma i registri
4) Trasferisci in memoria

... il sistema operativo potrebbe interrompere il tuo processo con conseguenze disastrose dopo ogni istruzione assembly.

Ogni SO ha le sue chiamate che non sono mai compatibili con gli altri sistemi, quindi per aiutarti bisognerebbe sapere su che sistema lavori.

Ad ogni modo in teoria le funzioni sono di solito del tipo:

MUTEX m = CreaUnMutex("Nome del Mutex", StatoIniziale);
MUTEX m = ApriUnMutex("Nome Del Mutex");
RichiediMutex(MUTEX m);
RilasciaMutex(MUTEX m);
EliminaMutex (m);

il tuo codice sarà del tipo:

codice:
MUTEX m;

int main(...)
{...
   MUTEX b = CreaUnMutex("B aspetta A", BLOCCATO);
   MUTEX a = CreaUnMutex("A aspetta B", APERTO);
   Processo A = LanciaIlProcesso(FuncA);
   Processo B = LanciaIlProcesso(FuncB);
   ... 
   AttendiFineDelProcesso(A);
   AttendiFineDelProcesso(B);
   EliminaIlMutex(a);
   EliminaIlMutex(b);
}

int FuncA()
{
     MUTEX a = ApriUnMUtex("A aspetta B");
     MUTEX b = ApriUnMUtex("B aspetta A");
    while(condizione){

    Faccio_le_cose_che_posso_fare_in_parallelo_con_B();
/*
aspetto che B finisca l'elaborazione precedente
*/
        RichiediIlMutex(a); 
/*
se sono in questo punto significa che B ha finito di lavorare e sta lavorando solo A
*/
        ...
        FaiQualcheElaborazione
        .  ..
        RilasciaIlMutex(b); // faccio partire B 
    }
}

int FuncB()
{
     MUTEX a = ApriUnMUtex("A aspetta B");
     MUTEX b = ApriUnMUtex("B aspetta A");
     while(condizione){

    Faccio_le_cose_che_posso_fare_in_parallelo_con_A();
          /*
aspetto che A finisca l'elaborazione precedente
*/
          RichiediIlMutex(b); 
        /* A questo punto A ha finito la sua elaborazione quindi non sta girando*/
        FaccioLeCoseCheDevoFareSoloDopoCheAHaFinito();
         RilascioIlMutex(a);
      }
}

//Salvo miei errori ed omissioni :D
Qua trovi una generalizzazione del classico problema del produttore e del consumatore con N produttori (nel tuo caso il processo A) ed M consumatori (nel tuo caso il processo B)

http://it.wikipedia.org/wiki/Problem...re/consumatore