Java中公平锁与非公平锁

最新推荐文章于 2024-04-13 13:42:15 发布
最新推荐文章于 2024-04-13 13:42:15 发布
阅读量254 收藏
点赞数 1
文章标签： 队列 多线程 java 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41590779/article/details/108065212
版权

公平锁与非公平锁的区别

所谓公平锁，即新加入的线程会按照尝试获取锁的先后顺序依次拿到锁。
所谓非公平锁，即新加入的线程会进行lock方法加锁进行CAS尝试，加锁失败之后tryAcquire方法state为0时候还会进行加锁尝试，而公平锁lock加锁不会尝试，tryAcquire方法state为0时候并且前面没有线程队列排队的时候才会进行加锁尝试。

  • 非公平锁的线程加锁会先进行CAS操作尝试获取锁，而公平锁直接进行后续操作。实现即重写抽象类Sync的lock方法的不同。
  • 非公平锁如果state状态为0就尝试加锁，而公平锁如果state为0并且前面没有排队的线程队列才尝试加锁。实现即重写抽象类AQS的tryAcquire方法的不同。

为什么要有非公平锁

提高效率，避免唤醒线程带来的空档期。在唤醒线程期间，如果有线程立刻获取锁，就可以将锁给他立刻执行。

ReentrantLock公平锁与非公平锁核心源码分析：

公平锁：

file

非公平锁：

file

file

具体请查看：ReentrantLock核心源码分析

公平锁中的特例

tryLock()是一个特例，即使你是公平锁，当你调用tryLock的时候，即使设置的是公平锁，前面有线程排队，也会立即尝试，不遵守公平锁规则。

1、直接调用非公平锁（抽象类Sync）中的nonfairTryAcquire方法尝试。

	public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

2、调用抽象类Sync的nonfairTryAcquire方法加锁

public class ReentrantLock implements Lock, java.io.Serializable {

	abstract static class Sync extends AbstractQueuedSynchronizer {

        /**
         * tryLock方法也会调用这个方法直接尝试，即使设置的是公平锁。
         */
        final boolean nonfairTryAcquire(int acquires) {
			// 获取当前线程
            final Thread current = Thread.currentThread();
			// 得到AQS的状态
            int c = getState();
			// 如果未加锁
            if (c == 0) {
				// CAS尝试加锁
                if (compareAndSetState(0, acquires)) {
					// 设置当前线程持有锁
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
			// 如果获取锁是当前线程
            else if (current == getExclusiveOwnerThread()) {
				// acquires为1，所以加锁每次AQS的状态加1。
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
				// 设置状态
                setState(nextc);
                return true;
            }
            return false;
        }
    }
}

公平锁与非公平锁优缺点

锁形式优点缺点
公平锁公平等待，每个线程在一段时间后都会有执行的机会有线程切换的开销，吞吐量相对较小
非公平锁没有线程切换的开销，吞吐量相对较大有时候会导致线程长时间得不到执行

公平锁与非公平锁代码演示

公平锁

每次打印任务需要打印两次，即同一个线程需要加锁解锁两次。 获取第一把锁执行时候，别的线程会尝试第一把锁，所以获得第二吧锁的时候需要等待其他线程第一次执行释放锁执行完成之后。每个启动线程启动有10ms的差距保证启动顺序。

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author weilai
 * @email 352342845@qq.com
 * @date 2020/3/23 12:58 下午
 */
public class DemoLock {

    public static void main(String[] args) {
        PrintQueue printQueue = new PrintQueue();
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(new PrintTask(printQueue));
        }
        for (int i = 0; i < 10; i++) {
            threads[i].start();
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class PrintTask implements Runnable {

    private PrintQueue printQueue;

    public PrintTask(PrintQueue printQueue) {
        this.printQueue = printQueue;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始任务");
        printQueue.printTask();
        System.out.println(Thread.currentThread().getName() + "结束任务");
    }
}

class PrintQueue {

    private ReentrantLock lock = new ReentrantLock(true);

    public void printTask() {
        print(1);
        print(2);
    }

    private void print(int count) {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "第" + count + "正在打印，需要1秒");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } finally {
            lock.unlock();
        }
    }

}

output：

Thread-0开始任务
Thread-0第1正在打印，需要1秒
Thread-1开始任务
Thread-2开始任务
Thread-3开始任务
Thread-4开始任务
Thread-5开始任务
Thread-6开始任务
Thread-7开始任务
Thread-8开始任务
Thread-9开始任务
Thread-1第1正在打印，需要1秒
Thread-2第1正在打印，需要1秒
Thread-3第1正在打印，需要1秒
Thread-4第1正在打印，需要1秒
Thread-5第1正在打印，需要1秒
Thread-6第1正在打印，需要1秒
Thread-7第1正在打印，需要1秒
Thread-8第1正在打印，需要1秒
Thread-9第1正在打印，需要1秒
Thread-0第2正在打印，需要1秒
Thread-0结束任务
Thread-1第2正在打印，需要1秒
Thread-1结束任务
Thread-2第2正在打印，需要1秒
Thread-2结束任务
Thread-3第2正在打印，需要1秒
Thread-3结束任务
Thread-4第2正在打印，需要1秒
Thread-4结束任务
Thread-5第2正在打印，需要1秒
Thread-5结束任务
Thread-6第2正在打印，需要1秒
Thread-6结束任务
Thread-7第2正在打印，需要1秒
Thread-7结束任务
Thread-8第2正在打印，需要1秒
Thread-8结束任务
Thread-9第2正在打印，需要1秒
Thread-9结束任务

非公平锁

每个线程需要加锁解锁两次，第一次释放锁的时候，在还没有唤醒排队线程的时候，当前线程又进行第二次加锁，满足非公平锁的尝试插队的情况，所以第二次会立刻获取锁，执行顺序为每次线程依次打印两次。

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author weilai
 * @email 352342845@qq.com
 * @date 2020/3/23 12:58 下午
 */
public class DemoLock {

    public static void main(String[] args) {
        PrintQueue printQueue = new PrintQueue();
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(new PrintTask(printQueue));
        }
        for (int i = 0; i < 10; i++) {
            threads[i].start();
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class PrintTask implements Runnable {

    private PrintQueue printQueue;

    public PrintTask(PrintQueue printQueue) {
        this.printQueue = printQueue;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始任务");
        printQueue.printTask();
        System.out.println(Thread.currentThread().getName() + "结束任务");
    }
}

class PrintQueue {

    private ReentrantLock lock = new ReentrantLock(false);

    public void printTask() {
        print(1);
        print(2);
    }

    private void print(int count) {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "第" + count + "正在打印，需要1秒");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } finally {
            lock.unlock();
        }
    }

}

output：

Thread-0开始任务
Thread-0第1正在打印，需要1秒
Thread-1开始任务
Thread-2开始任务
Thread-3开始任务
Thread-4开始任务
Thread-5开始任务
Thread-6开始任务
Thread-7开始任务
Thread-8开始任务
Thread-9开始任务
Thread-0第2正在打印，需要1秒
Thread-0结束任务
Thread-1第1正在打印，需要1秒
Thread-1第2正在打印，需要1秒
Thread-1结束任务
Thread-2第1正在打印，需要1秒
Thread-2第2正在打印，需要1秒
Thread-2结束任务
Thread-3第1正在打印，需要1秒
Thread-3第2正在打印，需要1秒
Thread-3结束任务
Thread-4第1正在打印，需要1秒
Thread-4第2正在打印，需要1秒
Thread-4结束任务
Thread-5第1正在打印，需要1秒
Thread-5第2正在打印，需要1秒
Thread-5结束任务
Thread-6第1正在打印，需要1秒
Thread-6第2正在打印，需要1秒
Thread-6结束任务
Thread-7第1正在打印，需要1秒
Thread-7第2正在打印，需要1秒
Thread-7结束任务
Thread-8第1正在打印，需要1秒
Thread-8第2正在打印，需要1秒
Thread-8结束任务
Thread-9第1正在打印，需要1秒
Thread-9第2正在打印，需要1秒
Thread-9结束任务
weixin_41590779
关注
Java并发编程（14）—— Java中的公平锁和非公平锁
shangjg3的博客
07-10 1079
在Synchronized中，当一个线程释放锁时，JVM会从等待队列中随机选择一个线程来获取锁，而不是按照申请锁的顺序来获取锁，因此Synchronized是一种非公平锁。在并发环境中，每一个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个就占有锁，否者就会加入到等待队列中，以后会按照 FIFO 的规则获取锁。Synchronized是Java中内置的锁机制，它的锁模式是非公平锁，这是因为Synchronized的实现方式是基于对象监视器（monitor）的。
Java中ReentrantLock，公平锁，非公平锁与synchronized
qq_40076948的博客
03-25 1145
本文内容及代码参考视频：https://www.bilibili.com/video/BV1ta4y1H73X/?spm_id_from=333.788.recommend_more_video.-1 ReentrantLock是Java开发中最常用到的组件之一，简单来说，可以把ReentrantLock理解为基于AQS所实现的公平锁与非公平锁，用于实现对共享资源对象的同步。它和synchronized关键字一样支持可重入，但在调度上相较于synchronized更加的灵活。接下来我们从其内部继承和功能.
Java锁——公平锁与非公平锁
枫陵的博客
05-04 1299
概念 公平锁：按序排队，判断同步队列是否还有先驱节点(hasQueuedPredecessors)的存在(我前面还有人吗?)，如果没有先驱节点才能获取锁 非公平锁: 先占先得，只要能抢获到同步状态就可以 问题 为什么会有公平锁和非公平锁的设计？为什么默认非公平？ 1. 恢复挂起的线程到真正锁的获取还是有时间差的，从开发人员来看这个时间微乎其微，但是从CPU的角度来看，这个时间差存在的还是很明显的。所以非公平锁能更充分的利用CPU的时间片，尽量减少CPU空闲状态时间 2. 使用多线程很重要的考量点
Java进阶篇--公平锁 & 非公平锁
m0_74293254的博客
10-15 3240
Java进阶篇--公平锁 & 非公平锁
Java那些“锁”事 - 公平锁和非公平锁
大后生大大大的博客
07-26 1177
在Java中，锁可以分为公平锁（Fair Lock）和非公平锁（Nonfair Lock），它们的区别在于线程获取锁的顺序是否遵循公平性原则。
java里面的公平锁和非公平锁
及时雨的csdn
09-18 415
java里面的线程加锁机制有两种方式,一种是使用synchronize关键字修饰代码块或者方法,另外一种是jdk1.5以后在juc包下实现的lock锁机制,本文讨论的主要是juc包下面的重入锁ReentrantLock. 实现方式: 公平锁: Lock lock = new ReentrantLock (true); 非公平锁 Lock lock = new ReentrantLock ()...
java 线程公平锁与非公平锁详解及实例代码
08-31
Java线程公平锁与非公平锁是并发编程中重要的概念，尤其在使用ReentrantLock时。ReentrantLock是Java并发包（java.util.concurrent）中的一个可重入互斥锁，它提供了比内置的synchronized关键字更为灵活的锁操作。 ...
Java线程公平锁和非公平锁的差异讲解
08-26
Java线程公平锁和非公平锁是Java并发编程中重要的概念，主要体现在`java.util.concurrent.locks`包下的`ReentrantLock`类中。`ReentrantLock`提供了可配置的公平性和非公平性，允许开发者根据应用需求选择合适的锁...
知识点: Java公平锁与非公平锁 原理讲解ReentrantLock 锁的饥饿效应及解决办法
码农杰森
06-14 2633
公平锁与非公平锁理论前言AQS公平锁非公平锁ReentrantLock 使用ReentrantLock 解决饥饿效应 本文知识： 公平锁与非公平锁理论 AQS的理论与原理讲解 公平锁与非公平锁原理讲解 ReentrantLock的使用 非公平锁饥饿效应解决方法 在上篇中分析了Java并发编程中悲观锁与乐观锁的实现算法，并分析了原子类中使用CAS算法实现乐观锁以及ABA、自旋等问题。 延续上篇继续导论Java ReentrantLock锁，如果实现公平锁与非公平锁。 前言 公平锁：多个线程申请锁时是相对公
公平锁&非公平锁.pdf
10-21
公平锁（Fair Lock）和非公平锁（Non-Fair Lock）是 Java 中的两种锁机制，用于实现线程同步。它们都继承自 AbstractQueuedSynchronizer（AQS），是 ReentrantLock 的基础实现。 公平锁的特点是，它会按照线程的...
java锁 -- 公平锁与非公平锁
比利的博客
10-13 1146
java锁 -- 公平锁与非公平锁
【Java常见锁（公平锁、非公平锁、可重入锁、自旋锁、独占锁、共享锁）】
weixin_46356409的博客
08-02 1518
Java常见锁（公平锁、非公平锁、可重入锁、自旋锁、独占锁、共享锁）
java之公平锁与非公平锁
泷泷养的乔小胖
05-26 808
大厂面试题：公平锁/非公平锁/重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁。 1、什么是公平锁和非公平锁 公平锁：是指多个线程按照申请锁的顺序来获取锁，类似与排队打饭，先来后到。 非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发的情况下，有可能造成优先级反转或者饥饿现象。 2、公平锁和非公平锁举例 Reentra...
java公平锁和非公平锁_Java公平锁与非公平锁
weixin_36295010的博客
02-26 171
Java公平锁与非公平锁大多数情况下，锁的申请都是非公平的，如果线程1与线程2都在请求锁A，当锁A可用时，系统只是会从阻塞队列中随机的选择一个线程, 不能保证其公平性。公平的锁会按照时间先后顺序,保证先到先得, 公平锁的这一特点不会出现线程饥饿现象。synchronized内部锁就是非公平的. ReentrantLock重入锁提供了一个构造方法:ReentrantLock(boolean fa...
Java公平锁和非公平锁
LLLlucky_boy的博客
08-16 157
目录显示锁ReentrantLock()也是非公平锁公平锁 显示锁ReentrantLock()也是非公平锁 顾名思义就是在锁代码块的时候可以自己指定开始位置和结束位置不能被线程共享，非公平锁在线程进入就绪状态时是抢占式占有时间片的。如下： public class Demo08 { public static void main(String[] args) { Runnable t = new Ticket(); new Thread(t).start();
公平锁和非公平锁
ycd500756的博客
01-08 611
转载于《Java多线程核心技术》 定义： 公平锁：按照线程加锁的顺序来分配，即先来先得FIFO； 非公平锁：一种获取锁的抢占机制，是随机的获得锁的，这样可能会有些线程一直会拿不到锁，结果也就是不公平的。 1.公平锁实例代码： package test.Thread4; import java.util.concurrent.locks.ReentrantLock; class Se
31、java公平锁和非公平锁，以及为什么要“非公平”？
最新发布
zht245648124的博客
04-13 1570
公平锁指的是按照线程请求的顺序，来分配锁；而非公平锁指的是不完全按照请求的顺序，在一定情况下，可以允许插队。但需要注意这里的非公平并不是指完全的随机，不是说线程可以任意插队，而是仅仅“在合适的时机”插队。那么什么时候是合适的时机呢？假设当前线程在请求获取锁的时候，恰巧前一个持有锁的线程释放了这把锁，那么当前申请锁的线程就可以不顾已经等待的线程而选择立刻插队。但是如果当前线程请求的时候，前一个线程并没有在那一时刻释放锁，那么当前线程还是一样会进入等待队列。
Java 公平锁 & 非公平锁
xiangxiongfly
02-19 2245
文章目录Java 公平锁 & 非公平锁概述论证synchronized是非公平锁论证ReentrantLock(false)是非公平锁论证ReentrantLock(true)是公平锁判断是否为公平锁 Java 公平锁 & 非公平锁 概述 公平：每个线程获取锁的机会是平等的。常见公平锁对象：new ReentrantLock(true)、new ReentrantReadWriteLock(true)等。 非公平：每个线程获取锁的机会是不平等的。常见非公平锁对象：synchronized、
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值