apue学习笔记（第十二章 线程控制）

 1 #include "apue.h"
 2 #include <pthread.h>
 3 
 4 int
 5 makethread(void *(*fn)(void *), void *arg)
 6 {
 7     int                err;
 8     pthread_t        tid;
 9     pthread_attr_t    attr;
10 
11     err = pthread_attr_init(&attr);
12     if (err != 0)
13         return(err);
14     err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
15     if (err == 0)
16         err = pthread_create(&tid, &attr, fn, arg);
17     pthread_attr_destroy(&attr);
18     return(err);
19 }

 1 #include <limits.h>
 2 #include <string.h>
 3 
 4 #define MAXSTRINGSZ    4096
 5 
 6 static char envbuf[MAXSTRINGSZ];
 7 
 8 extern char **environ;
 9 
10 char *
11 getenv(const char *name)
12 {
13     int i, len;
14 
15     len = strlen(name);
16     for (i = 0; environ[i] != NULL; i++) {
17         if ((strncmp(name, environ[i], len) == 0) &&
18           (environ[i][len] == ‘=‘)) {
19             strncpy(envbuf, &environ[i][len+1], MAXSTRINGSZ-1);
20             return(envbuf);
21         }
22     }
23     return(NULL);
24 }

 1 #include <string.h>
 2 #include <errno.h>
 3 #include <pthread.h>
 4 #include <stdlib.h>
 5 
 6 extern char **environ;
 7 
 8 pthread_mutex_t env_mutex;
 9 
10 static pthread_once_t init_done = PTHREAD_ONCE_INIT;
11 
12 static void
13 thread_init(void)
14 {
15     pthread_mutexattr_t attr;
16 
17     pthread_mutexattr_init(&attr);
18     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
19     pthread_mutex_init(&env_mutex, &attr);
20     pthread_mutexattr_destroy(&attr);
21 }
22 
23 int
24 getenv_r(const char *name, char *buf, int buflen)
25 {
26     int i, len, olen;
27 
28     pthread_once(&init_done, thread_init);
29     len = strlen(name);
30     pthread_mutex_lock(&env_mutex);
31     for (i = 0; environ[i] != NULL; i++) {
32         if ((strncmp(name, environ[i], len) == 0) &&
33           (environ[i][len] == ‘=‘)) {
34             olen = strlen(&environ[i][len+1]);
35             if (olen >= buflen) {
36                 pthread_mutex_unlock(&env_mutex);
37                 return(ENOSPC);
38             }
39             strcpy(buf, &environ[i][len+1]);
40             pthread_mutex_unlock(&env_mutex);
41             return(0);
42         }
43     }
44     pthread_mutex_unlock(&env_mutex);
45     return(ENOENT);
46 }

 1 #include <limits.h>
 2 #include <string.h>
 3 #include <pthread.h>
 4 #include <stdlib.h>
 5 
 6 #define MAXSTRINGSZ    4096
 7 
 8 static pthread_key_t key;
 9 static pthread_once_t init_done = PTHREAD_ONCE_INIT;
10 pthread_mutex_t env_mutex = PTHREAD_MUTEX_INITIALIZER;
11 
12 extern char **environ;
13 
14 static void
15 thread_init(void)
16 {
17     pthread_key_create(&key, free);
18 }
19 
20 char *
21 getenv(const char *name)
22 {
23     int        i, len;
24     char    *envbuf;
25 
26     pthread_once(&init_done, thread_init);
27     pthread_mutex_lock(&env_mutex);
28     envbuf = (char *)pthread_getspecific(key);
29     if (envbuf == NULL) {
30         envbuf = malloc(MAXSTRINGSZ);
31         if (envbuf == NULL) {
32             pthread_mutex_unlock(&env_mutex);
33             return(NULL);
34         }
35         pthread_setspecific(key, envbuf);
36     }
37     len = strlen(name);
38     for (i = 0; environ[i] != NULL; i++) {
39         if ((strncmp(name, environ[i], len) == 0) &&
40           (environ[i][len] == ‘=‘)) {
41             strncpy(envbuf, &environ[i][len+1], MAXSTRINGSZ-1);
42             pthread_mutex_unlock(&env_mutex);
43             return(envbuf);
44         }
45     }
46     pthread_mutex_unlock(&env_mutex);
47     return(NULL);
48 }

 1 #include "apue.h"
 2 #include <pthread.h>
 3 
 4 pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
 5 pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
 6 
 7 void
 8 prepare(void)
 9 {
10     int err;
11 
12     printf("preparing locks...\n");
13     if ((err = pthread_mutex_lock(&lock1)) != 0)
14         err_cont(err, "can‘t lock lock1 in prepare handler");
15     if ((err = pthread_mutex_lock(&lock2)) != 0)
16         err_cont(err, "can‘t lock lock2 in prepare handler");
17 }
18 
19 void
20 parent(void)
21 {
22     int err;
23 
24     printf("parent unlocking locks...\n");
25     if ((err = pthread_mutex_unlock(&lock1)) != 0)
26         err_cont(err, "can‘t unlock lock1 in parent handler");
27     if ((err = pthread_mutex_unlock(&lock2)) != 0)
28         err_cont(err, "can‘t unlock lock2 in parent handler");
29 }
30 
31 void
32 child(void)
33 {
34     int err;
35 
36     printf("child unlocking locks...\n");
37     if ((err = pthread_mutex_unlock(&lock1)) != 0)
38         err_cont(err, "can‘t unlock lock1 in child handler");
39     if ((err = pthread_mutex_unlock(&lock2)) != 0)
40         err_cont(err, "can‘t unlock lock2 in child handler");
41 }
42 
43 void *
44 thr_fn(void *arg)
45 {
46     printf("thread started...\n");
47     pause();
48     return(0);
49 }
50 
51 int
52 main(void)
53 {
54     int            err;
55     pid_t        pid;
56     pthread_t    tid;
57 
58     if ((err = pthread_atfork(prepare, parent, child)) != 0)
59         err_exit(err, "can‘t install fork handlers");
60     if ((err = pthread_create(&tid, NULL, thr_fn, 0)) != 0)
61         err_exit(err, "can‘t create thread");
62 
63     sleep(2);
64     printf("parent about to fork...\n");
65 
66     if ((pid = fork()) < 0)
67         err_quit("fork failed");
68     else if (pid == 0)    /* child */
69         printf("child returned from fork\n");
70     else        /* parent */
71         printf("parent returned from fork\n");
72     exit(0);
73 }