四、各种锁的理解

最新推荐文章于 2024-09-09 14:40:58 发布

wu1308156206

最新推荐文章于 2024-09-09 14:40:58 发布

阅读量61

点赞数

分类专栏： JUC 文章标签： java 开发语言

本文链接：https://blog.csdn.net/wu1308156206/article/details/125688740

版权

JUC 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

一、公平锁与非公平锁

公平锁：不允许插队，线程排队执行。
非公平锁：允许插队。比如先来的线程a要1小时执行完，后来的线程b只要1秒钟。这是可以让b先执行。默认都是非公平锁（synchronized，lock）

lock可以指定为公平锁。

二、可重入锁

所有的锁都是可重入的

看下面代码理解可重入的意思

synchronized版本

public class Demo1 {
    public static void main(String[] args) {
        MyClass1 myClass1 = new MyClass1();

        new Thread(()->{
            myClass1.fun1();
        },"a").start();

        new Thread(()->{
            myClass1.fun1();
        },"b").start();
    }
}

class MyClass1{
    public synchronized void fun1(){
        System.out.println(Thread.currentThread().getName()+":fun1");
        fun2();   //调用fun2 fun2中也加了锁，因为是同一把锁，所以不需要重新获取
    }

    public synchronized void fun2(){
        System.out.println(Thread.currentThread().getName()+":fun2");
    }
}

lock版本

public class Demo2 {
    public static void main(String[] args) {
        MyClass2 myClass2 = new MyClass2();

        new Thread(()->{
            myClass2.fun1();
        },"a").start();

        new Thread(()->{
            myClass2.fun1();
        },"b").start();
    }
}

class MyClass2{
    final Lock lock = new ReentrantLock();
    public void fun1(){
        lock.lock();        //lock()和unlock()一定要配对使用 如果写了lock()没写unlock()则会一直卡住
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + ":fun1");
            fun2();   //调用fun2。fun2中也加了锁，这是不同的锁
        }
        finally {
            lock.unlock();
            lock.unlock();
        }
    }

    public void fun2(){
        lock.lock();		//这里的锁和fun1中不是同一把锁
        try {
            System.out.println(Thread.currentThread().getName() + ":fun2");
        }
        finally {
            lock.unlock();   //如果和fun1中是同一把锁 这里释放了 fun1的锁也释放了
        }
    }
}

这里要注意一点，虽然和synchronized实现了一样的效果，但是在两个方法中是加了两把不同的锁。

三、自旋锁

自定义自旋锁

/**
 * 自定义自旋锁
 */
public class SpinLockDemo {
    //这里的引用值为null
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    //加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName()+"-> 加锁");
        //自旋
        //第一个线程进来后会马上修改掉原来的引用值null,并设置为thread
        //第二个线程只能一直循环，也就是所谓的自旋,直到第一个线程解锁，即设置引用值为null
        //这个比较和设置两个操作是原子的不能打断
        while(!atomicReference.compareAndSet(null,thread)){

        }
    }

    //解锁
    public void unMyLock(){
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + "-> 解锁");

        atomicReference.compareAndSet(thread,null);
    }
}

测试类

public class SpinLockTest {
    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(()->{
            spinLockDemo.myLock();
            try{
                TimeUnit.SECONDS.sleep(3);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                spinLockDemo.unMyLock();
            }
        },"A").start();

        try {
            //主线程暂停1秒  让线程A先执行
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            spinLockDemo.myLock();
            spinLockDemo.unMyLock();
        },"B").start();
    }
}

打印结果一定是A先解锁 B再解锁。线程A在自旋的过程中加了锁，线程B只能等待。线程A自旋完成，并释放锁，线程B才能拿到锁，开始自旋，自旋完成，释放锁。或者说自旋的过程是原子性的，不能打断。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9DQpS2gj-1657320204883)(G:\学习\JUC-Java并发编程\JUC学习笔记\image-20200428073022362.png)]

四、死锁

死锁产生的原因

多个线程按照不同的顺序对多个资源进行加锁，在释放资源前尝试获取其他资源，就会产生死锁。

例子

public class DeadLockTest {
    public static void main(String[] args) {
        final String source1 = "source1";
        final String source2 = "source2";

        //两个线程按不同的顺序获取资源
        new  Thread(new MyThread(source1,source2),"T1").start();
        new  Thread(new MyThread(source2,source1),"T2").start();
    }
}

class MyThread implements Runnable{

    //资源1
    private String source1;
    //资源2
    private String source2;

    public MyThread(String source1, String source2) {
        this.source1 = source1;
        this.source2 = source2;
    }

    @Override
    public void run() {
        synchronized (source1){
            System.out.println("线程 "+Thread.currentThread().getName() + "获取到资源 " + source1);
            System.out.println("线程 "+Thread.currentThread().getName() + "尝试获取资源 " + source2);
            synchronized(source2){
                System.out.println("线程 "+Thread.currentThread().getName() + "获取到资源 " + source2);
            }
        }
    }
}