JAVA锁

最新推荐文章于 2024-07-16 17:32:14 发布

Al_0922

最新推荐文章于 2024-07-16 17:32:14 发布

阅读量170

点赞数 2

分类专栏： JUC并发编程

本文链接：https://blog.csdn.net/Al_0922/article/details/118633258

版权

JUC并发编程专栏收录该内容

17 篇文章 0 订阅

订阅专栏

本文详细介绍了Java并发编程中的公平锁与非公平锁概念，包括它们的工作原理、区别以及在ReentrantLock中的实现。公平锁遵循先来后到原则，而非公平锁则可能造成线程饥饿。同时，文章提到了可重入锁的重要性，它是避免死锁的关键。在实际应用中，非公平锁通常具有更高的吞吐量。最后，通过示例展示了死锁的产生及如何使用jstack工具检测死锁情况。

摘要由CSDN通过智能技术生成

公平锁非公平锁

公平锁：是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到。
非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比现申请的线程优先获取锁，在高并发的情况下，有可能会造成优先级反转或者饥饿现象。

	// 无参
public ReentrantLock() {
	sync = new NonfairSync();
}
	// 有参
public ReentrantLock(boolean fair) {
	sync = fair ? new FairSync() : new NonfairSync();
}

区别

并发包中的 ReentrantLock 的创建可以指定构造函数的 boolean类型来得到公平锁或者非公平锁，默认是非公平锁！
公平锁：就是很公平，在并发环境中，每个线程在获取到锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己。
非公平锁：非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就会采用类似公平锁那种方式。
Java ReentrantLock 而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。对于Synchronized而言，也是一种非公平锁。

public class ReenTrantLock {
    public static void main(String[] args) {
        Tickets tickets = new Tickets();
        new Thread(()->{
            for (int i = 0; i <40; i++) {
                tickets.sale();
            }
        },"AA").start();
        new Thread(()->{
            for (int i = 0; i <40; i++) {
                tickets.sale();
            }
        },"BB").start();
        new Thread(()->{
            for (int i = 0; i <40; i++) {
                tickets.sale();
            }
        },"CC").start();
    }

}

class Tickets{
    private int ticket=30;
    ReentrantLock lock = new ReentrantLock(true);
    //卖票
    public void sale(){
        lock.lock();
        try {
            if (ticket>0) {
                System.out.println(Thread.currentThread().getName() + "卖出" + (ticket--) + ",剩余" + ticket);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

可重入锁

可重入锁（也叫递归锁）

指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

也就是说，线程可以进入任何一个它已经拥有的锁，所同步着的代码块。好比家里进入大门之后，就可以进入里面的房间了；
ReentrantLock、Synchronized 就是一个典型的可重入锁；
可重入锁最大的作用就是避免死锁

synchronized隐式------可重入锁

public class SyncLockDemo {

    //synchronized隐式锁，上锁解锁自动完成
    //synchronized同步方法验证synchronized是可重入锁
    public synchronized void add(){
        add();
    }

    public static void main(String[] args) {

        new  SyncLockDemo().add();//java.lang.StackOverflowError
        //
        Object o = new Object();

        //synchronized同步代码块验证synchronized是可重入锁
        new Thread(()->{
            synchronized (o){
                System.out.println(Thread.currentThread().getName()+"外层");

                synchronized (o){
                    System.out.println(Thread.currentThread().getName()+"中层");

                    synchronized (o){
                        System.out.println(Thread.currentThread().getName()+"外层");
                    }
                }
            }
        },"T1").start();
    }
}

lock显示----可重入锁

public class SyncLockDemo {


    public static void main(String[] args) {
        Object o = new Object();

        Lock lock = new ReentrantLock();
        //演示lock显示锁
        new Thread(()->{
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"外层");

                try {
                    lock.lock();
                    System.out.println(Thread.currentThread().getName()+"中层");

                    try {
                        lock.lock();
                        System.out.println(Thread.currentThread().getName()+"内层");
                    } finally {
                        lock.unlock();
                    }
                } finally {
                    lock.unlock();
                }
            } finally {
                lock.unlock();
            }
        },"T1").start();
    }
}

死锁

什么是死锁？
两个或两个以上线程在执行过程中，因为争夺资源而造成的一种互相等待的现象，如果没有外力干涉，就无法执行下去。

在这里插入图片描述
产生死锁的原因：

系统资源不足
进程运行推进顺序不合适
资源分配不当

快速写一个死锁

public class deadLockDemo {

    static Object a = new Object();
    static Object b = new Object();
    public static void main(String[] args) {

        new Thread(()->{
            synchronized (a){
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"持有锁a，试图获取锁b");

                synchronized (b){
                    System.out.println(Thread.currentThread().getName()+"获取锁b");
                }
            }
        },"A").start();

        new Thread(()->{
            synchronized (b){
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"持有锁b，试图获取锁a");

                synchronized (a){
                    System.out.println(Thread.currentThread().getName()+"获取锁a");
                }
            }
        },"B").start();
    }
}