úëðéåú
ãåâîà ìîùéîåú 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
%