多线程编程

 1#include <stdio.h>
 2#include <pthread.h>
 3
 4void *do_loop(void *data)
 5{
 6    int i; // counter, to print numbers
 7    int j; // counter, for delay
 8    int me = *((int *)data);
 9    for (i = 0; i < 10; i++) {
10        for (j = 0; j < 50000; j++) // delay loop
11            ;
12        printf("'%d' - Got '%d'\n", me, i);
13    }
14
15    // terminate the thread
16    pthread_exit(NULL);
17}
18
19int main(int argc, char *argv[])
20{
21    int       thr_id;    // thread ID for the newly created thread
22    pthread_t p_thread;  // thread's structure
23    int a = 1;           // thread 1 identifying number
24    int b = 2;           // thread 2 identifying number
25
26    // create a new thread that will execute 'do_loop()'
27    thr_id = pthread_create(&p_thread, NULL, do_loop, (void *)&a);
28
29    // run 'do_loop' in the main thread as well
30    do_loop((void *)&b);
31
32    return 0;
33}

1gcc pthread_create.c -o pthread_create -lpthread

1pthread_mutex_t a_mutex = PTHREAD_MUTEX_INITIALIZER;

1int rc = pthread_mutex_lock(&a_mutex);
2if (rc) {
3    /* an error has occurred */
4    perror("pthread_mutex_lock");
5    pthread_exit(NULL);
6}
7
8/* mutex is now locked - do your stuff. */

1rc = pthread_mutex_unlock(&a_mutex);
2if (rc) {
3    perror("pthread_mutex_unlock");
4    pthread_exit(NULL);
5}

1rc = pthread_mutex_destroy(&a_mutex);

  1#include <stdio.h>
  2#include <pthread.h>
  3
  4#define num_employees 2
  5
  6/* global mutex for out program. assignment initializes it */
  7pthread_mutex_t a_mutex = pthread_mutex_initializer;
  8
  9struct employee {
 10    int number;
 11    int id;
 12    char first_name[20];
 13    char last_name[20];
 14    char department[30];
 15    int room_number;
 16};
 17
 18/* global variable - our employee array, with 2 employees */
 19struct employee employees[] = {
 20    { 1, 12345678, "danny", "cohen", "accounting", 101 },
 21    { 2, 87654321, "moshe", "levy", "programmers", 202 },
 22};
 23
 24/* global variable - employee of the day. */
 25struct employee employee_of_the_day;
 26
 27void copy_employee(struct employee *from, struct employee *to)
 28{
 29    int rc; /* contain mutex lock/unlock results */
 30
 31    /* lock the mutex, to assure exclusive access to 'a' and 'b'. */
 32    rc = pthread_mutex_lock(&a_mutex);
 33
 34    to->number = from->number;
 35    to->id = from->id;
 36    strcpy(to->first_name, from->first_name);
 37    strcpy(to->last_name, from->last_name);
 38    strcpy(to->department, from->department);
 39    to->room_number = from->room_number;
 40
 41    /* unlock mutex */
 42    rc = pthread_mutex_unlock(&a_mutex);
 43}
 44
 45
 46void *do_loop(void *data)
 47{
 48    int my_num = *((int *)data);
 49    while (1) {
 50        /* set employee of the day to be the one with number 'my_num'. */
 51        copy_employee(&employees[my_num - 1], &employee_of_the_day);
 52    }
 53}
 54
 55int main(int argc, char *argv[])
 56{
 57    int       i;                /* loop counter */
 58    int       thr_id1;          /* thread id for the first new thread */
 59    int       thr_id2;          /* thread id for the second new thread */
 60    pthread_t p_thread1;        /* first thread's structure */
 61    pthread_t p_thread2;        /* second thread's structure */
 62    int       num1 = 1;         /* thread 1 employee number */
 63    int       num2 = 2;         /* thread 2 employee number */
 64    struct    employee eotd;    /* local copy of 'employee of the day' */
 65    struct    employee *worker; /* pointer to currently checked employee */
 66
 67    /* initialize employee of the day to first 1. */
 68    copy_employee(&employees[0], &employee_of_the_day);
 69
 70    /* create a new thread that will execute 'do_loop' with 1 */
 71    thr_id1 = pthread_create(&p_thread1, null, do_loop, (void *)&num1);
 72
 73    /* create a new thread that will execute 'do_loop' with 2 */
 74    thr_id2 = pthread_create(&p_thread2, null, do_loop, (void *)&num2);
 75
 76    /* run a loop that verfies integrity of 'employee of the day' many */
 77    for (i = 0; i < 6000; i++) {
 78        copy_employee(&employee_of_the_day, &eotd);
 79        worker = &employees[eotd.number - 1];
 80
 81        if (eotd.id != worker->id) {
 82            printf("mismatching 'id', %d != %d (loop '%d')\n", eotd.id, worker->id, i);
 83            exit(0);
 84        }
 85
 86        if (strcmp(eotd.first_name, worker->first_name) != 0) {
 87            printf("mismatching 'first_name', %s != %s (loop '%d')\n", eotd.first_name, worker->first_name, i);
 88            exit(0);
 89        }
 90
 91        if (strcmp(eotd.last_name, worker->last_name) != 0) {
 92            printf("mismatching 'last_name', %s != %s (loop '%d')\n", eotd.last_name, worker->last_name, i);
 93            exit(0);
 94        }
 95
 96        if (strcmp(eotd.department, worker->department) !=0) {
 97            printf("mismatching 'department', %s != %s (loop '%d')\n", eotd.department, worker->department, i);
 98            exit(0);
 99        }
100
101        if (eotd.room_number != worker->room_number) {
102            printf("mismatching 'room_number', %d != %d (loop '%d')\n", eotd.room_number, worker->room_number, i);
103            exit(0);
104        }
105    }
106
107    printf("glory, employees contents was always consistent\n");
108    return 0;
109}

1pthread_cond_t got_request = PTHREAD_COND_INITIALIZER;

1int rc = pthread_cond_signal(&got_request);
2
3// or
4
5int rc = pthread_cond_broadcast(&got_request);

 1/* first, lock the mutex */
 2int rc = pthread_mutex_lock(&request_mutex);
 3if (rc) { /* an error has occurred */
 4    perror("pthread_mutex_lock");
 5    pthread_exit(NULL);
 6}
 7
 8/* mutex is now locked - wait on the condition variable */
 9/* During the execution of pthread_cond_wait, the mutex is unlocked */
10rc = pthread_cond_wait(&got_request, &request_mutex);
11if (rc == 0) { /* we were awakened due to the cond. variable being signaled */
12               /* The mutex is now locked again by pthread_cond_wait() */
13    /* do your stuff... */
14}
15
16/* finally, unlock the mutex */
17pthread_mutex_unlock(&request_mutex);

 1#include <sys/time.h> /* struct timeval definition */
 2#include <unistd.h>   /* declaration of gettimeofday() */
 3
 4struct timeval  now;     /* time when we started waiting. */
 5struct timespec timeout; /* timeout value for the wait function */
 6int    done;             /* are we done waiting? */
 7
 8/* first, lock the mutex */
 9int rc = pthread_mutex_lock(&request_mutex);
10if (rc) { /* an error has occurred. */
11    perror("pthread_mutex_lock");
12    pthread_exit(NULL);
13}
14
15/* mutex is now locked */
16
17/* get current time */
18gettimeofday(&now);
19/* prepare timeout value */
20timeout.tv_sec = now.tv_sec + 5;
21timeout.tv_nsec = now.tv_usec * 1000; /* timeval uses microseconds. */
22                                      /* timespec uses nanoseconds. */
23                                      /* 1 nanosecond = 1000 micro seconds. */
24
25/* wait on the condition variable. */
26/* we use a loop, since a Unix signal might stop the wait before the timeout. */
27done = 0;
28while (!done) {
29    /* remember that pthread_cond_timedwait() unlocks the mutex on entrance */
30    rc = pthread_cond_timedwait(&got_request, &request_mutex, &timeout);
31    switch (rc) {
32        case 0: /* we were awakened due to the cond. variable being signaled */
33                /* the mutex was now locked again by pthread_cond_timedwait. */
34            /* do your stuff here... */
35            done = 0;
36            break;
37        case ETIMEDOUT: /* our time is up */
38            done = 0;
39            break;
40        default:   /* some error occurred (e.g. we got a Unix signal) */
41            break; /* break this switch, but re-do the while loop. */
42    }
43}
44
45/* finally, unlock the mutex */
46pthread_mutex_unlock(&request_mutex);

1int rc = pthread_cond_destroy(&got_request);
2if (rc == EBUSY) { /* some thread is still waiting on this condition variable */
3    /* handle this case here ... */
4}

 1/* number of pending requests, initially none. */
 2int num_requests = 0;
 3
 4/* first, lock the mutex */
 5int rc = pthread_mutex_lock(&a_mutex);
 6if (rc) { /* an error has occurred */
 7    perror("pthread_mutex_lock");
 8    pthread_exit(NULL);
 9}
10
11/* mutex is now locked - wait on the condition variable */
12/* if there are no requests to be handled. */
13rc = 0;
14if (num_requests == 0) {
15    rc = pthread_cond_wait(&got_request, &a_mutex);
16}
17
18if (num_requests > 0 && rc == 0) { /* we have a request pending. */
19    /* do your stuff... */
20
21    /* decrease count of pending requests */
22    num_requests--;
23}
24
25/* finally, unlock the mutex */
26pthread_mutex_unlock(&a_mutex);

  1#include <stdio.h>
  2#define __USE_GNU
  3#include <pthread.h>
  4#include <stdlib.h>
  5
  6#define NUM_HANDLER_THREADS 3
  7
  8/* global mutex for our program. assignment initializes it. */
  9/* note that we use a RECURSIVE mutex, since a handler thread might try to lock
 10 * it twice consecutively. */
 11pthread_mutex_t request_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
 12
 13/* global condition variable for our program. assignment initializes it. */
 14pthread_cond_t got_request = PTHREAD_COND_INITIALIZER;
 15
 16/* number for pending requests, initially none. */
 17int num_requests = 0;
 18
 19/* format of a single request. */
 20struct request {
 21    int number;           /* number of the request */
 22    struct request *next; /* pointer to next request, NULL if none. */
 23};
 24
 25/* head of linked list of requests. */
 26struct request *requests = NULL;
 27/* pointer to last request */
 28struct request *last_request = NULL;
 29
 30void add_request(int request_num, pthread_mutex_t *p_mutex,
 31                 pthread_cond_t *p_cond_var) {
 32    /* return code of pthreads functions. */
 33    int rc;
 34
 35    /* pointer to newly added request */
 36    struct request *a_request;
 37
 38    a_request = (struct request *)malloc(sizeof(struct request));
 39    if (!a_request) {
 40        fprintf(stderr, "add_request: out of memory\n");
 41        exit(1);
 42    }
 43
 44    a_request->number = request_num;
 45    a_request->next = NULL;
 46
 47    /* lock the mutex, to assure exclusive access to the list */
 48    rc = pthread_mutex_lock(p_mutex);
 49
 50    /* add new request to the end of the list, updating list */
 51    /* pointers as required */
 52    if (num_requests == 0) {
 53        requests = a_request;
 54        last_request = a_request;
 55    } else {
 56        last_request->next = a_request;
 57        last_request = a_request;
 58    }
 59
 60    num_requests++;
 61
 62#ifdef DEBUG
 63    printf("add_request: added request with id '%d'\n", a_request->number);
 64    fflush(stdout);
 65#endif
 66
 67    /* unlock mutex */
 68    rc = pthread_mutex_unlock(p_mutex);
 69
 70    /* signal the condition variable - there's a new request to handle */
 71    rc = pthread_cond_signal(p_cond_var);
 72}
 73
 74struct request *get_request(pthread_mutex_t *p_mutex) {
 75    int rc;
 76    struct request *a_request;
 77
 78    rc = pthread_mutex_lock(p_mutex);
 79
 80    if (num_requests > 0) {
 81        a_request = requests;
 82        requests = a_request->next;
 83
 84        if (requests == NULL) {
 85            last_request = NULL;
 86        }
 87        num_requests--;
 88    } else {
 89        a_request = NULL;
 90    }
 91
 92    /* unlock mutex */
 93    rc = pthread_mutex_unlock(p_mutex);
 94
 95    return a_request;
 96}
 97
 98void handle_request(struct request *a_request, int thread_id) {
 99    if (a_request) {
100        printf("Thread '%d' handled request '%d'\n", thread_id,
101               a_request->number);
102        fflush(stdout);
103    }
104}
105
106void handle_requests_loop(void *data) {
107    int rc;
108    struct request *a_request;
109    int thread_id = *((int *)data);
110
111#ifdef DEBUG
112    printf("Starting thread '%d'\n", thread_id);
113    fflush(stdout);
114#endif
115
116    /* lock the mutex, to access the requests list exclusively. */
117    rc = pthread_mutex_lock(&request_mutex);
118
119#ifdef DEBUG
120    printf("thread '%d' after pthread_mutex_lock\n", thread_id);
121    fflush(stdout);
122#endif
123
124    /* do forever... */
125    while (1) {
126#ifdef DEBUG
127        printf("thread '%d', number_requests = %d\n", thread_id, num_requests);
128        fflush(stdout);
129#endif
130        if (num_requests > 0) {
131            a_request = get_request(&request_mutex);
132            if (a_request) {
133                handle_request(a_request, thread_id);
134                free(a_request);
135            }
136        } else {
137#ifdef DEBUG
138            printf("thread '%d' before pthread_cond_wait\n", thread_id);
139            fflush(stdout);
140#endif
141            rc = pthread_cond_wait(&got_request, &request_mutex);
142
143#ifdef DEBUG
144            printf("thread '%d' after pthread_cond_wait\n", thread_id);
145            fflush(stdout);
146#endif
147        }
148    }
149}
150
151int main(int argc, char *argv[]) {
152    int i;
153    int thr_id[NUM_HANDLER_THREADS];
154    pthread_t p_threads[NUM_HANDLER_THREADS];
155    struct timespec delay;
156
157    /* create the request-handling threads */
158    for (i = 0; i < NUM_HANDLER_THREADS; i++) {
159        thr_id[i] = i;
160        pthread_create(&p_threads[i], NULL, handle_requests_loop,
161                       (void *)&thr_id[i]);
162    }
163
164    sleep(3);
165
166    /* run a loop that generates requests */
167    for (i = 0; i < 600; i++) {
168        add_request(i, &request_mutex, &got_request);
169        if (rand() > 3 * (RAND_MAX / 4)) {
170            delay.tv_sec = 0;
171            delay.tv_nsec = 10;
172            nanosleep(&delay, NULL);
173        }
174    }
175
176    sleep(5);
177    printf("Glory, we are done.\n");
178
179    return 0;
180}