多线程中锁的实现.

*引用本文请注明来自 blog.csdn.net/wtz1985       

所谓"锁",就是为了让自己独自占有空间,在自己没用完之前,不让别人来占用自己的资源.现在的操作系统,无论是WINDOWS,还是UNIX等其他操作系统.都采用多线程的环境.这极大提高了任务的执行速度,而且不会影响其他事务的执行.但是它们的执行是靠时间片的轮转的,如果某一个线程没有执行完,可它的时间片用完了,就会被挂起来,直到轮到它的下个时间片.假如继续让它们这么自由的,没有约束的执行命令,将会导致一种不可预见的结果,可该怎么解决呢?请看下面:

锁的引出,就是为了某一个线程在操作某一件事务时,独自占有其资源,并把自己琐起来,在自己没有把锁解开之前,别人只能等,不能抢,这就有效地控制了线程们不会因为时间片的作祟,而导致出现不可想象的结果.下面用代码简述一下锁是怎么实现的:

1、定义锁的接口。

1. /*----- locker.h -------*/
3. #ifndef _LOCKER_H
4. #define _LOCKER_H
6. struct _Locker;
7. typedef struct _Locker Locker;
9. typedef int (*LockerLockFunc)(Locker* thiz);
10. typedef int (*LockerUnlockFunc)(Locker* thiz);
11. typedef void (*LockerDestroyFunc)(Locker* thiz);
13. struct _Locker
14. {
15.  LockerLockFunc lock;
16.  LockerUnlockFunc unlock;
17.  LockerDestroyFunc locker_destroy;
19.  char priv[0];
20. };
22. static inline int locker_lock(Locker* thiz)
23. {
24.  assert(thiz != NULL && thiz->lock != NULL);
26.  return thiz->lock;
27. }
29. static inline int locker_unlock(Locker* thiz)
30. {
31.  assert(thiz != NULL && thiz->unlock != NULL);
33.  return thiz->unlock;
34. }
36. static inline void locker_destroy(Locker* thiz)
37. {
38.  assert(thiz != NULL && thiz->locker_destroy != NULL);
40.  return thiz->destroy_locker;
41. }
42. #endif  /*_LOCKER_H*/

2、定义线程锁的接口。

1. /*------ pthread_locker.h --------*/
3. #ifndef _PTHREAD_LOCKER_H
4. #define _PTHREAD_LOCKER_H
6. #include "locker.h"
8. Locker* locker_create(const char* name);
10. #endif /*_PTHREAD_LOCKER_H*/

3、接口的实现。

1. /*----- pthread_locker.c ------*/
3. #include "pthread_locker.h"
4. #include <stdio.h>
5. #include <stdlib.h>
6. #include <string.h>
7. #include <assert.h>
9. typedef struct _PrivInfo
10. {
11.  char* str_name;
12.  pthread_mutex_t mutex;
13. }PrivInfo;
15. static pthread_locker_lock(Locker* thiz)
16. {
17.  assert(thiz != NULL);
19.  PrivInfo* priv = (PrivInfo*)thiz->priv;
20.  return pthread_mutex_lock(&(priv->mutex));
21. }
23. static pthread_locker_unlock(Locker* thiz)
24. {
25.  assert(thiz != NULL);
27.  PrivInfo* priv = (PrivInfo*)thiz->priv;
28.  return pthread_mutex_unlock(&(priv->mutex));
29. }
31. static pthread_locker_destroy(Locker* thiz)
32. {
33.  assert(thiz != NULL);
35.  PrivInfo* priv = (PrivInfo*)thiz->priv;
36.  free(priv->str);
37.  pthread_mutex_destroy(&(priv->mutex));
38.  free(thiz);
40.  return;
41. }
43. Locker* locker_create(const char* name)
44. {
45.  Locker* thiz = (Locker*)malloc(sizeof(Locker)+sizeof(PrivInfo));
46.  PrivInfo* priv = thiz->priv;
47.  priv->str_name = strdup(name);
48.  pthread_mutex_init(&(priv->mutex), NULL);
50.  thiz->lock = pthread_locker_lock;
51.  thiz->unlock = pthread_lokcer_unlock;
52.  thiz->locker_destroy = pthread_locker_destroy;
54.  return thiz;
55. }

这就是线程锁的简单实现。可是当你在链表中插入时，要进行查找的操作，这时候只是简单的线程锁是不能解决的，那该怎么解决呢？这就涉及到递归锁的问题咯，下一篇再说递归琐的实现。