1.锁的本质

2.Lock接口使用ReentrenLock

3.读写锁使用

4.读写锁实现

Lock接口方法

有点意思的是lockInterruptibly(), 只要没有获取到锁就会一直等待,直到某一地方对当前线程执行interrupt()方法后,

lockInterruptibly()处会抛出异常,可以在catch中对此异常情况进行处理

synchronized+wait+notify  对比  reentrantLock+condition+await+signal:

两种方式思想差不多,wait和await都会释放锁,最明显的不同是condition有多个等待队列,wait/notify只有一个等待队列

/*
1、自己实现一个阻塞队列,只能存储 n个元素
put时,若队列未满,直接put,
若队列满,就阻塞,直到再有空间
get时,若队列中有元素,则获取到元素
若无元素,则等待元素
*/
class JamesQueue{
List<Object> list = new ArrayList<>(); Lock lock = new ReentrantLock();
Condition putCondition = lock.newCondition();
Condition takeCondition = lock.newCondition(); private int length; public JamesQueue(int length){
this.length = length;
} public void put(Object obj){
lock.lock();
try {
if (list.size() < length){
list.add(obj);
System.out.println("put:" + obj);
takeCondition.signal();
}else{
putCondition.await();
}
}catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
} public Object take(){
lock.lock();
Object obj = null;
try {
for (;;) {
if (list.size() > 0) {
obj = list.get(0);
list.remove(0);
System.out.println("take:" + obj); putCondition.signal();
break;
} else {
takeCondition.await();
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
return obj;
}
} public class Demo4_Condition3 {
public static void main(String args[]) throws InterruptedException {
JamesQueue bb = new JamesQueue(5); new Thread() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
bb.put("x" + i);
}
}
}.start(); Thread.sleep(3000L);
System.out.println("开始从队列中取元素...");
for (int i = 0; i < 10; i++) {
bb.take();
Thread.sleep(3000L);
}
}
}

ReentrantLock可重入锁

ReentrantLock基本原理

线程通过ReentrantLock.lock()加锁时:

判断count是否是0,若是则代表锁未被占用,开始抢锁,若抢到锁则CAS修改count值,并将owner设置为自身线程的引用;若否,则判断当前锁的占用者owner是不是自己,若是自己则count+1,若不是则进入等待队列waiters

手写ReentrantLock

package com.study.lock.locks1;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport; public class JamesReentrantLock implements Lock { // 锁的拥有者
AtomicReference<Thread> owner = new AtomicReference<>(); // 等待队列
private LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>(); // 标记重入次数的count值
AtomicInteger count = new AtomicInteger(0); @Override
public boolean tryLock() {// 浅尝辄止
// 判断count是否为0,若count!=0,说明锁被占用
int ct = count.get();
if (ct != 0) {
// 判断锁是否被当前线程占用,若被当前线程占用,做重入操作,count+=1
if (owner.get() == Thread.currentThread()) {
count.set(ct + 1);
return true;
} else {
// 若不是当前线程占用,互斥,抢锁失败,return false
return false;
}
} else {
// 若count=0, 说明锁未被占用,通过CAS(0,1) 来抢锁
if (count.compareAndSet(ct, ct + 1)) {
// 若抢锁成功,设置owner为当前线程的引用
owner.set(Thread.currentThread());
return true;
} else {
// CAS操作失败,说明情锁失败 返回false
return false;
}
}
} @Override
public void lock() {// 不死不休
// 尝试抢锁
if (!tryLock()) {
// 如果失败,进入等待队列
waiters.offer(Thread.currentThread()); // 自旋
for (;;) {
// 判断是否是队列头部,如果是
Thread head = waiters.peek();
if (head == Thread.currentThread()) {
// 再次尝试抢锁
if (!tryLock()) {
// 若抢锁失败,挂起线程,继续等待
LockSupport.park();
} else {
// 若成功,就出队列
waiters.poll();
return;
}
} else {
// 如果不是,就挂起线程
LockSupport.park();
}
}
}
} @Override
public void unlock() {
if (tryUnlock()) {
Thread th = waiters.peek();
if (th != null) {
LockSupport.unpark(th);
}
}
} public boolean tryUnlock() {
// 判断,是否是当前线程占有锁,若不是,抛异常
if (owner.get() != Thread.currentThread()) {
throw new IllegalMonitorStateException();
} else {
// 如果是,就将count-1 若count变为0 ,则解锁成功
int ct = count.get();
int nextc = ct - 1;
count.set(nextc); // 判断count值是否为0
if (nextc == 0) {
owner.compareAndSet(Thread.currentThread(), null);
return true;
} else {
return false;
}
}
} @Override
public void lockInterruptibly() throws InterruptedException { } @Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
int ct = count.get();
if (ct == 0) {
// 未被占用,CAS修改count
long end = System.currentTimeMillis() + unit.toMillis(time);
for (;;) {
long now = System.currentTimeMillis();
if (now > end) {
return false;
} else {
if (count.compareAndSet(0, 1)) {
owner.set(Thread.currentThread());
return true;
}
}
}
} else {
long end = System.currentTimeMillis() + unit.toMillis(time);
for (;;) {
long now = System.currentTimeMillis();
if (now > end) {
return false;
} else {
if (count.compareAndSet(0, 1)) {
owner.set(Thread.currentThread());
return true;
}
}
}
}
} @Override
public Condition newCondition() {
return null;
}
}

Lock与Synchronized对比

1.3.1 Lock接口及其实现的更多相关文章

  1. synchronized关键字,Lock接口以及可重入锁ReentrantLock

    多线程环境下,必须考虑线程同步的问题,这是因为多个线程同时访问变量或者资源时会有线程争用,比如A线程读取了一个变量,B线程也读取了这个变量,然后他们同时对这个变量做了修改,写回到内存中,由于是同时做修 ...

  2. 线程同步 Lock接口

    同步:★★★★★ 好处:解决了线程安全问题. 弊端:相对降低性能,因为判断锁需要消耗资源,产生了死锁. 定义同步是有前提的: 1,必须要有两个或者两个以上的线程,才需要同步. 2,多个线程必须保证使用 ...

  3. Java基础知识强化之多线程笔记06:Lock接口 (区别于Synchronized块)

    1. 简介 我们讲到了如何使用关键字synchronized来实现同步访问.本文我们继续来探讨这个问题,从Java 5之后,在java.util.concurrent.locks包下提供了另外一种方式 ...

  4. Java多线程(五) Lock接口,ReentranctLock,ReentrantReadWriteLock

    在JDK5里面,提供了一个Lock接口.该接口通过底层框架的形式为设计更面向对象.可更加细粒度控制线程代码.更灵活控制线程通信提供了基础.实现Lock接口且使用得比较多的是可重入锁(Reentrant ...

  5. jdk1.5多线程Lock接口及Condition接口

    jdk1.5多线程的实现的方式: jdk1.5之前对锁的操作是隐式的 synchronized(对象) //获取锁 { } //释放锁 jdk1.5锁的操作是显示的:在包java.util.concu ...

  6. Java多线程的~~~Lock接口和ReentrantLock使用

    在多线程开发.除了synchronized这个keyword外,我们还通过Lock接口来实现这样的效果.由Lock接口来实现 这样的多线程加锁效果的优点是非常的灵活,我们不在须要对整个函数加锁,并且能 ...

  7. Java 中的锁——Lock接口

    Java SE5之后,并发包中新增了Lock接口(以及相关实现类)用来实现锁功能.虽然它少了(通过synchronized块或者方法所提供的)隐式获取释放锁的便捷性,但是却拥有了锁获取与释放的操作性. ...

  8. 5.Lock接口及其实现ReentrantLock

    jdk1.7.0_79 在java.util.concurrent.locks这个包中定义了和synchronized不一样的锁,重入锁——ReentrantLock,读写锁——ReadWriteLo ...

  9. 多线程里面的关键字,wait, notfiy, 锁(synchronized), lock接口

    多线程环境下,必须考虑线程同步的问题,这是因为多个线程同时访问变量或者资源时会有线程争用,比如A线程读取了一个变量,B线程也读取了这个变量,然后他们同时对这个变量做了修改,写回到内存中,由于是同时做修 ...

  10. java多线程Lock接口简介使用与synchronized对比 多线程下篇(三)

    前面的介绍中,对于显式锁的概念进行了简单介绍 显式锁的概念,是基于JDK层面的实现,是接口,通过这个接口可以实现同步访问 而不同于synchronized关键字,他是Java的内置特性,是基于JVM的 ...

随机推荐

  1. 洛谷P1860 新魔法药水

    洛谷题目链接 动态规划: 这个题目调了我好久....结果循环变量写错了... 而且题目有个坑!!!只能用开始给你的$v$元买入东西 回归正题: 我们定义状态$ans[i][j]$表示第$i$个物品用了 ...

  2. [Luogu] 八数码难题

    https://www.luogu.org/problemnew/show/P1379 long long ago 暴力bfs #include <iostream> #include & ...

  3. [洛谷201704R1]开心派对小火车

    OJ题号:洛谷P3697 思路: 贪心.首先从起点出发,开特急电车,对于每一个特急车站$s_{i}$,分别下一次车,计算从当前车站$s_{i}$出发坐各停电车在指定时限内$t$最远能够到达的车站$r_ ...

  4. DRF-解析器组件源码解析

    解析器组件源码解析 解析器组件源码解析 1 执行request.data 开始找重装的request中的data方法 2 在dispatch找到重装的request def dispatch(self ...

  5. python实现随机生成头像

    今天遇到如何给用户分配随机头像的问题,想着要在本地放很多图片,有点无聊,就找了一些生成头像的工具.发现gravatar生成图像还不错,挺好玩的. 1.下面上代码 # -*- coding: utf-8 ...

  6. Objective-C中的self与LLVM Clang新引入的instancetype

    我们知道,大部分面向对象语言对于一个类的成员方法都有一个隐含的参数.在C++.Java.C#和JavaScript中是this,而在Objective-C中则是self.当然,由于Objective- ...

  7. smarty 模板几个例子(变量调节器)

    一.assign和display方法的使用以及几个变量调节器 header("content-type:text/html;charset=utf-8");//加载Smarty引擎 ...

  8. scikit-learn机器学习(三)多项式回归(二阶,三阶,九阶)

    我们仍然使用披萨直径的价格的数据 import matplotlib matplotlib.rcParams['font.sans-serif']=[u'simHei'] matplotlib.rcP ...

  9. NuGet修改packages目录/迁移缓存文件夹

    如图,以下是NuGet默认配置 打开C:\Program Files (x86)\NuGet\Config目录的Microsoft.VisualStudio.Offline.config可以看见如下配 ...

  10. nginx重新编译不停服

    找到安装nginx的源码根目录,如果没有就下载新的安装包 .tar.gz 查看ngixn版本极其编译参数 /usr/local/nginx/sbin/nginx -V 进入nginx源码目录 cd n ...