Java中关于各种锁的概念

牛牛的Java学习之旅

已于 2022-05-16 15:08:05 修改

阅读量141

点赞数

分类专栏： Java进阶文章标签： java 开发语言

于 2022-05-16 14:55:25 首次发布

本文链接：https://blog.csdn.net/llx522/article/details/124799835

版权

Java进阶专栏收录该内容

5 篇文章 1 订阅

订阅专栏

Java中关于各种锁的概念

乐观锁：

是一种乐观思想，认为读多写少，遇到并发写的可能性低，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但在更新的时候会判断一下在此期间别人有没有去更新这个数据，采取在写时先读出当前版本号，然后加锁操作

当线程拿到资源时，上乐观锁，在提交前，其他的锁也可以操作这个资源，当冲突的时候，并发机制会保留前一个提交，打回后一个提交，让后一个线程重新获取资源后，再操作，再提交。

拿版本号去对比

lock是乐观锁

悲观锁：

认为读少写多，遇到并发写的可能性高，每次拿数据的时候都认为别人会修改，所以每次在读写数据的时候都会上锁，别人想拿到这个数据就会block，直到拿到锁。

当线程拿到资源时，就对资源上锁，并在提交后，才释放资源，其他线程才能使用资源

synchronized是悲观锁

在并发量低的时候性能差不多，在并发量高的时候，乐观锁的性能远远优于悲观锁。

公平锁、非公平锁

公平锁：非常公平，不能插队，必须先来后到

非公平锁：可以插队，非常不公平（默认都是非公平锁）

Lock lock = new ReentrantLock(); //非公平锁
Lock lock = new ReentrantLock(true); //公平锁

可重入锁

递归锁：拿到外面的锁也就拿到里面的锁了

Lock锁必须配对，加了几把锁就要解几把锁！！

自旋锁

spinlock

自定义锁测试：

package com.liu.lock;

import java.util.concurrent.atomic.AtomicReference;

//自旋锁
public class SpinLockDemo01 {

    //Thread null
    AtomicReference<Thread> atomicReference = new AtomicReference<>();
    //加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+ "==> mylock");
        //自旋锁
        while (!atomicReference.compareAndSet(null,thread)){//所期望的是空，更新为当前线程

        }
    }

    //解锁
    public void myUnLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+ "==> myUnlock");
        atomicReference.compareAndSet(thread,null);//如果是期望的线程，就置为空
    }

}

package com.liu.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/*
测试结果：
t1线程先拿到锁，t2再拿到锁，自旋，等待t1解锁，t2才会解锁
 */
public class Test {

    public static void main(String[] args) throws InterruptedException {
//        ReentrantLock reentrantLock = new ReentrantLock();
//        reentrantLock.lock();
//        reentrantLock.unlock();

        //底层使用cas实现的自旋锁
        SpinLockDemo01 lock = new SpinLockDemo01();

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }

        },"t1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        },"t2").start();

    }

}

死锁

一句话理解：线程之间想获取其他线程的锁！

package com.liu.lock;

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        MyThread myThread = new MyThread(lockA,lockB);
        MyThread myThread1 = new MyThread(lockB,lockA);
        new Thread(myThread,"t1").start();
        new Thread(myThread1,"t2").start();
    }
}

class MyThread implements Runnable{

    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+"lock:"+lockA+"==>"+lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"lock:"+lockB+"==>"+lockA);
            }
        }

    }
}