pthreads
Rasskick i pthreads

Introduktion

Exempel: Tänk på att ha två trådar T1 och T2.

Hur upptäcker du dem?

Om samma variabel / resurs / minnesplats kan nås av flera trådar och åtminstone av tråden ändrar värdet på variabel / resurs / minnesplats , kan Race Condition uppstå. För om en tråd ändrar värdet på variabel / resurs / minnesplats och en annan tråd försöker läsa densamma får den inte det uppdaterade värdet.

Obs : Om alla trådar bara läser variabeln / resursen / minnesplatsen kommer inte Race Condition att inträffa.

Exempel: Programmet lider av racetillstånd

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

int x= 0;

void* fun(void* in)
{
    int i;
    for ( i = 0; i < 10000000; i++ )
    {
        x++;
    }
}

int main()
{
    pthread_t t1, t2;
    printf("Point 1 >> X is: %d\n", x);

    pthread_create(&t1, NULL, fun, NULL);
    pthread_create(&t2, NULL, fun, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    printf("Point 2 >> X is: %d\n", x);
    return 0;
}

Utmatningen på min skärm är:

Point 1 >> X is: 0
Point 2 >> X is: 9925047

Din produktion kommer att variera. Men det är säkert inte 20 000 000. Eftersom båda trådarna kör samma slinga och har global variabel int x;

for ( i = 0; i < 10000000; i++ )
{
   x++; 
}

Så det slutliga värdet på x i raden Point 2 >> X is: 9925047 bör vara 20 000 000. Men det är inte så.

Tillståndet för x kan ändras av en annan tråd under tiden mellan x läses och när det skrivs tillbaka.

Låt oss säga att en tråd hämtar värdet på x, men har inte lagrat det ännu. En annan tråd kan också hämta samma värde på x (eftersom ingen tråd har ändrat den ännu) och då skulle de båda lagra samma värde (x + 1) tillbaka i x!

Exempel:

Tråd 1: läser x, värdet är 7

Tråd 1: lägg till 1 till x, värdet är nu 8

Tråd 2: läser x, värdet är 7

Tråd 1: lagrar 8 i x

Tråd 2: lägger till 1 till x, värdet är nu 8

Tråd 2: lagrar 8 i x

Hur hanterar du dem?

Rasförhållanden kan undvikas genom att använda någon slags låsmekanism innan koden som får åtkomst till den delade resursen eller ömsesidig uteslutning.

Följande är modifierat program:

Exempel: Problem med lopptillstånd löst

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

int x= 0;
//Create mutex
pthread_mutex_t test_mutex;

void* fun(void* in)
{
    int i;
    for ( i = 0; i < 10000000; i++ )
    {
        //Lock mutex before going to change variable
        pthread_mutex_lock(&test_mutex);
        x++;
        //Unlock mutex after changing the variable
        pthread_mutex_unlock(&test_mutex);
    }
}

int main()
{
    pthread_t t1, t2;
    printf("Point 1 >> X is: %d\n", x);

    //Initlize mutex
    pthread_mutex_init(&test_mutex, NULL);

    pthread_create(&t1, NULL, fun, NULL);
    pthread_create(&t2, NULL, fun, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    //Destroy mutex after use
    pthread_mutex_destroy(&test_mutex);
    printf("Point 2 >> X is: %d\n", x);
    return 0;
}

Följande är utgången:

Point 1 >> X is: 0
Point 2 >> X is: 20000000

Här kommer svaret ut som 20 000 000 varje gång.

Obs! Det modifierade programmet, som är fritt från feltillstånd, kommer att ta mycket lång tid att utföra. Eftersom det finns överbelastning på mutex låsning.