使用yeild實現spinlock

typedef struct spinlock {
          union { //聯合
             struct raw_spinlock rlock;
#ifdef CONFIG_DEBUG_LOCK_ALLOC
#define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
             struct{
                     u8 __padding[LOCK_PADSIZE];
                     struct lockdep_map dep_map;
             };
#endif
         };
} spinlock_t;

spinlock_t my_lock = SPIN_LOCK_UNLOCKED; 
void spin_lock_init(spinlock_t *lock); 

//加鎖一個自旋鎖函式
void spin_lock(spinlock_t *lock);                                   //獲取指定的自旋鎖
void spin_lock_irq(spinlock_t *lock);                               //禁止本地中斷獲取指定的鎖
void spin_lock_irqsave(spinlock_t *lock, unsigned long flags);      //儲存本地中斷的狀態,禁止本地中斷,並獲取指定的鎖
void spin_lock_bh(spinlock_t *lock)                                 //安全地避免死鎖, 而仍然允許硬體中斷被服務


//釋放一個自旋鎖函式
void spin_unlock(spinlock_t *lock);                                 //釋放指定的鎖
void spin_unlock_irq(spinlock_t *lock);                             //釋放指定的鎖,並啟用本地中斷
void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags); //釋放指定的鎖,並讓本地中斷恢復到以前的狀態
void spin_unlock_bh(spinlock_t *lock);                              //對應於spin_lock_bh


//非阻塞鎖
int spin_trylock(spinlock_t *lock);                  //試圖獲得某個特定的自旋鎖,如果該鎖已經被爭用,該方法會立刻返回一個非0值,
                                                     //而不會自旋等待鎖被釋放,如果成果獲得了這個鎖,那麼就返回0.
int spin_trylock_bh(spinlock_t *lock);                           
//這些函式成功時返回非零( 獲得了鎖 ), 否則 0. 沒有"try"版本來禁止中斷.

//其他
int spin_is_locked(spinlock_t *lock);               //和try_lock()差不多

 #define ngx_shmtx_lock(mtx)   ngx_spinlock((mtx)->lock, ngx_pid, 1024) 

// 輸入引數 
//    lock:一個整形變數的指標
//    value:將lock設定新的值
//    spin: 自旋的次數. 該值越大會嘗試更多次獲得鎖. 然後才會轉入讓核心排程執行緒暫時讓出cpu.
void
ngx_spinlock(ngx_atomic_t *lock, ngx_atomic_int_t value, ngx_uint_t spin)
{
#if (NGX_HAVE_ATOMIC_OPS)
    ngx_uint_t  i, n;
    for ( ;; ) {
        if (*lock == 0 && ngx_atomic_cmp_set(lock, 0, value)) {
            return;
        }
        // 為何只在多個cpu的時候才多嘗試spin幾次
        // 呵呵,很簡單,如果是單核的話,既然自己沒有拿到鎖,那說明別的執行緒/程式正在使用鎖,就這麼一個cpu,我們就不佔著自旋了,否則別人沒機會得到cpu,更不會釋放鎖了.
        if (ngx_ncpu > 1) {
            for (n = 1; n < spin; n <<= 1) {
                // 空轉的時間隨著n的變大而變大
                for (i = 0; i < n; i++) {
                    ngx_cpu_pause(); // 在空轉的同時, 降低cpu功耗,提高效率
                }
                if (*lock == 0 && ngx_atomic_cmp_set(lock, 0, value)) {
                    return;
                }
            }
        }
        // 已經嘗試這麼久了還沒有得到鎖, 讓cpu忙別人的事情吧. 讓出cpu等待一下.
        ngx_sched_yield();
    }
#else
#if (NGX_THREADS)
#error ngx_spinlock() or ngx_atomic_cmp_set() are not defined !
#endif
#endif
}

#if (NGX_HAVE_SCHED_YIELD)
#define ngx_sched_yield()  sched_yield()
#else
#define ngx_sched_yield()  usleep(1)
#endif

/* GCC support */
 
#include <stdlib.h>
#include "spinlock.h"
 
extern int ncpu;
 
 
void spin_lock(atomic_t *lock, int which)
{
    int i, n;
 
    for ( ;; ) {
 
        if (*lock == 0 &&.
            __sync_bool_compare_and_swap(lock, 0, which)) {
            return;
        }
 
        if (ncpu > 1) {
 
            for (n = 1; n < 129; n << 1) {

                for (i = 0; i < n; i++) {
                    __asm("pause");
                }

                if (*lock == 0 &&.
                    __sync_bool_compare_and_swap(lock, 0, which)) {
                    return;
                }
            }
        }
 
        sched_yield();
    }
}
 
 
void spin_unlock(atomic_t *lock, int which)
{
    __sync_bool_compare_and_swap(lock, which, 0);
}