1
2
3
4
5
6
7
8
9
10

struct pthread_mutexattr_t
{
     enum lock_type     // 使用pthread_mutexattr_settype来更改
    {
         PTHREAD_MUTEX_TIMED_NP [ default] //当一个线程加锁后，其余请求锁的线程形成等待队列，在解锁后按优先级获得锁。
         PTHREAD_MUTEX_ADAPTIVE_NP        // 动作最简单的锁类型，解锁后所有线程重新竞争。
         PTHREAD_MUTEX_RECURSIVE_NP       // 允许同一线程对同一锁成功获得多次。当然也要解锁多次。其余线程在解锁时重新竞争。
         PTHREAD_MUTEX_ERRORCHECK_NP      // 若同一线程请求同一锁，返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP动作相同。
    } type;
} attr;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#include <unistd.h>
#include <sys/types.h>
#include <pthread.h>
#include <semaphore.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) \
         do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        }  while( 0)

#define CONSUMERS_COUNT  1
#define PRODUCERS_COUNT  1
#define BUFFSIZE  10

int g_buffer[BUFFSIZE];

unsigned  short in =  0;
unsigned  short out =  0;
unsigned  short produce_id =  0;
unsigned  short consume_id =  0;

sem_t g_sem_full;
sem_t g_sem_empty;
pthread_mutex_t g_mutex;

pthread_t g_thread[CONSUMERS_COUNT + PRODUCERS_COUNT];

void *consume( void *arg)
{
     int i;
     int num = ( int)arg;
     while ( 1)
    {
        printf( "%d wait buffer not empty\n", num);
        sem_wait(&g_sem_empty);
        pthread_mutex_lock(&g_mutex);

         for (i =  0; i < BUFFSIZE; i++)
        {
            printf( "%02d ", i);
             if (g_buffer[i] == - 1)
                printf( "%s",  "null");
             else
                printf( "%d", g_buffer[i]);

             if (i == out)
                printf( "\t<--consume");

            printf( "\n");
        }
        consume_id = g_buffer[out];
        printf( "%d begin consume product %d\n", num, consume_id);
        g_buffer[out] = - 1;
        out = (out +  1) % BUFFSIZE;
        printf( "%d end consume product %d\n", num, consume_id);
        pthread_mutex_unlock(&g_mutex);
        sem_post(&g_sem_full);
        sleep( 1);
    }
     return  NULL;
}

void *produce( void *arg)
{
     int num = ( int)arg;
     int i;
     while ( 1)
    {
        printf( "%d wait buffer not full\n", num);
        sem_wait(&g_sem_full);
        pthread_mutex_lock(&g_mutex);
         for (i =  0; i < BUFFSIZE; i++)
        {
            printf( "%02d ", i);
             if (g_buffer[i] == - 1)
                printf( "%s",  "null");
             else
                printf( "%d", g_buffer[i]);

             if (i == in)
                printf( "\t<--produce");

            printf( "\n");
        }

        printf( "%d begin produce product %d\n", num, produce_id);
        g_buffer[in] = produce_id;
        in = (in +  1) % BUFFSIZE;
        printf( "%d end produce product %d\n", num, produce_id++);
        pthread_mutex_unlock(&g_mutex);
        sem_post(&g_sem_empty);
        sleep( 5);
    }
     return  NULL;
}

int main( void)
{
     int i;
     for (i =  0; i < BUFFSIZE; i++)
        g_buffer[i] = - 1;

    sem_init(&g_sem_full,  0, BUFFSIZE);
    sem_init(&g_sem_empty,  0,  0);

    pthread_mutex_init(&g_mutex,  NULL);


     for (i =  0; i < CONSUMERS_COUNT; i++)
        pthread_create(&g_thread[i],  NULL, consume, ( void *)i);

     for (i =  0; i < PRODUCERS_COUNT; i++)
        pthread_create(&g_thread[CONSUMERS_COUNT + i],  NULL, produce, ( void *)i);

     for (i =  0; i < CONSUMERS_COUNT + PRODUCERS_COUNT; i++)
        pthread_join(g_thread[i],  NULL);

    sem_destroy(&g_sem_full);
    sem_destroy(&g_sem_empty);
    pthread_mutex_destroy(&g_mutex);

     return  0;
}