多线程编程

#include <stdio.h>
#include <pthread.h>

void *do_loop(void *data)
{
    int i; // counter, to print numbers
    int j; // counter, for delay
    int me = *((int *)data);
    for (i = 0; i < 10; i++) {
        for (j = 0; j < 50000; j++) // delay loop
            ;
        printf("'%d' - Got '%d'\n", me, i);
    }

    // terminate the thread
    pthread_exit(NULL);
}

int main(int argc, char *argv[])
{
    int       thr_id;    // thread ID for the newly created thread
    pthread_t p_thread;  // thread's structure
    int a = 1;           // thread 1 identifying number
    int b = 2;           // thread 2 identifying number

    // create a new thread that will execute 'do_loop()'
    thr_id = pthread_create(&p_thread, NULL, do_loop, (void *)&a);

    // run 'do_loop' in the main thread as well
    do_loop((void *)&b);

    return 0;
}

gcc pthread_create.c -o pthread_create -lpthread

pthread_mutex_t a_mutex = PTHREAD_MUTEX_INITIALIZER;

int rc = pthread_mutex_lock(&a_mutex);
if (rc) {
    /* an error has occurred */
    perror("pthread_mutex_lock");
    pthread_exit(NULL);
}

/* mutex is now locked - do your stuff. */

rc = pthread_mutex_unlock(&a_mutex);
if (rc) {
    perror("pthread_mutex_unlock");
    pthread_exit(NULL);
}

rc = pthread_mutex_destroy(&a_mutex);

#include <stdio.h>
#include <pthread.h>

#define num_employees 2

/* global mutex for out program. assignment initializes it */
pthread_mutex_t a_mutex = pthread_mutex_initializer;

struct employee {
    int number;
    int id;
    char first_name[20];
    char last_name[20];
    char department[30];
    int room_number;
};

/* global variable - our employee array, with 2 employees */
struct employee employees[] = {
    { 1, 12345678, "danny", "cohen", "accounting", 101 },
    { 2, 87654321, "moshe", "levy", "programmers", 202 },
};

/* global variable - employee of the day. */
struct employee employee_of_the_day;

void copy_employee(struct employee *from, struct employee *to)
{
    int rc; /* contain mutex lock/unlock results */

    /* lock the mutex, to assure exclusive access to 'a' and 'b'. */
    rc = pthread_mutex_lock(&a_mutex);

    to->number = from->number;
    to->id = from->id;
    strcpy(to->first_name, from->first_name);
    strcpy(to->last_name, from->last_name);
    strcpy(to->department, from->department);
    to->room_number = from->room_number;

    /* unlock mutex */
    rc = pthread_mutex_unlock(&a_mutex);
}


void *do_loop(void *data)
{
    int my_num = *((int *)data);
    while (1) {
        /* set employee of the day to be the one with number 'my_num'. */
        copy_employee(&employees[my_num - 1], &employee_of_the_day);
    }
}

int main(int argc, char *argv[])
{
    int       i;                /* loop counter */
    int       thr_id1;          /* thread id for the first new thread */
    int       thr_id2;          /* thread id for the second new thread */
    pthread_t p_thread1;        /* first thread's structure */
    pthread_t p_thread2;        /* second thread's structure */
    int       num1 = 1;         /* thread 1 employee number */
    int       num2 = 2;         /* thread 2 employee number */
    struct    employee eotd;    /* local copy of 'employee of the day' */
    struct    employee *worker; /* pointer to currently checked employee */

    /* initialize employee of the day to first 1. */
    copy_employee(&employees[0], &employee_of_the_day);

    /* create a new thread that will execute 'do_loop' with 1 */
    thr_id1 = pthread_create(&p_thread1, null, do_loop, (void *)&num1);

    /* create a new thread that will execute 'do_loop' with 2 */
    thr_id2 = pthread_create(&p_thread2, null, do_loop, (void *)&num2);

    /* run a loop that verfies integrity of 'employee of the day' many */
    for (i = 0; i < 6000; i++) {
        copy_employee(&employee_of_the_day, &eotd);
        worker = &employees[eotd.number - 1];

        if (eotd.id != worker->id) {
            printf("mismatching 'id', %d != %d (loop '%d')\n", eotd.id, worker->id, i);
            exit(0);
        }

        if (strcmp(eotd.first_name, worker->first_name) != 0) {
            printf("mismatching 'first_name', %s != %s (loop '%d')\n", eotd.first_name, worker->first_name, i);
            exit(0);
        }

        if (strcmp(eotd.last_name, worker->last_name) != 0) {
            printf("mismatching 'last_name', %s != %s (loop '%d')\n", eotd.last_name, worker->last_name, i);
            exit(0);
        }

        if (strcmp(eotd.department, worker->department) !=0) {
            printf("mismatching 'department', %s != %s (loop '%d')\n", eotd.department, worker->department, i);
            exit(0);
        }

        if (eotd.room_number != worker->room_number) {
            printf("mismatching 'room_number', %d != %d (loop '%d')\n", eotd.room_number, worker->room_number, i);
            exit(0);
        }
    }

    printf("glory, employees contents was always consistent\n");
    return 0;
}

pthread_cond_t got_request = PTHREAD_COND_INITIALIZER;

int rc = pthread_cond_signal(&got_request);

// or

int rc = pthread_cond_broadcast(&got_request);

/* first, lock the mutex */
int rc = pthread_mutex_lock(&request_mutex);
if (rc) { /* an error has occurred */
    perror("pthread_mutex_lock");
    pthread_exit(NULL);
}

/* mutex is now locked - wait on the condition variable */
/* During the execution of pthread_cond_wait, the mutex is unlocked */
rc = pthread_cond_wait(&got_request, &request_mutex);
if (rc == 0) { /* we were awakened due to the cond. variable being signaled */
               /* The mutex is now locked again by pthread_cond_wait() */
    /* do your stuff... */
}

/* finally, unlock the mutex */
pthread_mutex_unlock(&request_mutex);

#include <sys/time.h> /* struct timeval definition */
#include <unistd.h>   /* declaration of gettimeofday() */

struct timeval  now;     /* time when we started waiting. */
struct timespec timeout; /* timeout value for the wait function */
int    done;             /* are we done waiting? */

/* first, lock the mutex */
int rc = pthread_mutex_lock(&request_mutex);
if (rc) { /* an error has occurred. */
    perror("pthread_mutex_lock");
    pthread_exit(NULL);
}

/* mutex is now locked */

/* get current time */
gettimeofday(&now);
/* prepare timeout value */
timeout.tv_sec = now.tv_sec + 5;
timeout.tv_nsec = now.tv_usec * 1000; /* timeval uses microseconds. */
                                      /* timespec uses nanoseconds. */
                                      /* 1 nanosecond = 1000 micro seconds. */

/* wait on the condition variable. */
/* we use a loop, since a Unix signal might stop the wait before the timeout. */
done = 0;
while (!done) {
    /* remember that pthread_cond_timedwait() unlocks the mutex on entrance */
    rc = pthread_cond_timedwait(&got_request, &request_mutex, &timeout);
    switch (rc) {
        case 0: /* we were awakened due to the cond. variable being signaled */
                /* the mutex was now locked again by pthread_cond_timedwait. */
            /* do your stuff here... */
            done = 0;
            break;
        case ETIMEDOUT: /* our time is up */
            done = 0;
            break;
        default:   /* some error occurred (e.g. we got a Unix signal) */
            break; /* break this switch, but re-do the while loop. */
    }
}

/* finally, unlock the mutex */
pthread_mutex_unlock(&request_mutex);

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

/* number of pending requests, initially none. */
int num_requests = 0;

/* first, lock the mutex */
int rc = pthread_mutex_lock(&a_mutex);
if (rc) { /* an error has occurred */
    perror("pthread_mutex_lock");
    pthread_exit(NULL);
}

/* mutex is now locked - wait on the condition variable */
/* if there are no requests to be handled. */
rc = 0;
if (num_requests == 0) {
    rc = pthread_cond_wait(&got_request, &a_mutex);
}

if (num_requests > 0 && rc == 0) { /* we have a request pending. */
    /* do your stuff... */

    /* decrease count of pending requests */
    num_requests--;
}

/* finally, unlock the mutex */
pthread_mutex_unlock(&a_mutex);

#include <stdio.h>
#define __USE_GNU
#include <pthread.h>
#include <stdlib.h>

#define NUM_HANDLER_THREADS 3

/* global mutex for our program. assignment initializes it. */
/* note that we use a RECURSIVE mutex, since a handler thread might try to lock
 * it twice consecutively. */
pthread_mutex_t request_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;

/* global condition variable for our program. assignment initializes it. */
pthread_cond_t got_request = PTHREAD_COND_INITIALIZER;

/* number for pending requests, initially none. */
int num_requests = 0;

/* format of a single request. */
struct request {
    int number;           /* number of the request */
    struct request *next; /* pointer to next request, NULL if none. */
};

/* head of linked list of requests. */
struct request *requests = NULL;
/* pointer to last request */
struct request *last_request = NULL;

void add_request(int request_num, pthread_mutex_t *p_mutex,
                 pthread_cond_t *p_cond_var) {
    /* return code of pthreads functions. */
    int rc;

    /* pointer to newly added request */
    struct request *a_request;

    a_request = (struct request *)malloc(sizeof(struct request));
    if (!a_request) {
        fprintf(stderr, "add_request: out of memory\n");
        exit(1);
    }

    a_request->number = request_num;
    a_request->next = NULL;

    /* lock the mutex, to assure exclusive access to the list */
    rc = pthread_mutex_lock(p_mutex);

    /* add new request to the end of the list, updating list */
    /* pointers as required */
    if (num_requests == 0) {
        requests = a_request;
        last_request = a_request;
    } else {
        last_request->next = a_request;
        last_request = a_request;
    }

    num_requests++;

#ifdef DEBUG
    printf("add_request: added request with id '%d'\n", a_request->number);
    fflush(stdout);
#endif

    /* unlock mutex */
    rc = pthread_mutex_unlock(p_mutex);

    /* signal the condition variable - there's a new request to handle */
    rc = pthread_cond_signal(p_cond_var);
}

struct request *get_request(pthread_mutex_t *p_mutex) {
    int rc;
    struct request *a_request;

    rc = pthread_mutex_lock(p_mutex);

    if (num_requests > 0) {
        a_request = requests;
        requests = a_request->next;

        if (requests == NULL) {
            last_request = NULL;
        }
        num_requests--;
    } else {
        a_request = NULL;
    }

    /* unlock mutex */
    rc = pthread_mutex_unlock(p_mutex);

    return a_request;
}

void handle_request(struct request *a_request, int thread_id) {
    if (a_request) {
        printf("Thread '%d' handled request '%d'\n", thread_id,
               a_request->number);
        fflush(stdout);
    }
}

void handle_requests_loop(void *data) {
    int rc;
    struct request *a_request;
    int thread_id = *((int *)data);

#ifdef DEBUG
    printf("Starting thread '%d'\n", thread_id);
    fflush(stdout);
#endif

    /* lock the mutex, to access the requests list exclusively. */
    rc = pthread_mutex_lock(&request_mutex);

#ifdef DEBUG
    printf("thread '%d' after pthread_mutex_lock\n", thread_id);
    fflush(stdout);
#endif

    /* do forever... */
    while (1) {
#ifdef DEBUG
        printf("thread '%d', number_requests = %d\n", thread_id, num_requests);
        fflush(stdout);
#endif
        if (num_requests > 0) {
            a_request = get_request(&request_mutex);
            if (a_request) {
                handle_request(a_request, thread_id);
                free(a_request);
            }
        } else {
#ifdef DEBUG
            printf("thread '%d' before pthread_cond_wait\n", thread_id);
            fflush(stdout);
#endif
            rc = pthread_cond_wait(&got_request, &request_mutex);

#ifdef DEBUG
            printf("thread '%d' after pthread_cond_wait\n", thread_id);
            fflush(stdout);
#endif
        }
    }
}

int main(int argc, char *argv[]) {
    int i;
    int thr_id[NUM_HANDLER_THREADS];
    pthread_t p_threads[NUM_HANDLER_THREADS];
    struct timespec delay;

    /* create the request-handling threads */
    for (i = 0; i < NUM_HANDLER_THREADS; i++) {
        thr_id[i] = i;
        pthread_create(&p_threads[i], NULL, handle_requests_loop,
                       (void *)&thr_id[i]);
    }

    sleep(3);

    /* run a loop that generates requests */
    for (i = 0; i < 600; i++) {
        add_request(i, &request_mutex, &got_request);
        if (rand() > 3 * (RAND_MAX / 4)) {
            delay.tv_sec = 0;
            delay.tv_nsec = 10;
            nanosleep(&delay, NULL);
        }
    }

    sleep(5);
    printf("Glory, we are done.\n");

    return 0;
}