乐观锁和自旋锁基础概念有什么?要如何实现?

TheDisguiser 2020-05-29 14:11:15 java常见问答 9216

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

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

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

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

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

乐观锁具体实现:

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);
    }
}

以上就是乐观锁与自旋锁的所有内容了,更多数据库锁机制相关的java常见问答知识,请关注我们的网站来具体了解吧。

推荐阅读:

乐观锁和悲观锁的实现要如何配置?具体概念是什么?

乐观锁实现方式有几种?乐观锁是什么?

乐观锁和悲观锁详解,具体概念介绍