6.6: Inter Thread communication

void* doSomeThing(void *arg) {
    unsigned long i = 0;

    int local_id; // new, per-thread variable                                    
    counter += 1;
    local_id = counter; // make a local copy of counter for this thread                                

    printf("  Job %d started\n", local_id);
    for(i=0; i<(0xFFFFFFFF);i++);
    printf("  Job %d finished\n", local_id);

    return NULL;
}

// Code that both threads will execute:
counter += 1;
local_id = counter;
// -----------------------------------

// Thread 1
counter += 1; // after this, counter == 1
    // Before Thread 1 can execute local_id = counter, it is paused by the CPU
    // Thread 2
    counter += 1; // after this, counter == 2
    local_id = counter; // thus, in Thread 2, local_id is correctly 2
// Here, the CPU switches back to Thread 1
// Thread 1
local_id = counter; // now, local_id is still 2, instead of 1... mission failed

// In simple pseudocode, counter += 1 might look like this:
int temp = counter + 1; // temp is for example the CPU register here, and "counter" is the value in memory
counter = temp; // the register value is written back out to the memory

// Code that both threads will execute:
int temp = counter + 1;
counter = temp;
// -----------------------------------

// Thread 1
int temp = counter + 1; // after this, Thread 1's temp register contains the value 1. The "counter" value in RAM is still 0.
    // Before Thread 1 can actually store this temporary register result in memory, the CPU gives control to Thread 2
    // Thread 2
    int temp = counter + 1; // "counter" was still 0 in RAM, so Thread 2's temp register now also contains the value 1
    counter = temp; // The "counter" value in RAM is now 1
// Here, the CPU switches back to Thread 1
// Thread 1
counter = temp; // The "counter" value in RAM is still 1

// Thread 1
// ... other code
b = x + 5;
// ... other code

    // Thread 2
    // ... other code
    x = 3 + z;
    // ... other code

int counter;
pthread_mutex_t counter_lock;                   /* THIS LINE HAS BEEN ADDED */

void* doSomeThing(void *arg) {
    unsigned long i = 0;

    int local_id;                               /* THIS LINE HAS BEEN ADDED */
    pthread_mutex_lock(&counter_lock);          /* THIS LINE HAS BEEN ADDED */
    counter += 1;
    local_id = counter;                         /* THIS LINE HAS BEEN ADDED */
    pthread_mutex_unlock(&counter_lock);        /* THIS LINE HAS BEEN ADDED */


    printf("  Job %d started\n", local_id);     /* THIS LINE HAS BEEN CHANGED */
    for(i=0; i<(0xFFFFFFFF);i++);
    printf("  Job %d finished\n", local_id);    /* THIS LINE HAS BEEN CHANGED */

    return NULL;
}

// Thread 1 wants to first read from the network, then write result to the hard disk
// Thread 2 wants to first read the contents of a file, then send it on the network

// Thread 1:
network.lock()
    // CPU pauses Thread 1 and activates Thread 2
    harddisk.lock()
// CPU pauses Thread 2 and activates Thread 1 again
harddisk.lock() // this will not complete, because Thread 2 is holding this lock already. Thread 1 has to wait
    // CPU pauses Thread 1 because it has to wait and activates Thread 2 again
    network.lock() // this will not complete, because Thread 1 is holding this lock already. Thread 2 has to wait

// Both threads are waiting endlessly AND also locking the network and the harddisk for any other threads that might arrive

// PSEUDOCODE!
mutex myLock;
int items_in_array = 0; 
int* array = malloc(sizeof(int) * 10);

void* producer() 
{
    while (true) 
    {
        bool itemStored = false;
        Item item = produceItem();

        while( !itemStored ) {

            lock( myLock );
            
            if( items_in_array < 10 ) {
                array[ items_in_array ] = item;
                items_in_array += 1;

                itemStored = true;
            }

            unlock( myLock );
        }
    }
}

// PSEUDOCODE!




void* consumer() 
{
    while (true) 
    {
        Item item = NULL;

        lock( myLock );
        
        if( items_in_array > 0 ) {
            item = array[ items_in_array - 1 ];
            items_in_array -= 1;
        }

        unlock( myLock );

        if( item != NULL ) {
            consumeItem(item);
        }
    }
}

// PSEUDOCODE!
mutex myLock;

semaphore fill_count;  
init(fill_count,  0);

semaphore empty_count; 
init(empty_count, 10);

int items_in_array = 0; 
int* array = malloc(sizeof(int) * 10);

void* producer() 
{
    while (true) 
    {
        Item item = produceItem();

        wait( empty_count ); // THIS IS NEW!

        lock( myLock );
        
        array[ items_in_array ] = item;
        items_in_array += 1;

        unlock( myLock );
        
        post( fill_count ); // THIS IS NEW!
    }
}

// PSEUDOCODE!


  


 





void* consumer() 
{
    while (true) 
    {
        Item item = NULL;

        wait( fill_count ); // THIS IS NEW! 

        lock( myLock );
        
        item = array[ items_in_array - 1 ];
        items_in_array -= 1;

        unlock( myLock );

        post( empty_count ); // THIS IS NEW! 

        consumeItem(item);
    }
}