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是配合使用的,稍后解释原因。

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

 

posted @ 2016-03-16 10:11  mr_yu  阅读(1579)  评论(0编辑  收藏