華南理工大學(xué)研究生課程(操作系統(tǒng)與系統(tǒng)編程)講義06 Thread

1、Thread Benefits of thread Simplify handle event Share memory and file descriptors Throughput can be improved Improved response time Process items - Address space- Global variables- Open files,- Current working directory- Timers- Signals- Semaphores- Accounting information- User and group IdsThread i

2、tems - Thread ID- Program counter - Stack (for local variables and return addresses)- State- Register set- Priority- ErrnoThread Identification A thread ID is represented by the pthread_t data type - Linux 2.4.22 : unsigned long integer - Solaris 9 : unsigned integer. - FreeBSD 5.2.1 and Mac OS X 10

3、.3 : pointer to the pthread structure for the pthread_t data type. int pthread_equal(pthread_t tid1, pthread_t tid2) pthread_t pthread_self(void)Thread CreationAdditional threads created by pthread_create function:#include int pthread_create ( pthread_t *tid, const pthread_attr_t *attr, void * (*fun

4、c) (void *), void *arg);- tid is the thread ID (returned by the call)- attr attributes: initial stack size, priority, should be a daemon thread or notspecify these attributes by initializing a pthread_attr_t variable.default:NULL - func:address of thread start function. - arg points to a set of para

5、meters to be passed to the function when it is called. return value from pthread functions is either 0: OK, positive number (Exxx):Example of threadpthread_t ntid; void printids(const char *s) pid_t pid; pthread_t tid; pid = getpid(); tid = pthread_self(); printf(%s pid %u tid %u (0 x%x)n, s, (unsig

6、ned int)pid, (unsigned int)tid, (unsigned int)tid); void * thr_fn(void *arg) printids(new thread: ); return(void *)0); Example of threadint main(void) int err; err = pthread_create(&ntid, NULL, thr_fn, NULL); if (err != 0) err_quit(cant create thread: %sn, strerror(err); printids(main thread:);

7、sleep(1); exit(0); Result:./a.out new thread: pid 6628 tid 1026 (0 x402) main thread: pid 6626 tid 1024 (0 x400) Thread Termination Any thread within a process calls exit, _Exit, or _exit, = the entire process terminates. Defaultly, a signal sent to a thread will terminate the entire process Thread

8、TerminationSimply return from the start routine. The return value is the threads exit code.Canceled by another thread in the same process.Call pthread_exit. void pthread_exit(void *rval_ptr); rval_ptr : typeless pointer, available to other threads in the process by calling the pthread_join function.

9、Waiting for a thread One thread can wait for another thread to terminate by calling the pthread_join function: (similar to waitpid() for process) #include int pthread_join (pthread_t tid, void *status); - tid is thread id of the process we want to wait - *status, if not null, takes the return value

10、from the thread as a pointer to some object Incorrect use of pthread_exit argumentstruct foo int a, b, c, d; ; void printfoo(const char *s, const struct foo *fp) printf(s); printf( structure at 0 x%xn, (unsigned)fp); printf( foo.a = %dn, fp-a); printf( foo.b = %dn, fp-b); printf( foo.c = %dn, fp-c);

11、 printf( foo.d = %dn, fp-d); Incorrect use of pthread_exit argumentvoid * thr_fn1(void *arg) struct foo foo = 1, 2, 3, 4; printfoo(thread 1:n, &foo); pthread_exit(void *)&foo); void * thr_fn2(void *arg) printf(thread 2: ID is %dn, pthread_self(); pthread_exit(void *)0); Incorrect use of pthr

12、ead_exit argumentint main(void) int err; pthread_t tid1, tid2; struct foo *fp; err = pthread_create(&tid1, NULL, thr_fn1, NULL); if (err != 0) err_quit(cant create thread 1: %sn, strerror(err); err = pthread_join(tid1, (void *)&fp); if (err != 0) err_quit(cant join with thread 1: %sn, strerr

13、or(err); sleep(1); printf(parent starting second threadn); err = pthread_create(&tid2, NULL, thr_fn2, NULL); if (err != 0) err_quit(cant create thread 2: %sn, strerror(err); sleep(1); printfoo(parent:n, fp); exit(0); Incorrect use of pthread_exit argumentResult:$ ./a.out $ ./a.out thread 1: thre

14、ad 1: structure at 0 x409a2abc structure at 0 x409a2abc foo.a = 1 foo.a = 1 foo.b = 2 foo.b = 2 foo.c = 3 foo.d = 4 foo.c = 3 foo.d = 4 parent starting second thread parent starting second thread thread 2: thread 2: ID is 32770 ID is 32770 parent: parent: structure at 0 x409a2abc structure at 0 x409

15、a2abc foo.a = 0 foo.a = 0 foo.b = 32770 foo.b = 32770 foo.c = 1075430560 foo.c = 1075430560 foo.d = 1073937284 foo.d = 1073937284 Detach The term detaching means cleaning up after a thread and reclaiming its storage space. Two ways to achieve this: - calling the pthread_join function and waiting for

16、 it to terminate- setting the detach attribute of the thread (either at creation time or dynamically by calling the pthread_detach function: (a thread is either joinable or detached)Exit functionsvoid pthread_cleanup_push(void (*rtn)(void *), void *arg); void pthread_cleanup_pop(int execute); Implem

17、ented as macros Similar to atexit function, schedules the cleanup function, rtn, called with the single argument, arg, when the thread performs one of the following actions: - Makes a call to pthread_exit - Responds to a cancellation request - Makes a call to pthread_cleanup_pop with a nonzero If th

18、e execute argument is zero, the cleanup function is not called. In either case, pthread_cleanup_pop removes the cleanup handler established by the last call to pthread_cleanup_push.Comparison of process and thread primitivesMutexes: Locking and Unlocking Mutexes are used to provide mutually exclusiv

19、e access to critical sections. Posix mutexs are variables declared to be of type pthread_mutex_t Statically allocated mutexes can be initialized to the constant PTHREAD_MUTEX_INITIALIZER: static pthread_mutex_t mtxlock = PTHREAD_MUTEX_INITIALIZER;( mutex status is locked or unlocked)Mutexes Dynamica

20、lly allocated mutexes can be initialized at run time by calling the pthread_mutex_init function. Lock and unlock functions: #include int pthread_mutex_lock(pthread_mutex_t *mptr); (if the mutex is locked by some other thread, then we are blocked until the mutex is unlocked) int pthread_mutex_trylock

21、 (pthread_mutex_t *mptr); int pthread_mutex_unlock (pthread_mutex_t *mptr); * trylock returns EBUSY if the mutex is already lockedMutexes The normal usage: pthread_mutex_lock (the_mutex);. Critical Section pthread_mutex_unlock (the_mutex);Mutex example Two threads that increment a global variable in

22、correctly See: example01.c Two threads that increment a global variable correctly See: threads/example02.cTo compile those programs cc progrm -lpthread example01.c(1/2)#include pthread.h #define NLOOP 5000 int counter; /* incremented by threads */ void *doit(void *); int main(int argc, char *argv) p

23、thread_t tidA, tidB; pthread_create(&tidA, NULL, &doit, NULL); pthread_create(&tidB, NULL, &doit, NULL); /* wait for both threads to terminate */ pthread_join(tidA, NULL); pthread_join(tidB, NULL); exit(0); example01.c(2/2)void * doit(void *vptr) int i, val; /*Each thread fetches, pr

24、ints, and increments the counter NLOOP times. The value of the counter should increase monotonically. */ for (i = 0; i NLOOP; i+) val = counter; printf(%d: %dn, pthread_self(), val + 1); counter = val + 1; return (NULL);example02.c(1/2)#include pthread.h #define NLOOP 5000 int counter; /* incremente

25、d by threads */ pthread_mutex_t counter_mutex =PTHREAD_MUTEX_INITIALIZER; void *doit(void *); int main(int argc, char *argv) pthread_t tidA, tidB; thread_create(&tidA, NULL, &doit, NULL); thread_create(&tidB, NULL, &doit, NULL); /* wait for both threads to terminate */ thread_join(ti

26、dA, NULL); thread_join(tidB, NULL); exit(0); example02.c(2/2)void * (void *vptr) int i, val; /* Each thread fetches, prints, and increments the counter NLOOP times. The value of the counter should increase monotonically. */ for (i = 0; i NLOOP; i+) pthread_mutex_lock(&counter_mutex); val = count

27、er; printf(%d: %dn, pthread_self(), val + 1); counter = val + 1; pthread_mutex_unlock(&counter_mutex); return (NULL); Reader-Write lock locked in read mode locked in write mode Unlocked Apis:int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

28、 int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); Condition Variables: Waiting and Signaling A mutex is for locking and a condition variable is for waiting. A condition variable is a variable of type: pthread_cond_t The associated functions are:#include int pthread_cond_wait(pthread_cond_t *cptr

29、, pthread_mutex_t *mptr); int pthread_cond_signal( pthread_cond_t *cptr);(both return zero on success, nonzero on error)Condition Variables A condition variable is always associated with a mutex.Condition variable is a signaling mechanism associated with a mutex. When a thread waits on a condition v

30、ariable, its lock on the associated mutex is released. When the thread successfully returns from the wait, it again holds the lock.General structure of the code that waits on a condition variable:struct pthread_mutex_tmutex;pthread_cond_tcond;/* variables for maintaining the condition */ varx = PTHR

31、EAD_MUTEX_INITIALIZER, initialize mutexPTHREAD_COND_INITIALIZER, initialize condition var ; pthread_mutex_lock(&var.mutex);while (condition is false)pthread_cond_wait(&var.cond, &var.mutex); modify condition.pthread_mutex_unlock(&var.mutex);General structure of the code that signals a condition variabl