golang 自旋锁的实现

cas算法（compare and swap）

cas算法是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（non-blocking synchronization）。cas算法涉及到三个操作数

• 需要读写的内存值v
• 进行比较的值a
• 拟写入的新值b

当且仅当 v 的值等于 a时，cas通过原子方式用新值b来更新v的值，否则不会执行任何操作（比较和替换是一个原子操作）。一般情况下是一个自旋操作，即不断的重试。

自旋锁

自旋锁是指当一个线程在获取锁的时候，如果锁已经被其他线程获取，那么该线程将循环等待，然后不断地判断是否能够被成功获取，知直到获取到锁才会退出循环。

获取锁的线程一直处于活跃状态，但是并没有执行任何有效的任务，使用这种锁会造成 busy-waiting 。

它是为实现保护共享资源而提出的一种锁机制。其实，自旋锁与互斥锁比较类似，它们都是为了解决某项资源的互斥使用。无论是互斥锁，还是自旋锁，在任何时刻，最多只能由一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。但是两者在调度机制上略有不同。对于互斥锁，如果资源已经被占用，资源申请者只能进入睡眠状态。但是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，“自旋”一词就是因此而得名。

golang实现自旋锁

type spinlock uint32
func (sl *spinlock) lock() {
  for !atomic.compareandswapuint32((*uint32)(sl), 0, 1) {
    runtime.gosched()
  }
}
func (sl *spinlock) unlock() {
  atomic.storeuint32((*uint32)(sl), 0)
}
func newspinlock() sync.locker {
  var lock spinlock
  return &lock
}

可重入的自旋锁和不可重入的自旋锁

文章开始的时候的那段代码，仔细分析一下就可以看出，它是不支持重入的，即当一个线程第一次已经获取到了该锁，在锁释放之前又一次重新获取该锁，第二次就不能成功获取到。由于不满足cas，所以第二次获取会进入while循环等待，而如果是可重入锁，第二次也是应该能够成功获取到的。

而且，即使第二次能够成功获取，那么当第一次释放锁的时候，第二次获取到的锁也会被释放，而这是不合理的。

为了实现可重入锁，我们需要引入一个计数器，用来记录获取锁的线程数

type spinlock struct {
   owner int
   count int
}

func (sl *spinlock) lock() {
    me := getgoroutineid()
    if spinlock .owner == me { // 如果当前线程已经获取到了锁，线程数增加一，然后返回
        sl.count++
        return
    }
    // 如果没获取到锁，则通过cas自旋
  for !atomic.compareandswapuint32((*uint32)(sl), 0, 1) {
    runtime.gosched()
  }
}
func (sl *spinlock) unlock() {
   if rl.owner != getgoroutineid() {
     panic("illegalmonitorstateerror")
   }
   if sl.count >0 { // 如果大于0，表示当前线程多次获取了该锁，释放锁通过count减一来模拟
      sl.count--
    }else { // 如果count==0，可以将锁释放，这样就能保证获取锁的次数与释放锁的次数是一致的了。
      atomic.storeuint32((*uint32)(sl), 0)
    }
}

func getgoroutineid() int {
  defer func() {
    if err := recover(); err != nil {
      fmt.println("panic recover:panic info:%v", err)   }
  }()

  var buf [64]byte
  n := runtime.stack(buf[:], false)
  idfield := strings.fields(strings.trimprefix(string(buf[:n]), "goroutine "))[0]
  id, err := strconv.atoi(idfield)
  if err != nil {
    panic(fmt.sprintf("cannot get goroutine id: %v", err))
  }
  return id
}


func newspinlock() sync.locker {
  var lock spinlock
  return &lock
}

自旋锁的其他变种

1. ticketlock

ticketlock主要解决的是公平性的问题。

思路：每当有线程获取锁的时候，就给该线程分配一个递增的id，我们称之为排队号，同时，锁对应一个服务号，每当有线程释放锁，服务号就会递增，此时如果服务号与某个线程排队号一致，那么该线程就获得锁，由于排队号是递增的，所以就保证了最先请求获取锁的线程可以最先获取到锁，就实现了公平性。

可以想象成银行办理业务排队，排队的每一个顾客都代表一个需要请求锁的线程，而银行服务窗口表示锁，每当有窗口服务完成就把自己的服务号加一，此时在排队的所有顾客中，只有自己的排队号与服务号一致的才可以得到服务。

2. clhlock

clh锁是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，它不断轮询前驱的状态，如果发现前驱释放了锁就结束自旋，获得锁。

3. mcslock

mcslock则是对本地变量的节点进行循环。

4. clhlock 和 mcslock

都是基于链表，不同的是clhlock是基于隐式链表，没有真正的后续节点属性，mcslock是显示链表，有一个指向后续节点的属性。

将获取锁的线程状态借助节点(node)保存,每个线程都有一份独立的节点，这样就解决了ticketlock多处理器缓存同步的问题。

自旋锁与互斥锁

• 自旋锁与互斥锁都是为了实现保护资源共享的机制。
• 无论是自旋锁还是互斥锁，在任意时刻，都最多只能有一个保持者。
• 获取互斥锁的线程，如果锁已经被占用，则该线程将进入睡眠状态；获取自旋锁的线程则不会睡眠，而是一直循环等待锁释放。

总结：

• 自旋锁：线程获取锁的时候，如果锁被其他线程持有，则当前线程将循环等待，直到获取到锁。
• 自旋锁等待期间，线程的状态不会改变，线程一直是用户态并且是活动的(active)。
• 自旋锁如果持有锁的时间太长，则会导致其它等待获取锁的线程耗尽cpu。
• 自旋锁本身无法保证公平性，同时也无法保证可重入性。
• 基于自旋锁，可以实现具备公平性和可重入性质的锁。
• ticketlock:采用类似银行排号叫好的方式实现自旋锁的公平性，但是由于不停的读取servicenum，每次读写操作都必须在多个处理器缓存之间进行缓存同步，这会导致繁重的系统总线和内存的流量，大大降低系统整体的性能。
• clhlock和mcslock通过链表的方式避免了减少了处理器缓存同步，极大的提高了性能，区别在于clhlock是通过轮询其前驱节点的状态，而mcs则是查看当前节点的锁状态。
• clhlock在numa架构下使用会存在问题。在没有cache的numa系统架构中，由于clhlock是在当前节点的前一个节点上自旋,numa架构中处理器访问本地内存的速度高于通过网络访问其他节点的内存，所以clhlock在numa架构上不是最优的自旋锁。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。