Linux内核-乐观/自旋锁基础概念与实现

【推荐阅读】

浅谈linux 内核网络 sk_buff 之克隆与复制

深入linux内核架构--进程&线程

了解Docker 依赖的linux内核技术

小伙伴们知道乐观锁吧，这是一种十分乐观的锁机制，那你们知道自旋锁是什么吗?它与乐观锁的基础概念又有哪些呢?它们又都该怎么实现呢?下面就听小编为你一一讲解吧。

一、乐观锁基础概念及实现

乐观锁，顾名思义，就是说它非常乐观，它会总是假设最好的情况，在其他线程去拿数据时乐观的认为它们不会修改数据，所以不上锁，但是在更新数据期间还是会判断一下有没有线程改变了这个数据。

乐观锁一定是相对悲观锁而言的。因为乐观，所以它采取的加锁机制也会更为宽松。乐观锁一般情况下不会去刻意使用数据库本身的锁机制，它会依赖数据本身来保证数据的正确性。

乐观锁相信事务之间的数据竞争的概率是比较小的，因此它会尽可能的直接做下去，直到提交的时候才去锁定，所以不会产生任何锁和死锁。

乐观锁具体实现：

package priv.nanjing.testCasClass;
import java.util.concurrent.atomic.AtomicInteger;
/*
 * @Author : darrenqiao
 * */
//多线程争用的数据类
class Counter
{
    //int count = 0;
    //使用AtomicInteger代替基本数据类型
    AtomicInteger count = new AtomicInteger(0);
    public int getCount()
    {
        //return count;
        return count.get();
    }
    public void add()
    {
        //count += 1;
        count.addAndGet(1);
    }
    public void dec()
    {
        //count -= 1;
        count.decrementAndGet();
    }
}
//争用数据做加操作的线程
class AddDataThread extends Thread
{
    Counter counter;
    public AddDataThread(Counter counter)
    {
        this.counter = counter;
    }
    @Override
    public void run()
    {
        for (int i = 0; i < CasClass.LOOP; ++i)
        {
            counter.add();
        }
    }
}
//争用数据做减法操作的线程
class DecDataThread extends Thread
{
    Counter counter;
    public DecDataThread(Counter counter)
    {
        this.counter = counter;
    }
    @Override
    public void run()
    {
        for (int j = 0; j < CasClass.LOOP; j++)
        {
            counter.dec();
        }
    }
}
public class CasClass
{
    final static int LOOP = 10000;
    public static void main(String[] args) throws InterruptedException
    {
        Counter counter = new Counter();
        Thread addThread = new AddDataThread(counter);
        Thread decThread = new DecDataThread(counter);
        addThread.start();
        decThread.start();
        addThread.join();
        decThread.join();
        System.out.println(counter.getCount());
    }
}

二、自旋锁基础概念及实现

自旋锁，就是指当一个线程获取锁时，如若这个锁已经被其他线程获取，那这个线程就会一直循环等待，并且不断判断这个说锁能不能拿到，一直到成功获取锁才会全部退出。

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

自旋锁具体实现：

public class SpinLock
{
    private AtomicReferencecas = new AtomicReference();
    public void lock()
    {
        Thread current = Thread.currentThread();
        // 利用CAS
        while (!cas.compareAndSet(null, current))
        {
            // DO nothing
        }
    }
    public void unlock()
    {
        Thread current = Thread.currentThread();
        cas.compareAndSet(current, null);
    }
}