Synchronizing Threads with POSIX Semaphores

futuregod

       
        文件:posixsem.tar.bz2
        大小:0KB
        下载:
下载
       
                Synchronizing Threads with POSIX Semaphores

Why semaphores?

Posix semaphores are easy to use

• 
  sem_init
  
• 
  sem_wait
  
• 
  sem_post
  
• 
  sem_getvalue
  
• 
  sem_destroy
  

Exercises
  
1
  
2
  
3
  
4
Now it is time to take a look at some code that does something a little
unexpected. The program
threadadd.c
creates
two new threads, both of which increment a global
variable called [color="blue"]count exactly NITER, with
NITER = 1,000,000.
But the program produces unexpected results.
[color="brown"]Exercise 1. Create a directory called
posixsem in your class Unix directory. Download  
in this directory the code
threadadd.c

and compile it using
     gcc threadadd.c -o threadadd -lpthread
Run the executable threadadd and observe the ouput. Try it on
both tanner and felix.
Quite unexpected! Since count starts at 0, and both
threads
increment it NITER times, we should see count equal
to 2*NITER at the end of the program. Something fishy is going on here.
Threads can greatly simplify writing elegant and efficient programs. However,
there are problems when multiple threads share a common address
space, like the variable count in our earlier example.
To understand what might happen, let us analyze this simple piece of code:
      THREAD 1                THREAD 2
      a = data;               b = data;
      a++;                    b--;
      data = a;               data = b;
Now if this code is executed serially (for instance, THREAD 1 first and then
THREAD 2),
there are no problems. However threads execute in an arbitrary order, so consider
the following situation:
Thread 1Thread 2
data
a = data;
---
0
a = a+1;
---
0
---
b = data;  // 0
0
---
b = b + 1;0
data = a;  // 1
---
1
---
data = b;  // 1
1
So data could end up +1, 0, -1, and there is NO WAY to
know which value! It is completely non-deterministic!
The solution to this is to provide functions that will block a thread
if another thread is accessing data that it is using.
Pthreads may use semaphores to achieve this.
[color="brown"]Posix semaphores
All POSIX semaphore functions and types are prototyped or defined in
[color="blue"]semaphore.h. To define a semaphore object, use
      sem_t sem_name;
To initialize a semaphore, use sem_init():
      int sem_init(sem_t *sem, int pshared, unsigned int value);

•    [color="brown"]sem points to a semaphore object to initialize
  
•    [color="brown"]pshared is a flag indicating whether or not the semaphore should
     be shared with fork()ed processes. LinuxThreads does not currently
     support shared semaphores
  
•    [color="brown"]value is an initial value to set the semaphore to
  

Example of use:
[color="blue"]      sem_init(&sem_name, 0, 10);
To wait on a semaphore, use sem_wait:
      int sem_wait(sem_t *sem);
Example of use:
      sem_wait(&sem_name);

•    sem_wait is an implementation of the DOWN operation
  discussed in class.-->
  If the value of the semaphore is negative, the calling process blocks; one of the blocked
  processes wakes up when another process calls sem_post.

To increment the value of a semaphore, use sem_post:

      int sem_post(sem_t *sem);
Example of use:
      sem_post(&sem_name);

• sem_post is an implementation of the UP operation
  discussed in class. -->
  It increments the value of the semaphore and wakes up a blocked process waiting on the
  semaphore, if any.
  

To find out the value of a semaphore, use
      int sem_getvalue(sem_t *sem, int *valp);

•    gets the current value of sem and places it in the location pointed to
     by [color="brown"]valp
  

Example of use:
      int value; [color="blue"]
      sem_getvalue(&sem_name, &value);
      printf("The value of the semaphors is %d\n", value);
To destroy a semaphore, use
      int sem_destroy(sem_t *sem);

•    destroys the semaphore; no threads should be waiting on the semaphore
     if its destruction is to succeed.
  

Example of use:
[color="blue"]     sem_destroy(&sem_name);
[color="brown"]Using semaphores - a short example
Consider the problem we had before and now let us use semaphores:

      Declare the semaphore global (outside of any funcion):
            sem_t mutex;
      Initialize the semaphore in the main function:
     
            sem_init(&mutex, 0, 1);
Thread 1Thread 2
data
sem_wait (&mutex);
---
0
---
sem_wait (&mutex);
0
a = data;
/* blocked */
0
a = a+1;
/* blocked */
0
data = a;
/* blocked */
1
sem_post (&mutex);                     
/* blocked */
1         
/* blocked */
b = data;
1
/* blocked */
b = b + 1;
1
/* blocked */
data = b;
2
/* blocked */
sem_post (&mutex);
2         
[data is fine.  The data race is gone.]
[color="brown"]Exercise 2.Use the example above
as a guide to fix the program
threadadd.c
, so that
the program always produces the expected output (the value
2*NITER).
To compile a program that uses pthreads and posix semaphores, use
[color="blue"]     gcc -o filename filename.c -lpthread -lrt
[color="brown"]Exercise 3.
Download this (incomplete)
producer-consumer
code in your posixsem directory (call it PC.c).
The producer and the consumer share a buffer with four character slots.
Extend this code to implement a solution to the producer
consumer problem using Posix threads and semaphores. Assume
that there is only one producer and one consumer. The output of your code should be
similar to the following:
      Producing A ...
      Producing B ...
      Producing C ...
      Producing D ...
      ------> Consuming A ...
      ------> Consuming B ...
      ------> Consuming C ...
      ------> Consuming D ...
      Producing E ...
      Producing F ...
      Producing G ...
      Producing H ...
      ------> Consuming E ...
      ------> Consuming F ...
      ------> Consuming G ...
      ------> Consuming H ...
      Producing I ...
      Producing J ...
      ------> Consuming I ...
      ------> Consuming J ...
To compile a program that uses pthreads and posix semaphores, use
[color="blue"]     gcc -o filename filename.c -lpthread -lrt
[color="brown"]Exercise 4. Modify the code from exercise 3 to work with
multiple producers and multiple consumers. Create three producers and three
consumers in the main function and try to interleave their execution by making them sleep
for a while.  Comment well your code.
Compile and run your program and observe the
output. Label each line in the output by the identifier for each producer and consumer (P1, P2,
P3, C1, C2, C3). The output of your program should be similar to the following:
      [P1] Producing A ...
      [P1] Producing B ...
       ------> [C1] Consuming A ...
       ------> [C1] Consuming B ...
      [P2] Producing A ...
      [P2] Producing B ...
       ------> [C2] Consuming A ...
       ------> [C2] Consuming B ...
      [P3] Producing A ...
      [P3] Producing B ...
       ------> [C3] Consuming A ...
       ------> [C3] Consuming B ...
      [P1] Producing C ...
      [P1] Producing D ...
       ------> [C1] Consuming C ...
       ------> [C1] Consuming D ...
      [P2] Producing C ...
      [P2] Producing D ...
       ------> [C2] Consuming C ...
       ------> [C2] Consuming D ...
      [P3] Producing C ...
      [P3] Producing D ...
       ------> [C1] Consuming C ...
      [P2] Producing E ...
       ------> [C2] Consuming D ...
      [P3] Producing E ...
       ------> [C3] Consuming E ...
       ------> [C3] Consuming E ...
      [P1] Producing E ...
       ------> [C3] Consuming E ...
      [P2] Producing F ...
       ------> [C2] Consuming F ...
      [P3] Producing F ...
       ------> [C1] Consuming F ...
      [P1] Producing F ...
       ------> [C3] Consuming F ...
               
               
               
               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u/16030/showart_1715682.html