ReentrantLock基本使用
package com.study.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo1_GetLock {
//公平锁
//static Lock lock = new ReentrantLock(true);
//非公平锁
static Lock lock = new ReentrantLock();
public static void main(String args[]) throws InterruptedException {
//主线程 拿到锁
lock.lock();
Thread th = new Thread(new Runnable() {
@Override
public void run() {
/* System.out.println("begain to get lock...");
lock.lock();
System.out.println("interrupted...");*/
//子线程 获取锁(浅尝辄止)
/* boolean result = lock.tryLock();
System.out.println("是否获得到锁:" +result);*/
//子线程 获取锁(点到为止)
/* try {
boolean result1 = lock.tryLock(5, TimeUnit.SECONDS);
System.out.println("是否获得到锁:" +result1);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
//子线程 获取锁(任人摆布)
/* try {
System.out.println("start to get lock Interruptibly");
lock.lockInterruptibly();
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("dad asked me to stop...");
}*/
//子线程 获取锁(不死不休)
System.out.println("begain to get lock...");
lock.lock();
System.out.println("succeed to get lock...");
}
});
th.start();
Thread.sleep(10000L);
lock.unlock();
}
}
使用Condition进行线程通信,如同wait、notify一般也只能在加锁的代码中使用
package com.study.lock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo3_Condition {
private static Lock lock = new ReentrantLock();
private static Condition condition = lock.newCondition();
public static void main(String[] args) throws InterruptedException {
Thread th = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
System.out.println("condition.await()");
try {
condition.await();
System.out.println("here i am...");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
});
th.start();
Thread.sleep(2000L);
lock.lock();
condition.signalAll();
lock.unlock();
}
}
Condition死锁情况,和wait、notify一样对代码执行的先后顺序有要求,不能在我还没有锁时就已经signal释放了锁,然后再去加锁,这个时候没有人回去释放锁了
package com.study.lock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo3_Condition_deadLock {
private static Lock lock = new ReentrantLock();
private static Condition condition = lock.newCondition();
public static void main(String[] args) throws InterruptedException {
Thread th = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.lock();
try {
System.out.println("获得锁,调用condition.await()\n");
condition.await(); // waiting park
System.out.println("唤醒了...\n");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
});
th.start();
// Thread.sleep(2000L);
lock.lock();
condition.signal();
lock.unlock();
}
}
ReentrantLock手写阻塞队列
package com.study.lock;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
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);
}
}
}
/*
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;
}
}
ReentrantLock原理
他底层维护了一个 owner=当前线程 , count 是 当前重入次数,每次加锁成功加1,释放减1
他是如何加锁的呢,先去判断count 是否为0 ,为0表示当前没有线程占用,如何去用CAS机制去操作修改成1 , 修改成功,在去修改owner为自己,注意这个owner不是CAS修改只是一个普通set,因为,在没有线程修改成功count,是没有线程会来修改,owner的。
抢锁,他会去判断count是否为0,如果不为0,他会去判断owner是否是自己,是自己,count值加1(这次修改不需要CAS)代表重入成功,不是自己进入waiters等待队列,然后挂起block状态
解锁,假如当前的owner是其他线程,不是自己会报错,如果owner是自己,count就去减1,直到减到为0,减到为0就会把owner修改为null再去唤醒,等待队列中的头部线程
手写ReenteantLock
package com.study.lock;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
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 JamesLock implements Lock {
//锁的拥有者
AtomicReference<Thread> owner = new AtomicReference<>();
//等待队列
private LinkedBlockingQueue<Thread> waiter = new LinkedBlockingQueue<>();
@Override
public boolean tryLock() {
return owner.compareAndSet(null, Thread.currentThread());
}
@Override
public void lock() {
if (!tryLock()){
waiter.offer(Thread.currentThread());
for(;;){
Thread head = waiter.peek();
if (head == Thread.currentThread()){
if(!tryLock()){
//挂起线程
LockSupport.park();
}else{
//抢锁成功,将线程出度列
waiter.poll();
return;
}
}else{
//线程挂起
LockSupport.park();
}
}
}
}
@Override
public void unlock() {
if (tryUnlock()){
Thread th = waiter.peek();
if (th !=null){
LockSupport.unpark(th);
}
}
}
public boolean tryUnlock(){
//首先判断当前线程是否站有锁
if (owner.get() !=Thread.currentThread()){
throw new IllegalMonitorStateException();
}else{
return owner.compareAndSet(Thread.currentThread(), null);
}
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public Condition newCondition() {
return null;
}
}