java ReentrantLock 公平锁 非公平锁 测试

 1 package reentrantlock;
 2
 3 import java.util.ArrayList;
 4 import java.util.concurrent.locks.ReentrantLock;
 5
 6 public class TestFairSyn {
 7
 8     public static void main(String[] args) {
 9         ArrayList<Thread> arrayList = new ArrayList<>();
10         Resrc resrc = new Resrc();
11
12         for (int i = 0; i < 15; i++){
13             arrayList.add(new Thread(resrc));
14         }
15         for (int i = 0; i < 15; i++){
16             arrayList.get(i).start();
17         }
18     }
19
20     static class Resrc implements Runnable{
21         private static boolean isTestFair = true;
22         ReentrantLock reentrantLock = new ReentrantLock(isTestFair);
23
24         @Override
25         public void run() {
26             System.out.println(Thread.currentThread().getId()+" 尝试获得锁");
27             reentrantLock.lock();
28             if (false){
29                 System.out.println("\t\t" + Thread.currentThread().getId() + " 成功获得锁-解锁");
30                 reentrantLock.unlock();
31             }
32             else {
33                 try {
34                     System.out.println("\t\t" + Thread.currentThread().getId() + " 成功获得锁");
35                     // 如果测试 公平锁,把睡眠时间取消,能够大大增加线程的抢占现象
36                     Thread.sleep(0, 100);
37                 } catch (InterruptedException e) {
38                     e.printStackTrace();
39                 } finally {
40                     System.out.println("\t\t" + "\t\t" + Thread.currentThread().getId() + " 解锁");
41                     reentrantLock.unlock();
42                 }
43             }
44         }
45     }
46
47 }

原文地址:https://www.cnblogs.com/cnblogszs/p/10361387.html

时间: 2024-11-14 13:04:04

java ReentrantLock 公平锁 非公平锁 测试的相关文章

最全Java锁详解:独享锁/共享锁+公平锁/非公平锁+乐观锁/悲观锁

在Java并发场景中,会涉及到各种各样的锁如公平锁,乐观锁,悲观锁等等,这篇文章介绍各种锁的分类: 公平锁/非公平锁 可重入锁 独享锁/共享锁 乐观锁/悲观锁 分段锁 自旋锁 01.乐观锁 vs 悲观锁 乐观锁与悲观锁是一种广义上的概念,体现了看待线程同步的不同角度,在Java和数据库中都有此概念对应的实际应用. 1.乐观锁 顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号等机制. 乐观锁适用于多

【多线程】公平锁/非公平锁、乐观锁/悲观锁

公平锁/非公平锁(多线程执行顺序的维度) 概念理解 公平锁:加锁前先查看是否有排队等待的线程,有的话优先处理排在前面的线程,先来先得. 非公平所:线程加锁时直接尝试获取锁,获取不到就自动到队尾等待. 例子 ReentrantLock 同时支持两种锁 //创建一个非公平锁,默认是非公平锁 Lock nonFairLock= new ReentrantLock(); Lock nonFairLock= new ReentrantLock(false); //创建一个公平锁,构造传参true Lock

锁的公平与非公平

锁是给线程用的,线程拿到锁之后才能干活.当多个线程竞争一个锁时,同一个时间只能有一个线程脱颖而出持有锁,其他线程等该线程释放锁后发起下一轮竞争.那么这种竞争就存在公平性问题,如果是公平的竞争,那么这些线程就得有序来依次得到锁,这就需要线程们按先来后到排队,第一个线程使用完后把锁递给第二个线程,以此类推.非公平的锁是无序的,举个例子:线程甲持有锁,后面线程乙跑过来争,发现被甲拿了就去睡觉(休眠或者被挂起)了,等线程甲释放锁通知乙来取:过了会儿,乙被唤醒时,刚好线程丙半路杀过来了,把锁拿去用了,而乙

Java多线程系列--“JUC锁”05之 非公平锁

获取非公平锁(基于JDK1.7.0_40) 非公平锁和公平锁在获取锁的方法上,流程是一样的:它们的区别主要表现在"尝试获取锁的机制不同".简单点说,"公平锁"在每次尝试获取锁时,都是采用公平策略(根据等待队列依次排序等待):而"非公平锁"在每次尝试获取锁时,都是采用的非公平策略(无视等待队列,直接尝试获取锁,如果锁是空闲的,即可获取状态,则获取锁).在前面的"Java多线程系列--"JUC锁"03之 公平锁(一)&q

带你快速了解Java锁中的公平锁与非公平锁

前言 Java语言中有许多原生线程安全的数据结构,比如ArrayBlockingQueue.CopyOnWriteArrayList.LinkedBlockingQueue,它们线程安全的实现方式并非通过synchronized关键字,而是通过java.util.concurrent.locks.ReentrantLock来实现. 锁的底层实现 无论什么语言在操作系统层面锁的操作都会变成系统调用(System Call),以 Linux 为例,就是 futex 函数,可以把它理解为两个函数:fu

Java多线程编程4--Lock的使用--公平锁和非公平锁

公平与非公平锁:锁Lock分为"公平锁"和"非公平锁",公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的,即先来先得的FIFO先进先出顺序.而非公平锁就是一种获取锁的抢占机制,是随机获得锁的,和公平锁不一样的就是先来的不一定先得到锁,这个方式可能造成某些线程一直拿不到锁,结果也就是不公平的了. 1.公平锁实例 public class Service { private ReentrantLock lock ; public Service(boolean i

理解ReentrantLock的公平锁和非公平锁

学习AQS的时候,了解到AQS依赖于内部的FIFO同步队列来完成同步状态的管理,当前线程获取同步状态失败时,同步器会将当前线程以及等待状态等信息构造成一个Node对象并将其加入到同步队列,同时会阻塞当前线程,当同步状态释放时,会把首节点中的线程唤醒,使其再次尝试获取同步状态. 这时,我有了一个疑问,AQS的同步队列是FIFO的,就是先来排队的先走.那怎么实现非公平锁呢?查阅了一些资料,总算知道了. 首先从公平锁开始看起. ReentrantLock 的公平锁 ReentrantLock 默认采用

Java 中15种锁的介绍:公平锁,可重入锁,独享锁,互斥锁,乐观锁,分段锁,自旋锁等等(转)

Java 中15种锁的介绍 在读很多并发文章中,会提及各种各样锁如公平锁,乐观锁等等,这篇文章介绍各种锁的分类.介绍的内容如下: 公平锁 / 非公平锁 可重入锁 / 不可重入锁 独享锁 / 共享锁 互斥锁 / 读写锁 乐观锁 / 悲观锁 分段锁 偏向锁 / 轻量级锁 / 重量级锁 自旋锁 上面是很多锁的名词,这些分类并不是全是指锁的状态,有的指锁的特性,有的指锁的设计,下面总结的内容是对每个锁的名词进行一定的解释. 公平锁 / 非公平锁 公平锁 公平锁是指多个线程按照申请锁的顺序来获取锁. 非公

AQS实现公平锁和非公平锁

基于AQS的锁(比如ReentrantLock)原理大体是这样:有一个state变量,初始值为0,假设当前线程为A,每当A获取一次锁,status++. 释放一次,status--.锁会记录当前持有的线程.当A线程拥有锁的时候,status>0. B线程尝试获取锁的时候会对这个status有一个CAS(0,1)的操作,尝试几次失败后就挂起线程,进入一个等待队列.如果A线程恰好释放,--status==0, A线程会去唤醒等待队列中第一个线程,即刚刚进入等待队列的B线程,B线程被唤醒之后回去检查这