1-4并发编程（4）

最新推荐文章于 2024-02-08 09:53:25 发布
最新推荐文章于 2024-02-08 09:53:25 发布
阅读量192 收藏
点赞数
分类专栏： juc与jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Insist___/article/details/104359941
版权

文章目录

1 lock

1.1reentrantlock用于替代synchronized

/**
 * reentrantlock用于替代synchronized
 * 由于m1锁定this,只有m1执行完毕的时候,m2才能执行
 * 这里是复习synchronized最原始的语义
 * 
 * 使用reentrantlock可以完成同样的功能
 * 需要注意的是，必须要必须要必须要手动释放锁（重要的事情说三遍）
 * 使用syn锁定的话如果遇到异常，jvm会自动释放锁，但是lock必须手动释放锁，因此经常在finally中进行锁的释放
 * @author mashibing
 */
package yxxy.c_020;

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

public class ReentrantLock2 {
	Lock lock = new ReentrantLock();

	void m1() {
		try {
			lock.lock(); //synchronized(this)
			for (int i = 0; i < 10; i++) {
				TimeUnit.SECONDS.sleep(1);

				System.out.println(i);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	void m2() {
		lock.lock();
		System.out.println("m2 ...");
		lock.unlock();
	}

	public static void main(String[] args) {
		ReentrantLock2 rl = new ReentrantLock2();
		new Thread(rl::m1).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(rl::m2).start();
	}
}

1.2使用reentrantlock可以进行“尝试锁定”tryLock，这样无法锁定，或者在指定时间内无法锁定，线程可以决定是否继续等待

/**
 * reentrantlock用于替代synchronized
 * 由于m1锁定this,只有m1执行完毕的时候,m2才能执行
 * 这里是复习synchronized最原始的语义
 * 
 * 使用reentrantlock可以完成同样的功能
 * 需要注意的是，必须要必须要必须要手动释放锁（重要的事情说三遍）
 * 使用syn锁定的话如果遇到异常，jvm会自动释放锁，但是lock必须手动释放锁，因此经常在finally中进行锁的释放
 * 
 * 使用reentrantlock可以进行“尝试锁定”tryLock，这样无法锁定，或者在指定时间内无法锁定，线程可以决定是否继续等待
 * @author mashibing
 */
package yxxy.c_020;

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

public class ReentrantLock3 {
	Lock lock = new ReentrantLock();

	void m1() {
		try {
			lock.lock();
			for (int i = 0; i < 10; i++) {
				TimeUnit.SECONDS.sleep(1);

				System.out.println(i);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	/**
	 * 使用tryLock进行尝试锁定，不管锁定与否，方法都将继续执行
	 * 可以根据tryLock的返回值来判定是否锁定
	 * 也可以指定tryLock的时间，由于tryLock(time)抛出异常，所以要注意unclock的处理，必须放到finally中
	 */
	void m2() {
		/*
		boolean locked = lock.tryLock();
		System.out.println("m2 ..." + locked);
		if(locked) lock.unlock();
		*/
		
		boolean locked = false;
		
		try {
			locked = lock.tryLock(5, TimeUnit.SECONDS);
			System.out.println("m2 ..." + locked);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			if(locked) lock.unlock();
		}
		
	}

	public static void main(String[] args) {
		ReentrantLock3 rl = new ReentrantLock3();
		new Thread(rl::m1).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(rl::m2).start();
	}
}

1.3使用ReentrantLock还可以调用lockInterruptibly方法，可以对线程interrupt方法做出响应，在一个线程等待锁的过程中，可以被打断

有个线程一直在占用资源。
其他线程不想在等待了，

/**
 * reentrantlock用于替代synchronized
 * 由于m1锁定this,只有m1执行完毕的时候,m2才能执行
 * 这里是复习synchronized最原始的语义
 * 
 * 使用reentrantlock可以完成同样的功能
 * 需要注意的是，必须要必须要必须要手动释放锁（重要的事情说三遍）
 * 使用syn锁定的话如果遇到异常，jvm会自动释放锁，但是lock必须手动释放锁，因此经常在finally中进行锁的释放
 * 
 * 使用reentrantlock可以进行“尝试锁定”tryLock，这样无法锁定，或者在指定时间内无法锁定，线程可以决定是否继续等待
 * 
 * 使用ReentrantLock还可以调用lockInterruptibly方法，可以对线程interrupt方法做出响应，
 * 在一个线程等待锁的过程中，可以被打断
 * 
 * @author mashibing
 */
package yxxy.c_020;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Function;

public class ReentrantLock4 {
		
	public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		
		
		Thread t1 = new Thread(()->{
			try {
				lock.lock();
				System.out.println("t1 start");
				TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
				System.out.println("t1 end");
			} catch (InterruptedException e) {
				System.out.println("interrupted!");
			} finally {
				lock.unlock();
			}
		});
		t1.start();
		
		Thread t2 = new Thread(()->{
			try {
				//lock.lock();
				lock.lockInterruptibly(); //可以对interrupt()方法做出响应
				System.out.println("t2 start");
				TimeUnit.SECONDS.sleep(5);
				System.out.println("t2 end");
			} catch (InterruptedException e) {
				System.out.println("interrupted!");
			} finally {
				lock.unlock();
			}
		});
		t2.start();
		
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.interrupt(); //打断线程2的等待
		
	}
}

1.4ReentrantLock还可以指定为公平锁

synchronized是非公平锁。
好多个线程访问一个资源，要锁定这个资源的锁。当有个资源拿到了这把锁，占有这把锁之后，其他线程都是访问不了的。都得等着。一旦释放了锁。其他哪个线程拿到锁说不定，要看线程调度器选择哪个了，没有公平可言，有可能这个线程等一秒就拿到锁了。其他线程等了一天也没有拿到
这个效率比较高。不用计算线程等待时间。
ReentrantLock 是公平锁
谁等的时间长，就获得这把锁。

/**
 * reentrantlock用于替代synchronized
 * 由于m1锁定this,只有m1执行完毕的时候,m2才能执行
 * 这里是复习synchronized最原始的语义
 * 
 * 使用reentrantlock可以完成同样的功能
 * 需要注意的是，必须要必须要必须要手动释放锁（重要的事情说三遍）
 * 使用syn锁定的话如果遇到异常，jvm会自动释放锁，但是lock必须手动释放锁，因此经常在finally中进行锁的释放
 * 
 * 使用reentrantlock可以进行“尝试锁定”tryLock，这样无法锁定，或者在指定时间内无法锁定，线程可以决定是否继续等待
 * 
 * 使用ReentrantLock还可以调用lockInterruptibly方法，可以对线程interrupt方法做出响应，
 * 在一个线程等待锁的过程中，可以被打断
 * 
 * ReentrantLock还可以指定为公平锁
 * 
 * @author mashibing
 */
package yxxy.c_020;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLock5 extends Thread {
		
	private static ReentrantLock lock=new ReentrantLock(true); //参数为true表示为公平锁，请对比输出结果
    public void run() {
        for(int i=0; i<100; i++) {
            lock.lock();
            try{
                System.out.println(Thread.currentThread().getName()+"获得锁");
            }finally{
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) {
        ReentrantLock5 rl=new ReentrantLock5();
        Thread th1=new Thread(rl);
        Thread th2=new Thread(rl);
        th1.start();
        th2.start();
    }
}
Insist___
关注
专栏目录
62-Java并发编程实战
10-10
62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java...
13-Java并发编程学习宝典.zip
06-22
Java并发编程是软件开发中的重要领域，特别是在大型系统和高并发场景中不可或缺。"13-Java并发编程学习宝典.zip" 包含了一系列关于Java并发编程的学习资源，旨在帮助开发者掌握多线程编程的核心技术和最佳实践。以下...
【代码】ReentrantLock还可以指定为公平锁
学亮编程手记
05-07 502
ReentrantLock还可以指定为公平锁 默认非公平 参数为true表示为公平锁，请对比输出结果 import java.util.concurrent.locks.ReentrantLock; /* ReentrantLock还可以指定为公平锁 */ public class T05_ReentrantLock5 extends Thread { private sta...
18 ReentrantLock还可以指定为公平锁
cihuan0804的博客
07-16 102
默认的synchronized都是非公平锁。 （多个线程访问同一个资源，其中一个线程拿到锁。等一秒和等一天没准下一秒还是等一秒的先拿到锁。） 公平锁：就是谁等的时间长，让谁拿到这把锁。 公平锁效率比较低，但是比较公平。非公平锁效率比较高，但是不公平。 public class Reentran...
ReentrantLock公平锁与非公平锁
远方的少年
04-28 283
ReentrantLock既可以实现公平锁也可以实现非公平锁，可以通过构造方法中的参数来指定。 public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); } 下面一个例子可以测试一下Reentrantlock的公平锁与非公平锁的区别。大家可以改构造方法的参数...
ReentrantLock实现公平锁和非公平锁
qq_35270686的博客
02-03 626
ReentrantLock公平锁，非公平锁实现
JAVA进阶之路-ReentrantLock的公平锁和非公平锁
08-12 1095
通过学习AQS的原理，我们了解到，AQS内部是通过一个FIFO同步队列来完成同步状态的管理。当线程获取当前状态的时候（内部其实就是更新操作），同步器会将当前的状态构建成一个node节点对象，将其放入到同步队列中，同时底层调用LockSupport.park(this)来阻塞当前线程，释放cpu。当同步状态释放的时候，会把首节点进行环形，使其再次尝试获取同步状态。 那么内部的公平和非公平是如何来实现...
桫哥-GOlang-13并发编程
06-12
"桫哥-GOlang-13并发编程"的主题深入探讨了Go语言的并发编程这一关键特性，这对于理解和编写高效、可扩展的Go程序至关重要。 并发编程是现代软件开发中的一个核心概念，它允许程序同时执行多个任务，从而提高系统...
图解ReentrantLock公平锁和非公平锁实现
m0_73311735的博客
10-13 4032
ReentrantLock是Java并发中十分常用的一个类，具备类似synchronized锁的作用。但是相比synchronized, 它具备更强的能力，同时支持公平锁和非公平锁。指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。多个线程加锁时直接尝试获取锁，能抢到锁到直接占有锁，抢不到才会到等待队列的队尾等待。那ReentrantLock中具体是怎么实现公平和非公锁的呢？它们之间又有什么优缺点呢？本文就带大家一探究竟。
ReentrantLock（公平锁、非公平锁）可重入锁原理
starsray的博客
07-20 392
基本使用 ReentrantLock，位于java.util.concurrent包，于JDK1.5引入，一种可重入互斥Lock ，其基本行为和语义与使用synchronized方法和语句访问的隐式监视器锁相同，但具有扩展功能。 ReentrantLock的使用也很简单，在源码注释中可以看到使用的推荐方式： public void m() { lock.lock(); // block...
详解ReentrantLock---公平锁与非公平锁
qq_15045645的博客
08-04 291
https://blog.csdn.net/ljz2016/article/details/77696671 https://blog.csdn.net/qq_42001445/article/details/108429202 https://blog.csdn.net/m47838704/article/details/80013056 其中AbstractOwnableSynchronizer是提供了设置占用当前锁的线程信息的方法，主要的锁的实现还是在AbstractQueuedSynchr
ReentrantLock 和 公平锁
最新发布
qq_38254978的博客
02-08 824
ReentrantLock的基本使用// 一般要在一个类中定位为全局变量// 加锁逻辑一定不可以写在try内部try {count++;// 执行完输出一句话say();// 一定要在finally中增加解锁操作，否则可能会造成死锁。// 也可以再加锁,此时如果同一线程获取到锁，就是重入，holdCount会进行++操作，标识当前线程获取到锁的次数// 如果是不加锁的情况下，此时在main函数中的输出应该是 1,1try {test.say();// 输出 0。
ReentrantLock深度剖析(公平锁,非公平锁)
ILIKETANGBOHU的博客
09-30 469
第一次循环会通过CAS将队列的head（头部），tall（尾部）设置为null，将新创建的node放在head，第二次循环将带有线程（首次进入等待队列的线程）的node的prev指向空node并且将空node的next指向带有线程的node，此时队列的head指向空的node，tall指向带有线程的node。非首次进入等待队列的线程，存放进node中并将node的prev指向队列的tall，队列tall的next指向node，完成后队列的tall指向了新进来的node。其他线程抢占失败后则尝试进入队列。
Java并发——ReentrantLock的公平锁与非公平锁
tongdanping的博客
03-16 1229
一、锁的公平性含义所谓公平锁，就是在绝对时间上，先对锁发起获取请求的一定先被满足，那么这个锁是公平的，反之，则是非公平的。因为ReentrantLock的实现是通过自定义的静态内部类sync实现的，sync继承了AbstractQueuedSynchronizor抽象类，因此ReentrantLock也是实现了基于双向链表的同步队列，也就是说，如果每次都是选择队列头的Node关联的线程获取锁，那就...
ReentrantLock的公平锁机制如何实现的？（源码理解）
adru的博客
02-04 660
接下来，方法获取头节点的下一个节点（s = h.next），并检查该节点是否为null或者该节点的线程不是当前线程（s.thread!是指多个线程按照申请锁的顺序来获取锁，即线程会直接进入队列中排队，队列中的第一个线程才能获得锁。这种机制确保了线程获取锁的公平性，避免了“饥饿”现象，即等待时间过长的线程无法获取到锁的情况。默认情况下，ReentrantLock是非公平的，这是因为非公平锁的效率通常要高于公平锁。在没有特殊需求的情况下，一般推荐使用非公平锁，因为它能提供更高的性能。，则表示成功获取锁。
ReentrantLock的非公平锁和公平锁的实现原理
jsj13263690918的博客
11-26 1281
非公平锁 因为之前已经分析过AQS，ReentranLock是利用一个实现了AQS的NonfairSync来获取非公平锁。所以只需关注NonfairSync的tryAcquire的实现。       获取锁（nonfairTryAcquire方法定义在Sync内部类中）   获取锁成功分为两种情况，第一个if判断AQS的state是否等于0，表示锁没有人占有。接着，hasQueu...
JAVA锁 —— ReentrantLock公平锁和非公平锁原理详解
JasonChen3318的博客
09-01 1711
一、简介： ReentrantLock的实现是基于其内部类FairSync(公平锁)和NonFairSync(非公平锁)实现的。 其可重入性是基于Thread.currentThread()实现的：如果当前线程已经获得了执行序列中的锁， 那执行序列之后的所有方法都可以获得这个锁。 1、公平锁 公平和非公平锁的队列都基于锁内部维护的一个双向链表，表结点Node的值就是每一个请求当前锁的线程...
Java进阶篇--公平锁 & 非公平锁
m0_74293254的博客
10-15 2966
Java进阶篇--公平锁 & 非公平锁
狂神说java-juc并发编程
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值