úëðéåú ãåâîà ìîùéîåú pthreads

 

äúåëðéú äáàä îîçéùä éöéøä, äîúðä  åéöéàä ùì îùéîåú.  áî÷øä äæä éù ùúé îùéîåú ðåñôåú ìî÷åø òí àåúå ÷åã àáì òí ôøîèøéí ùåðéí.  àôùø ëîåáï äéä ìòùåú ÷åã ééçåãé ìëì îùéîä çãùä.

 

/* pthr1.c */

 

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
 
void *print_message_function( void *ptr );
 
main()
{
     pthread_t thread1, thread2;
     char *message1 = "Thread 1";
     char *message2 = "Thread 2";
     int  iret1, iret2;
 
    /* Create independent threads each of which will execute function */
 
     iret1 = pthread_create ( &thread1, NULL, print_message_function, (void*) message1);
     iret2 = pthread_create( &thread2, NULL, print_message_function, (void*) message2);
 
     /* Wait till threads are complete before main continues. Unless we  */
     /* wait we run the risk of executing an exit which will terminate   */
     /* the process and all threads before the threads have completed.   */
 
     pthread_join ( thread1, NULL);
     pthread_join( thread2, NULL); 
 
     printf("Thread 1 returns: %d\n",iret1);
     printf("Thread 2 returns: %d\n",iret2);
     exit(0);
}
 
void *print_message_function( void *ptr )
{
     char *message;
     message = (char *) ptr;
     printf("%s \n", message);
}

 

 

% cc –lpthread  pthr1.c

% ./a.out

Thread 1
Thread 2
Thread 1 returns: 0
Thread 2 returns: 0

%

 

äúåëðéú äáàä îîçéùä ùúòåôä ùì îùéîä âåøøú úòåôä ùì äàôìé÷öéä ëåìä, ìôçåú áîðâðåï äæä ùì úîéëä áîùéîåú:

 

/* thr_test1.c  - thread test */

 

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

 

void *print_message_function1( void *ptr );

void *print_message_function2( void *ptr );

 

main()

{

     pthread_t thread1, thread2;

     char *message1 = "Thread 1";

     char *message2 = "Thread 2";

     int  iret1, iret2;

 

    /* Create independent threads each of which will execute function */

 

     iret1 = pthread_create ( &thread1, NULL, print_message_function1,

(void*) message1);

     iret2 = pthread_create( &thread2, NULL, print_message_function2,

(void*) message2);

 

     /* Wait till threads are complete before main continues. Unless we 

*/

     /* wait we run the risk of executing an exit which will terminate  

*/

     /* the process and all threads before the threads have completed.  

*/

 

     pthread_join ( thread1, NULL);

     pthread_join( thread2, NULL);

 

     printf("Thread 1 returns: %d\n",iret1);

     printf("Thread 2 returns: %d\n",iret2);

     exit(0);

}

 

void *print_message_function1( void *ptr )

{

     char *message;

     message = (char *) ptr;

     printf("1:%s \n", message);

     sleep(3);

     printf("2:%s \n", message);

}

 

 

void *print_message_function2( void *ptr )

{

     char *message;

     int x =0;

     message = (char *) ptr;

     printf("1:%s \n", message);

     sleep(2);

     x = 100/x;

     printf("2:%s \n", message);

}

 

ôìè øéöä:

 

% cc -lpthread thr_test1.c

% ./a.out

1:Thread 1

1:Thread 2

Floating exception (core dumped)

%

 

ääãôñåú

2:Thread 1

2:Thread 2

 

ùì äîùéîåú åääãôñåú

 

Thread 1 returns: 0
Thread 2 returns: 0
 

ùì äúåëðéú äøàùéú ìà îúáöòåú, ëé òã àæ ëì äàôìé÷öéä ìà ÷ééîú ëáø.

 

äúåëðéú äáàä îîçéùä ùñéåîä ùì äúåëðéú äøàùéú âåøøú àú ñéåîä ùì ëì äàôìé÷öéä:

/* thr_test2.c  - thread test - does main termination terminate the entire

  application? */

 

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

 

void *print_message_function1( void *ptr );

void *print_message_function2( void *ptr );

 

main()

{

     pthread_t thread1, thread2;

     char *message1 = "Thread 1";

     char *message2 = "Thread 2";

     int  iret1, iret2;

 

    /* Create independent threads each of which will execute function */

 

     iret1 = pthread_create ( &thread1, NULL, print_message_function1,

(void*) message1);

     iret2 = pthread_create( &thread2, NULL, print_message_function2,

(void*) message2);

 

     /*   Do not wait for threads */

 

     /* pthread_join ( thread1, NULL); */

     /* pthread_join( thread2, NULL); */

 

     printf("Thread 1 returns: %d\n",iret1);

     printf("Thread 2 returns: %d\n",iret2);

     exit(0);

}

 

void *print_message_function1( void *ptr )

{

     char *message;

     message = (char *) ptr;

     printf("1:%s \n", message);

     sleep(3);

     printf("2:%s \n", message);

}

 

 

void *print_message_function2( void *ptr )

{

     char *message;

     int x =0;

     message = (char *) ptr;

     printf("1:%s \n", message);

     sleep(2);

     printf("2:%s \n", message);

}

 

ôìè øéöä:

 

% cc -lpthread thr_test2.c

math:/home3/ronn/OS > ./a.out

1:Thread 1

1:Thread 2

Thread 1 returns: 0

Thread 2 returns: 0

%

 

ääãôñåú

2:Thread 1

2:Thread 2

 

ìà îúáöòåú ø÷ îùåí ùäúåëðéú äøàùéú ñééîä ÷åãí.

äãáø îåîçù ëàùø îçæéøéí àú ä-join-éí, áúåëðéú äáàä:

/* thr_test3.c  - thread test - does main termination terminate the entire

  application? */

 

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

 

void *print_message_function1( void *ptr );

void *print_message_function2( void *ptr );

 

main()

{

     pthread_t thread1, thread2;

     char *message1 = "Thread 1";

     char *message2 = "Thread 2";

     int  iret1, iret2;

 

    /* Create independent threads each of which will execute function */

 

     iret1 = pthread_create ( &thread1, NULL, print_message_function1,

(void*) message1);

     iret2 = pthread_create( &thread2, NULL, print_message_function2,

(void*) message2);

 

     /*   Wait for threads */

 

     pthread_join ( thread1, NULL);

     pthread_join( thread2, NULL);

 

     printf("Thread 1 returns: %d\n",iret1);

     printf("Thread 2 returns: %d\n",iret2);

     exit(0);

}

 

void *print_message_function1( void *ptr )

{

     char *message;

     message = (char *) ptr;

     printf("1:%s \n", message);

     sleep(3);

     printf("2:%s \n", message);

}

 

 

void *print_message_function2( void *ptr )

{

     char *message;

     int x =0;

     message = (char *) ptr;

     printf("1:%s \n", message);

     sleep(2);

     printf("2:%s \n", message);

}

 

ôìè øéöä:

% cc -lpthread thr_test3.c

% ./a.out

1:Thread 1

1:Thread 2

2:Thread 2

2:Thread 1

Thread 1 returns: 0

Thread 2 returns: 0

%

 

äúåëðéú äáàä îîçéùä  àú äùéîåù áîðâðåï äðòéìåú:

/* mutex1.c */

 

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

 

void *functionC();

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;

int  counter = 0;

 

int main()

{

   int rc1, rc2;

   pthread_t thread1, thread2;

 

   /* Create independent threads each of which will execute functionC */

 

   if( (rc1=pthread_create( &thread1, NULL, &functionC, NULL)) )

   {

      printf("Thread creation failed: %d\n", rc1);

   }

 

   if( (rc2=pthread_create( &thread2, NULL, &functionC, NULL)) )

   {

      printf("Thread creation failed: %d\n", rc2);

   }

 

   /* Wait till threads are complete before main continues. Unless we  */

   /* wait we run the risk of executing an exit which will terminate   */

   /* the process and all threads before the threads have completed.   */

 

   pthread_join( thread1, NULL);

   pthread_join( thread2, NULL);

 

   exit(0);

}

 

void *functionC()

{

   pthread_mutex_lock( &mutex1 );

   counter++;

   printf("Counter value: %d\n",counter);

   pthread_mutex_unlock( &mutex1 );

}

 

 

ôìè øéöä:

% cc –lpthread mutex1.c

% ./a.out

Counter value: 1

Counter value: 2

%

 

äúåëðéú äáàä îîçéùä àõ äùéîåù á-join ìäîúðä ìñéåí îùéîåú:

 

/* join1.c */

 

#include <stdio.h>

#include <pthread.h>

 

#define NTHREADS 10

void *thread_function();

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;

int  counter = 0;

 

main()

{

   pthread_t thread_id[NTHREADS];

   int i, j;

 

   for(i=0; i < NTHREADS; i++)

   {

      pthread_create( &thread_id[i], NULL, &thread_function, NULL );

   }

 

   for(j=0; j < NTHREADS; j++)

   {

      pthread_join( thread_id[j], NULL);

   }

 

   /* Now that all threads are complete I can print the final result.    

*/

   /* Without the join I could be printing a value before all the threads

*/

   /* have been completed.                                                

*/

 

   printf("Final counter value: %d\n", counter);

}

 

void *thread_function()

{

   printf("Thread number %ld\n", pthread_self());

   pthread_mutex_lock( &mutex1 );

   counter++;

   pthread_mutex_unlock( &mutex1 );

}

 

ôìè øéöä:

 

% cc -lpthread join1.c

% ./a.out

Thread number 1082399936

Thread number 1090788416

Thread number 1099176896

Thread number 1116941120

Thread number 1125329600

Thread number 1133718080

Thread number 1142106560

Thread number 1150495040

Thread number 1158883520

Thread number 1167272000

Final counter value: 10

%

 

äúåëðéú äáàä îîçéùä îä ÷åøä àí ìà òåùéí îðâðåï ðòéìåú: éù ëàï áð÷ ùì 2 ì÷åçåú àçã òí äåï ùì 400 åùðé ùì 250, åëì äæîï îòáéøéí ñëåîéí îì÷åç àçã ìùðé, åáî÷áéì îãôéñéí àú äñê äëåìì ùì äëñó ááð÷. ìëàåøä äñê äëåìì ááð÷ öøê ìäéåú ÷áåò åìòîåã òì 650, àáì æä ìà úîéã îä ùîåãôñ, ëé ìòéúéí ä÷åã îåôñ÷ áàîöò áéöåò òãëåï àå áàîöò äãôñä.

 

äúåëðéú:

// bank1.c

 

#include <stdio.h>

#include <pthread.h>

 

#define NO_OF_CLIENTS 2

#define TRUE 1

 

typedef struct bank_client

{

  char name[80];

  int amount;

 

} BANK_CLIENT,  *BANK_CLIENT_PTR;

 

static BANK_CLIENT bank[NO_OF_CLIENTS]= {{"yossi", 250}, {"shimon", 400}};

 

void *tradeForever()

  {

    int sums[] ={50, 100, -75, -50, 125, -100, -50};

    int n = 7;

    int index = 0;

    int amountToTrade;

    int fromAmount;

 

   while(TRUE)

   {

    amountToTrade = sums[index];

    index = (index + 1)%n;

    bank[0].amount -= amountToTrade;

    bank[1].amount += amountToTrade;

 

   } // while

 

  } // tradeForever

 

 void *checkTotalAmountForever()

  {

   while(TRUE)

   {

    printf("Total amount in Bank: %d\n",

          bank[0].amount + bank[1].amount);

 

   } // while

 

  } // checkTotalAmountForever

 

 

  int main()

  {

   pthread_t thread_no1, thread_no2;

 

   pthread_create(&thread_no1, NULL, tradeForever, NULL);

   pthread_create(&thread_no2, NULL, checkTotalAmountForever, NULL);

 

   pthread_join( thread_no1, NULL);

   pthread_join( thread_no2, NULL);

 

 

  } // Main

 

ôìè øéöä:

 

% cc -lpthread bank1.c

% ./a.out | grep –v 650

Total amount in Bank: 700

Total amount in Bank: 700

Total amount in Bank: 600

Total amount in Bank: 550

Total amount in Bank: 525

Total amount in Bank: 750

Total amount in Bank: 550

Total amount in Bank: 750

Total amount in Bank: 550

Total amount in Bank: 600

Total amount in Bank: 550

Total amount in Bank: 750

Total amount in Bank: 525

Total amount in Bank: 600

Total amount in Bank: 550

 

%

 

äúåëðéú äáàä ãåàâú ìëê ùúåëï äñëåîéí ááð÷ ìà é÷øàå îäøâò ùäåçì äòãëåï ùì ääòáøä òã ùæå úñúééí, ò"é ùéîåù áîðâðåï äðòéìåú:

// bank2.c

 

#include <stdio.h>

#include <pthread.h>

 

#define NO_OF_CLIENTS 2

#define TRUE 1

 

typedef struct bank_client

{

  char name[80];

  int amount;

 

} BANK_CLIENT,  *BANK_CLIENT_PTR;

 

static BANK_CLIENT bank[NO_OF_CLIENTS]= {{"yossi", 250}, {"shimon", 400}};

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;

 

 

 

void *tradeForever()

  {

    int sums[] ={50, 100, -75, -50, 125, -100, -50};

    int n = 7;

    int index = 0;

    int amountToTrade;

    int fromAmount;

 

   while(TRUE)

   {

    amountToTrade = sums[index];

    index = (index + 1)%n;

   

    pthread_mutex_lock( &mutex1 );

    bank[0].amount -= amountToTrade;

    bank[1].amount += amountToTrade;

    pthread_mutex_unlock( &mutex1 );

   } // while

 

  } // tradeForever

 

 void *checkTotalAmountForever()

  {

   while(TRUE)

   {

    pthread_mutex_lock( &mutex1 );

 

    printf("Total amount in Bank: %d\n",

          bank[0].amount + bank[1].amount);

 

    pthread_mutex_unlock( &mutex1 );

 

   } // while

 

  } // checkTotalAmountForever

 

 

  int main()

  {

   pthread_t thread_no1, thread_no2;

 

   pthread_mutex_init(&mutex1, NULL);

   pthread_create(&thread_no1, NULL, tradeForever, NULL);

   pthread_create(&thread_no2, NULL, checkTotalAmountForever, NULL);

 

   pthread_join( thread_no1, NULL);

   pthread_join( thread_no2, NULL);

 

  } // Main

 

äôìè áúåëðéú äæå éãôéñ ñê ëåìì ùì äçùáåðåú àê åø÷ ë-650, ëîå ùöøéê.

 

 

 

 

 

äúåëðéú äáàä îîçéùä ùéîåù áîùúðé úðàé.

äéà îîîùú äãôñä îùåúôú ùì ðúåï, thread àçã îãôéñ àåúå áòøëéí 1 òã 2 å-7 òã 10   åäùðé áéï 3 ì-6.

 

 

/* cond1.c */

 

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

 

pthread_mutex_t count_mutex     = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;

pthread_cond_t  condition_cond  = PTHREAD_COND_INITIALIZER;

 

void *functionCount1();

void *functionCount2();

int  count = 0;

#define COUNT_DONE  10

#define COUNT_HALT1  3

#define COUNT_HALT2  6

 

main()

{

   pthread_t thread1, thread2;

 

   pthread_create( &thread1, NULL, &functionCount1, NULL);

   pthread_create( &thread2, NULL, &functionCount2, NULL);

   pthread_join( thread1, NULL);

   pthread_join( thread2, NULL);

 

   exit(0);

}

 

void *functionCount1()

{

   for(;;)

   {

      pthread_mutex_lock( &condition_mutex );

      if( count >= COUNT_HALT1 && count <= COUNT_HALT2 )

         pthread_cond_wait( &condition_cond, &condition_mutex );

      else

          pthread_cond_signal( &condition_cond );

      pthread_mutex_unlock( &condition_mutex );

 

      if( count > COUNT_HALT1 || count < COUNT_HALT2 )

      {

        pthread_mutex_lock( &count_mutex );

        printf("Counter value functionCount1: %d\n",count);

        count++;

      } /* if */

      pthread_mutex_unlock( &count_mutex );

      if(count >= COUNT_DONE)

      {

        printf("Counter value functionCount1: %d\n",count);

       return(NULL);

      } /*if */

 

    }

}

 

void *functionCount2()

{

    for(;;)

    {

      pthread_mutex_lock( &condition_mutex );

      if( count >= COUNT_HALT1 && count <= COUNT_HALT2 )

          pthread_cond_signal( &condition_cond );

      else

         pthread_cond_wait( &condition_cond, &condition_mutex );

 

 

      pthread_mutex_lock( &count_mutex );

      if( count >= COUNT_HALT1 && count <= COUNT_HALT2 )

      {

       printf("Counter value functionCount2: %d\n",count);

       count++;

      } /* if */

       pthread_mutex_unlock( &count_mutex );

 

      pthread_mutex_unlock( &condition_mutex );

 

      if(count >= COUNT_DONE)

           return(NULL);

    }

 

} /* functionCount2 */

 

 

 

ôìè øéöä:

 

 

% cc -lpthread cond1.c

% ./a.out

Counter value functionCount1: 1

Counter value functionCount1: 2

Counter value functionCount1: 3

Counter value functionCount2: 4

Counter value functionCount2: 5

Counter value functionCount2: 6

Counter value functionCount1: 7

Counter value functionCount1: 8

Counter value functionCount1: 9

Counter value functionCount1: 10

%

 

úåëðéú ðåñôú äéà úåëðéú äîîîùú àú äãåâîä ä÷ìàñéú ùì îùàá îùåúó ùìí, àçã îãôéñ åäùðé î÷ãí, áéï 0 ì-19:

 

/* th_ex5.c */

 

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

 

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;

pthread_cond_t  cond1  = PTHREAD_COND_INITIALIZER;

pthread_cond_t  cond2  = PTHREAD_COND_INITIALIZER;

 

void *producer();

void *consumer();

 

int  n = 0;

int flag = 0;

 

int main()

{

   pthread_t thread1, thread2;

 

   pthread_create( &thread1, NULL, &producer, NULL);

   pthread_create( &thread2, NULL, &consumer, NULL);

   pthread_join( thread1, NULL);

   pthread_join( thread2, NULL);

 

   exit(0);

}

 

void *producer()

{

  int i;

 

   for(i=0;i < 20;i++)

   {

      pthread_mutex_lock( &mutex1 );

      if (flag == 0)

      {

         flag = 2;

         pthread_cond_wait( &cond1, &mutex1 );

      } /* if */

      n++;

      pthread_mutex_unlock( &mutex1 );

      pthread_mutex_lock( &mutex2 );

      if (flag == 3)

      {

        flag = 0;

        pthread_cond_signal(&cond2);

      } /* if */

      flag = 0;

      pthread_mutex_unlock( &mutex2 );

 

    } /* for */

} /* producer */

 

void *consumer()

{

 int i;

 

   for(i=0;i < 20;i++)

   {

      pthread_mutex_lock( &mutex1 );

      printf("n = %d\n", n);

      if (flag == 2)

      {

         flag = 1;

         pthread_cond_signal(&cond1);

      } /* if */

      flag = 1;

      pthread_mutex_unlock( &mutex1 );

      pthread_mutex_lock( &mutex2 );

      if (flag == 1)

      {

        flag = 3;

        pthread_cond_wait( &cond2, &mutex2 );

      } /* if */

      pthread_mutex_unlock( &mutex2 );

 

    } /* for */

 

}/* consumer */

 

 

 

ôìè øéöä:

 

%  cc –lpthread th_ex5.c

./a.out

n = 0

n = 1

n = 2

n = 3

n = 4

n = 5

n = 6

n = 7

n = 8

n = 9

n = 10

n = 11

n = 12

n = 13

n = 14

n = 15

n = 16

n = 17

n = 18

n = 19

%