skynet中的各种锁

　　最近读skynet c语言部分的源码，发现有好多锁的使用和gcc提供的一些原子操作。看到这些东西，对于我这个newbee来说实在有些hold不住。但为了了解并进一步掌握，还是决定好好分析一下。不足之处望指正。

　　自旋锁(spinlock) 和 互斥锁(mutex) 对比

　　自旋锁：得到锁之前是在一个循环中空转，直到得到锁为止，那么就有三种可能 1：很短时间就得到锁，由于是空转，没有sleep，也就没有由系统到用户态的消耗，2：很长时间才得到锁，虽然没有状态的切换，但是由于忙等时间过长

　　　　　　导致性能下降，3：一直空转，消耗cpu时间。

　　互斥锁 : 企图获得锁，若是得不到锁则阻塞，放弃cpu，没有忙等的出现，当锁可得时，发生状态切换，由内核切换到用户态，虽然没有忙等但是状态切换的代价仍然很大。

　　

　　由此可知：对自旋锁和互斥锁的选择是要根据得到锁的耗时来的，若果当得到锁后，需要执行大量的操作，一般选用互斥锁，若得到锁后，进行很少量的操作，一般选择自旋锁，因为执行的操作短，那么忙等的开销总体还是小于内核态

　　　　　　   和用户态切换带来的开销的。

　　最近在使用skynet，这里贴出来cloud实现自旋锁的代码，方便大家查阅：

　　　　#ifndef SKYNET_SPINLOCK_H
　　　　#define SKYNET_SPINLOCK_H

　　　　#define SPIN_INIT(q) spinlock_init(&(q)->lock);
　　　　#define SPIN_LOCK(q) spinlock_lock(&(q)->lock);
　　　　#define SPIN_UNLOCK(q) spinlock_unlock(&(q)->lock);
　　　　#define SPIN_DESTROY(q) spinlock_destroy(&(q)->lock);

　　　　#ifndef USE_PTHREAD_LOCK

　　　　struct spinlock {
    　　　　int lock;
　　　　};

　　　　static inline void
　　　　spinlock_init(struct spinlock *lock) {
   　　　　 lock->lock = 0;
　　　　}

　　　　static inline void
　　　　spinlock_lock(struct spinlock *lock) {
  　　　　  while (__sync_lock_test_and_set(&lock->lock,1)) {}
　　　　}

　　　　static inline int
　　　　spinlock_trylock(struct spinlock *lock) {
   　　　　 return __sync_lock_test_and_set(&lock->lock,1) == 0;
　　　　}

　　　　static inline void
　　　　spinlock_unlock(struct spinlock *lock) {
 　　　　   __sync_lock_release(&lock->lock);
　　　　}

　　　　static inline void
　　　　spinlock_destroy(struct spinlock *lock) {
 　　　　   (void) lock;
　　　　}

　　　　#else

　　　　#include <pthread.h>

　　　　// we use mutex instead of spinlock for some reason
　　　　// you can also replace to pthread_spinlock

　　　　struct spinlock {
  　　　　  pthread_mutex_t lock;
　　　　};

　　　　static inline void
　　　　spinlock_init(struct spinlock *lock) {
 　　　　   pthread_mutex_init(&lock->lock, NULL);
　　　　}

　　　　static inline void
　　　　spinlock_lock(struct spinlock *lock) {
  　　　　  pthread_mutex_lock(&lock->lock);
　　　　}

　　　　static inline int
　　　　spinlock_trylock(struct spinlock *lock) {
 　　　　   return pthread_mutex_trylock(&lock->lock) == 0;
　　　　}

　　　　static inline void
　　　　spinlock_unlock(struct spinlock *lock) {
 　　　　   pthread_mutex_unlock(&lock->lock);
　　　　}

　　　　static inline void
　　　　spinlock_destroy(struct spinlock *lock) {
 　　　　   pthread_mutex_destroy(&lock->lock);
　　　　}

　　
　　　　#endif
　　　　#endif

　　linux自带了pthread_spinlock。

　　cloud的第一种实现中，用到了gcc自带的原子操作函数实现了spinlock，这里提供一些gcc自带的原子操作的资料：https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/_005f_005fatomic-Builtins.html#_005f_005fatomic-Builtins

　　

　　互斥锁和条件锁

　　pthread_mutex_t 和 pthread_cond_t

　　在阅读skynet.start.c中发现了这两种锁的使用，代码过长，不全部列出，这里只列出简化过得。

　　源码在这里：https://github.com/cloudwu/skynet/blob/master/skynet-src/skynet_start.c

　　简化后代码：

　　//创建线程时调用的代码

　　static void
　　create_thread(pthread_t *thread, void *(*start_routine) (void *), void *arg) {
    　　if (pthread_create(thread,NULL, start_routine, arg)) {
        　　fprintf(stderr, "Create thread failed");
        　　exit(1);
    　　}
　　}
　　//事件发生时调用
　　static void　　
　　wakeup(struct monitor *m, int busy) {
    　　if (m->sleep >= m->count - busy) {
        　　// signal sleep worker, "spurious wakeup" is harmless
        　　pthread_cond_signal(&m->cond);
    　　}
　　}
　　//创建socket线程监听链接，并唤醒阻塞的thread_worker线程
　　static void *
　　thread_socket(void *p) {
    　　struct monitor * m = p;
    　　skynet_initthread(THREAD_SOCKET);
    　　for (;;) {
        　　int r = skynet_socket_poll();
        　　if (r==0)
            　　break;
        　　if (r<0) {
            　　CHECK_ABORT
            　　continue;
        　　}
      　　  wakeup(m,0);
    　　}
    　　return NULL;
　　}

　　static void *
　　thread_worker(void *p) {
    　　struct worker_parm *wp = p;
    　　int id = wp->id;
    　　int weight = wp->weight;
    　　struct monitor *m = wp->m;
    　　struct skynet_monitor *sm = m->m[id];
    　　skynet_initthread(THREAD_WORKER);
    　　struct message_queue * q = NULL;         //上边几句选择性忽略
   　　 while (!m->quit) {
        　　q = skynet_context_message_dispatch(sm, q, weight);
        　　if (q == NULL) {
            　　if (pthread_mutex_lock(&m->mutex) == 0) {  //创建工作线程时，每个线程运行到这里，获得mutex
                　　++ m->sleep;  　　　　　　　　  //当没有事件要处理时，阻塞贤臣数加1
                　　// "spurious wakeup" is harmless,
                　　// because skynet_context_message_dispatch() can be call at any time.
                　　if (!m->quit)
                    　　pthread_cond_wait(&m->cond, &m->mutex);   //在这里真正的阻塞在cond上，调用这个函数时，线程阻塞在cond上，并暂时放弃mutex的使用权，让其他线程可　　以获取到，当其他线程获得到mutex，继续阻塞在cond上，直到socket线程监听到链接，调用pthread_cond_signal来唤醒工作线程，唤醒的工作线程，重新获得mutex.
                　　-- m->sleep;
               　　 if (pthread_mutex_unlock(&m->mutex)) {
                   　　 fprintf(stderr, "unlock mutex error");
                   　　 exit(1);
               　　　　 }
          　　　　  }
       　　　　 }
    　　　　}
   　　　　 return NULL;
　　　　}
　　　　　　

　　　创建thread_worker线程的代码： create_thread(&pid[i+3], thread_worker, &wp[i]);

　　　以上代码大致工作过程:

　　　1.create_thread(&pid[i+3], thread_worker, &wp[i]); 创建工作线程

　　   2.运行到thread_worker函数中pthread_cond_wait(&m->cond, &m->mutex)时，线程阻塞在cond上，待等待的条件出现，方可被唤醒.

　　　3.所有创建的工作线程，都阻塞在了cond上，等待条件出现，而条件出现是在用户连接服务端后，被epoll或kqueue监听到后，唤醒工作线程

　　　　int r = skynet_socket_poll();
        　　if (r==0)
            　　break;
        　　if (r<0) {
            　　CHECK_ABORT
            　　continue;
        　　}
      　　  wakeup(m,0); //唤醒工作线程

　　

　　一般来说 mutex和cond是配合使用的，稍后解释原因。

　　未完，待续，欢迎纠正错误。