10g新加了mutex，替换部分latch的功能。
经过了解，原来mutex不是oracle自己发明的，而是操作系统的一个功能。既然不是oracle独家的，那我也想体验一下，于是就有了下面小程序。

struct foo *fh[NHASH]是一个典型的hash table，上面有几个表头，每个表头下面挂着一个foo链表，每个链表最后一个节点的next又指回表头。
操作的过程就是 hold（f_count++） -> 操作 ->释放（f_count--或free）

main函数里，对f2节点故意只hold，不释放，最后打印的时候可以看到f_count是2

点击(此处)折叠或打开

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#define NHASH 29
#define HASH(fp) (((unsigned long)fp)%NHASH)
struct foo *fh[NHASH];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo
{
int f_count;
pthread_mutex_t f_lock;
struct foo* f_next;
int f_id;
int f_value;
};
struct foo* foo_alloc(int id, int value)
{
struct foo* fp = NULL;
struct foo* tmp = NULL;
int idx;
if((fp = malloc(sizeof(struct foo))) != NULL)
{
fp->f_count = 1;
if(pthread_mutex_init(&fp->f_lock, NULL) != 0)
{
free(fp);
return NULL;
}
}
idx = HASH(fp);
pthread_mutex_lock(&hashlock);
if(fh[idx] == NULL)
{
fh[idx] = fp;
}
else
{
tmp = fh[idx];
while(tmp->f_next != NULL)
{
tmp = tmp->f_next;
}
tmp->f_next = fp;
}
fp->f_next = fh[idx];
pthread_mutex_lock(&fp->f_lock);
pthread_mutex_unlock(&hashlock);
fp->f_value = value;
fp->f_id = id;
pthread_mutex_unlock(&fp->f_lock);
return fp;
}
void foo_hold(struct foo* fp)
{
pthread_mutex_lock(&fp->f_lock);
fp->f_count++;
pthread_mutex_unlock(&fp->f_lock);
}
struct foo* foo_find(int id)
{
struct foo *fp;
int idx;
idx = HASH(fp);
pthread_mutex_lock(&hashlock);
for(fp=fh[idx]; fp!=NULL; fp=fp->f_next)
{
if(fp->f_id == id)
{
foo_hold(fp);
break;
}
}
pthread_mutex_unlock(&hashlock);
return(fp);
}
void foo_rele(struct foo* fp)
{
struct foo* tfp;
int idx;
pthread_mutex_lock(&fp->f_lock);
if(fp->f_count <= 1)
{
pthread_mutex_lock(&hashlock);
idx = HASH(fp);
tfp = fh[idx];
if (tfp == fp)
{
if(fp->f_next != fh[idx]) fh[idx] = fp->f_next;
else fh[idx] = NULL;
}
else
{
while(tfp->f_next != fp)
{
tfp = tfp->f_next;
}
tfp->f_next = fp->f_next;
}
pthread_mutex_unlock(&hashlock);
pthread_mutex_unlock(&fp->f_lock);
pthread_mutex_destroy(&fp->f_lock);
free(fp);
}
else
{
fp->f_count--;
pthread_mutex_unlock(&fp->f_lock);
}
}
void main()
{
struct foo* f1 = foo_alloc(1, 100);
struct foo* f2 = foo_alloc(2, 200);
foo_hold(f1);
f1->f_value = 111;
foo_rele(f1);
foo_hold(f2);
f2->f_value = 222;
foo_rele(f1);
int i;
for(i=1; i<NHASH; i++)
{
if(fh[i] != NULL)
{
printf(\"fh[%d]: id=%d, value=%d, count=%d\\n\", i, fh[i]->f_id, fh[i]->f_value, fh[i]->f_count);
}
}
return;
}

ITPub博客

体验mutex

最新文章