21、Java锁

21.1.公平锁非公平锁

是什么

公平锁:就是非常公平,先来后到

非公平锁:就是不公平,不按照先后顺序,可以插队!存在即道理,有的时候插队可以提高效率。

两者区别

公平锁:并发环境下,每个线程在获取锁的时候都要先看一下这个锁的等待队列!如果为空,那就可以占有锁!否则就要等待!

非公平锁:上来就直接尝试占有该锁!如果失败就会采用类似公平锁的方式!

synchronized :默认就是非公平锁,不可更改。

ReentrantLock :默认就是非公平锁,可以通过参数修改!

public ReentrantLock() {
   
     
    sync = new NonfairSync(); // 默认是非公平锁,随机
}

public ReentrantLock(boolean fair) {
   
      // 公平锁
    sync = fair ? new FairSync() : new NonfairSync();
}

21.2. 可重入锁

可重入锁:获取到外面的一把锁,里面的锁自动获取。

如车钥匙,车的播放音乐、开车前进、倒车、充电等功能,甲将钥匙给了乙,乙有了这把钥匙就能打开车门,点火,开车、放音乐。车钥匙就是可重入锁。如下示例:

 
递归锁就是可重入锁!

可重入锁最大的好处:就是避免死锁!

synchronized实现可重入锁,示例代码如下:

package com.interview.concurrent.lock.javalock;

/**
 * @author DDKK.COM 弟弟快看,程序员编程资料站
 * @description 描述:synchronized实现可重入锁
 * 可重入锁:获取到外面的一把锁,里面的锁自动获取
 * @date 2023/2/25 18:37
 */
public class RtLockSynchronized {
   
     

    public static void main(String[] args) {
   
     
        Car car = new Car();
        new Thread(() -> {
   
     
            car.carFire();
        },"carFire").start();

        new Thread(() -> {
   
     
            car.music();
        },"music").start();

        new Thread(() -> {
   
     
            car.runAdvance();
        },"runAdvance").start();
    }
}

class Car{
   
     
    // 外面的锁
    public synchronized void carFire(){
   
     
        System.out.println(Thread.currentThread().getName() + ":打火");
        /**
         *  @description:
         *  以下两个方法本来也是被锁的,但是由于获得了外面的锁,
         *  所以这个锁也获得了!
         *  @author DDKK.COM 弟弟快看,程序员编程资料站
         *  @date 2023/2/25 18:44
         */
        music();
        runAdvance();
    }
    public synchronized void music(){
   
     
        System.out.println(Thread.currentThread().getName() + ":播放音乐");
    }

    public synchronized void runAdvance(){
   
     
        System.out.println(Thread.currentThread().getName() + ":前进,走");
    }
}

运行效果如下:

 

ReentrantLock实现可重入锁,示例代码如下:

package com.interview.concurrent.lock.javalock;

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

/**
 * @author DDKK.COM 弟弟快看,程序员编程资料站
 * @description 描述:ReentrantLock实现可重入锁
 * 可重入锁:获取到外面的一把锁,里面的锁自动获取
 * @date 2023/2/25 18:37
 */
public class RtLockReentrantLock {
   
     

    public static void main(String[] args) {
   
     
        Car2 car = new Car2();
        new Thread(() -> {
   
     
            car.carFire();
        },"carFire").start();

        new Thread(() -> {
   
     
            car.music();
        },"music").start();

        new Thread(() -> {
   
     
            car.runAdvance();
        },"runAdvance").start();
    }
}

class Car2{
   
     
    Lock lock = new ReentrantLock();
    // 外面的锁
    public void carFire(){
   
     
        lock.lock();
        try {
   
     
            System.out.println(Thread.currentThread().getName() + ":打火");
            /**
             *  @description:
             *  以下两个方法本来也是被锁的,但是由于获得了外面的锁,
             *  所以这个锁也获得了!
             *  @author DDKK.COM 弟弟快看,程序员编程资料站
             *  @date 2023/2/25 18:44
             */
            music();
            runAdvance();
        } catch (Exception e) {
   
     
            e.printStackTrace();
        } finally {
   
     
            lock.unlock();
        }
    }
    public void music(){
   
     
        lock.lock();
        try {
   
     
            System.out.println(Thread.currentThread().getName() + ":播放音乐");
        } catch (Exception e) {
   
     
            e.printStackTrace();
        } finally {
   
     
            lock.unlock();
        }
    }

    public void runAdvance(){
   
     
        lock.lock();
        try {
   
     
            System.out.println(Thread.currentThread().getName() + ":前进,走");
        } catch (Exception e) {
   
     
            e.printStackTrace();
        } finally {
   
     
            lock.unlock();
        }
    }
}

21.3. 自旋锁

自旋锁spinlock

尝试获取锁的线程不会立即阻塞,采用循环的方式尝试获取锁!减少上下文的切换!缺点会消耗CPU

CAS的实现就是自旋锁,代码如下:

 @HotSpotIntrinsicCandidate
    public final int getAndAddInt(Object o, long offset, int delta) {
   
     
        int v;
        do {
   
     
            v = getIntVolatile(o, offset);
        } while (!weakCompareAndSetInt(o, offset, v, v + delta));
        return v;
    }

我们手动编写一个锁来测试!

package com.interview.concurrent.lock.javalock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * @author DDKK.COM 弟弟快看,程序员编程资料站
 * @description 描述
 * @date 2023/2/25 20:21
 */
public class SpinLock {
   
     
    AtomicReference atomicReference = new AtomicReference();

    public void lock(){
   
     
        Thread thread = Thread.currentThread();

        /**
         *  @description: 利用原子引用的自旋锁实现
         *  期望的值是空,就不会加锁,会一直循环,直到给期望值赋值
         *  @author DDKK.COM 弟弟快看,程序员编程资料站
         *  @date 2023/2/25 20:36
         */
        while(atomicReference.compareAndSet(null,thread)){
   
     

        }
    }

    public void unlock(){
   
     
        Thread thread = Thread.currentThread();
        //给AtomicReference赋期望值,就自动解锁
        atomicReference.compareAndSet(thread,null);
    }
}

测试

package com.interview.concurrent.lock.javalock;

/**
 * @author DDKK.COM 弟弟快看,程序员编程资料站
 * @description 描述:测试利用原子引用(AtomicRefrence)的自旋锁原理编写的锁
 * @date 2023/2/25 20:38
 */
public class SpinLockDemo {
   
     
    public static void main(String[] args) {
   
     

        Ticket ticket = new Ticket();
        new Thread(() -> {
   
     
            for (int i = 0; i < 10; i++) {
   
     
                ticket.saleTicket();
            }
        },"A").start();

        new Thread(() -> {
   
     
            for (int i = 0; i < 10; i++) {
   
     
                ticket.saleTicket();
            }
        },"B").start();

    }
}

class Ticket{
   
     
    int num = 50 ;

    //创建锁
    SpinLock spinLock = new SpinLock();
    public void saleTicket(){
   
     
        spinLock.lock();
        try {
   
     
            while(num > 0){
   
     
                System.out.println(Thread.currentThread().getName() + "卖出第" + num-- + "张票,还剩" + num + "张票");
            }
        } catch (Exception e) {
   
     
            e.printStackTrace();
        } finally {
   
     
            spinLock.unlock();
        }
    }
}

21.4. 死锁

可重入锁:可以避免死锁!

21.4.1 什么是死锁!

 
产生死锁的原因:

1、系统资源不足

2、进程运行顺序不当!

3、资源分配不当!

21.4.2. 死锁堆栈分析

package com.interview.concurrent.lock.javalock;

import java.util.concurrent.TimeUnit;

/**
 * @author DDKK.COM 弟弟快看,程序员编程资料站
 * @description 描述
 * @date 2023/2/25 21:14
 */
public class DeadLock {

   public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";

        Resources resources1 = new Resources(lockA,lockB);
        Resources resources2 = new Resources(lockB,lockA);
        new Thread(() -> {
            resources1.run();
        },"lockA").start();
        new Thread(() -> {
            resources2.run();
        },"lockB").start();

    }
}

class Resources{
    private String lockA;
    private String lockB;

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

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

            synchronized(lockB){
                System.out.println(Thread.currentThread().getName() + ":lock=" + lockB + "=>get:" + lockA);
            }
        }
    }
}

 

解决:

jps -l

 

查看死锁现象:jstack 进程号

 

死锁:针对死锁,要使用jstack来分析堆栈。