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. [Luogu] 让我们异或吧

    https://www.luogu.org/problemnew/show/P2420 异或满足 A ^ B = B ^ A A ^ A = 0 0 ^ A = A #include <cstd ...

  2. Codeforces 1243 D 0-1 MST

    题面 隐隐感觉N年前做过一道类似的题. 很显然我们只需要考虑,仅有0边的子图有多少个连通块,然后这个数量减去1就是答案了(这个和kruscal过程等价). 然后其实就是妥妥的暴力了...因为1边数量非 ...

  3. CSP-S模拟测试 88 题解

    T1 queue: 考场写出dp柿子后觉得很斜率优化,然后因为理解错了题觉得斜率优化完全不可做,只打了暴力. 实际上他是可以乱序的,所以直接sort,正确性比较显然,贪心可证,然后就是个sb斜率优化d ...

  4. mysql40题

    一.表关系 请创建如下表,并创建相关约束 导入现有数据库数据: /* Navicat Premium Data Transfer Source Server : localhost Source Se ...

  5. Devexpress GridControl中 repositoryItemCheckEdit作为选择列以及作为显示列的使用方法

    一.在gridcontrol列表控件中使用单选框作为选择列,这里有两种方式. 方式一:选择gridcontrol控件的Run Designer按钮,添加一列,设置该列的ColumnEdit为check ...

  6. 文件对比工具 Beyond Compare 4.2.9中文破解版for mac

    链接:https://pan.baidu.com/s/1AsESVIYsn9Lv6qz2TfROrQ 密码:6o63链接:https://pan.baidu.com/s/1eiGgRHfPTEERlH ...

  7. overflow妙用--去除默认滚动条,内容仍可滚动

    在开发中我们往往要去除默认滚动条,但是其在竖直方向的滚动效果仍然需要. <div id="parent"> <div id="child"&g ...

  8. Yarn 安装 node-sass 依赖导致 Build Fresh Packages 太慢的问题

    解决办法: 1. 在 项目目录下新建 .yarnrc 文件 添加以下代码 registry "https://registry.npm.taobao.org" sass_binar ...

  9. Maven的安装和配置(Windows 10)

    1. 官网下载Maven管理工具 官网:https://maven.apache.org/download.cgi 系统要求: JDK:Maven 3.3以上需要JDK 1.7以上版本支持 Memor ...

  10. varnish web cache服务

    varnish介绍 缓存开源解决方案: - varnish - 充分利用epoll机制(能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率),并发量大,单连接资源较轻 - squid ...