同步——互斥锁

互斥锁是最基本的同步形式，用于保护临界区

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mptr);
int pthread_mutex_trylock(pthread_mutex_t *mptr);
int pthread_mutex_unlock(pthread_mutex_t *mptr);
// return : 0/errno

// 互斥锁静态初始化
pthread_mutex_t mMutex = PTHREAD_MUTEX_INITIALIZER
// 动态初始化
pthread_mutex_t *mptr = malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(mptr, 0);

// 通常情况下，我们将互斥锁和需要保护的对象封装一个结构体内
struct {
       pthread_mutex_t mutex;
       int shObj;
} shared = {
       PTHREAD_MUTEX_INITIALIZER
};

// 线程间共享互斥锁的生产者消费者
#include	"unpipc.h"

#define	MAXNITEMS 		1000000
#define	MAXNTHREADS			100

int		nitems;			/* read-only by producer and consumer */
struct {
  pthread_mutex_t	mutex;
  int	buff[MAXNITEMS];
  int	nput;
  int	nval;
} shared = { PTHREAD_MUTEX_INITIALIZER };

void	*produce(void *), *consume(void *);

int
main(int argc, char **argv)
{
	int			i, nthreads, count[MAXNTHREADS];
	pthread_t	tid_produce[MAXNTHREADS], tid_consume;

	if (argc != 3)
		err_quit("usage: prodcons2 <#items> <#threads>");
	nitems = min(atoi(argv[1]), MAXNITEMS);
	nthreads = min(atoi(argv[2]), MAXNTHREADS);

	Set_concurrency(nthreads);
		/* 4start all the producer threads */
	for (i = 0; i < nthreads; i++) {
		count[i] = 0;
		Pthread_create(&tid_produce[i], NULL, produce, &count[i]);
	}

		/* 4wait for all the producer threads */
	for (i = 0; i < nthreads; i++) {
		Pthread_join(tid_produce[i], NULL);
		printf("count[%d] = %d\n", i, count[i]);	
	}

		/* 4start, then wait for the consumer thread */
	Pthread_create(&tid_consume, NULL, consume, NULL);
	Pthread_join(tid_consume, NULL);

	exit(0);
}
/* end main */

void *
produce(void *arg)
{
	for ( ; ; ) {
		Pthread_mutex_lock(&shared.mutex);
		if (shared.nput >= nitems) {
			Pthread_mutex_unlock(&shared.mutex);
			return(NULL);		/* array is full, we're done */
		}
		shared.buff[shared.nput] = shared.nval;
		shared.nput++;
		shared.nval++;
		Pthread_mutex_unlock(&shared.mutex);
		*((int *) arg) += 1;
	}
}

void *
consume(void *arg)
{
	int		i;

	for (i = 0; i < nitems; i++) {
		if (shared.buff[i] != i)
			printf("buff[%d] = %d\n", i, shared.buff[i]);
	}
	return(NULL);
}

互斥锁可以用在进程间共享：互斥锁建在共享内存区，并设置PTHREAD_PROCESS_SHARED属性，这样该互斥锁为系统级别

pthread_mutex_t *mptr //point to the mutex in shm
pthread_mutexattr_t mattr;
mptr = /* mutex in shm */
Pthread_mutexattr_init(&mattr);
Pthread_mutexattr_setpshared(&mattr, PTHEAD_PROCESS_SHARED);
Pthread_mutex_init(mptr, &mattr);

当在进程间共享一个互斥锁时，持有该互斥锁的进程在持有期间终止，没有办法让系统在进程终止时自动释放所持有的锁，读写锁和Posix信号量亦然；进程终止时内核总是自动清理的唯一同步锁类型是fcntl记录锁。线程在获取锁的情况下被另一个线程Pthread_cancel掉时，我们可以设置清理处理程序pthread_cleanup_pop/push应对该状况。