基于锁的并发数据结构

并发计数器

非并发实现

typedef struct counter_t {
	int value;
}counter_t;

void init(counter_t* c) {
	c->value = 0;
}

void increment(counter_t* c) {
	c->value++;
}

void decrement(counter_t* c) {
	c->value--;
}

int get(counter_t* c) {
	return c->value;
}

将这个计数器变为线程完全的很简单，再每一个操作前加锁，操作完成之后解锁

typedef struct counter_t {
	int value;
	pthread_mutex_t lock;
}counter_t;

void init(counter_t* c) {
	c->value = 0;
	Pthread_mutex_init(&c->lock, NULL);
}

void increment(counter_t* c) {
	Pthread_mutex_lock(&c->lock);
	c->value++;
	Pthread_mutex_unlock(&c->lock);
}

void decrement(counter_t* c) {
	Pthread_mutex_lock(&c->lock);
	c->value--;
	Pthread_mutex_unlock(&c->lock);
}

int get(counter_t* c) {
	Pthread_mutex_lock(&c->lock);
	int rc = c->value;
	Pthread_mutex_unlock(&c->lock);
	return rc;
}

线程完全队列(使用单链表实现)
 

typedef struct _node_t {
	int value;
	struct _node_t* next;
}node_t;

typedef struct queue_t {
	node_t* head;
	node_t* tail;
	pthread_mutex_t headLock;
	pthread_mutex_t tailLock;
}queue_t;

void Queue_Init(queue_t* q) {
	node_t* temp = (node_t*)malloc(sizeof(node_t));
	temp->next = NULL;
	q->head = q->tail = temp;
	pthread_mutex_init(&q->headLock, NULL);
	pthread_mutex_init(&q->tailLock, NULL);

}

void Queue_Enqueue(queue_t* q, int value) {
	node_t* temp = (node_t*)malloc(sizeof(node_t));
	temp->value = value;
	temp->next = NULL;

	pthread_mutex_lock(&q->tailLock);            // 锁住队列的尾部
	q->tail->next = temp;
	q->tail = temp;
	pthread_mutex_unlock(&q->tailLock);
}

int Queue_Dequeue(queue_t* q, int* value) {
	pthread_mutex_lock(&q->headLock);            // 锁住队列的头部
	node_t* temp = q->head;
	node_t* newHead = temp->next;
	if (newHead == NULL) {
		pthread_mutex_unlock(&q->headLock)
		return -1;
	}
	*value = newHead->value;
	q->head = newHead;
	pthread_mutex_unlock(&q->headLock);
	free(temp);
	return 0;
}

这个用单链表实现的双端队列，队头使用了dummy的技巧，即添加一个头节点，分开了头和尾的操作，然后使用了两把锁，分别锁住队列的头部和队列的尾部。

入队操作只涉及队列尾部，出队操作只涉及队列的头部。