版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/ldb987/article/details/86663392
为什么使用lock
a. 灵活性
i. lock需要显示的获取和释放锁，繁琐但灵活
ii. synchronized不需要显示地获取和释放锁，简单
b. 公平性
i. 使用lock可以方便的实现公平性
c. 非阻塞的获取锁，trylock(),如果没有获取，返回false，如果获取，返回true
d. 能被中断的获取锁，也就是获取锁时可以被中断
e. 超时获取锁。超过了设定的时间，如果没有获取，返回false，如果获取，返回true
f. 可以实现公平锁锁应用
lock应用
package com.roocon.thread.t9;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Sequence {
private int value;
***//创建一把锁，所有线程公用一把锁
Lock lock = new ReentrantLock();***
Lock l1 = new ReentrantLock();
/**
* @return
*/
public int getNext() {
***//锁定，类似于同步代码块
lock.lock();
//公共资源存在线程安全性问题
int a = value ++;
//释放锁
lock.unlock();***
return a;
}
public static void main(String[] args) {
Sequence s = new Sequence();
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName() + " " + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName() + " " + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
System.out.println(Thread.currentThread().getName() + " " + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}
用lock实现重入锁
a.重入锁：
简单理解就是：有a，b两个方法，都加了锁，并a调用b；main方法调用a，可以在获取a方法的锁后，再进入b，获取b的锁。这就是锁重入
b.实现
b.1重写lock和unlock
package com.roocon.thread.ta1;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
public class MyLock implements Lock {
private boolean isLocked = false;
private Thread lockBy = null;
private int lockCount = 0;
@Override
public synchronized void lock() {
// ...
Thread currentThread = Thread.currentThread(); // Thread-0
while (isLocked && currentThread != lockBy)
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
isLocked = true;
lockBy = currentThread;
lockCount ++; // 1 2
}
@Override
public synchronized void unlock() {
if(lockBy == Thread.currentThread()) {
lockCount --; // 1 0
if(lockCount == 0) {
notify();
isLocked = false;
}
}
}
}
b.2线程实现
package com.roocon.thread.ta1;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo {
Lock lock = new ReentrantLock();
public void a() {
lock.lock();
System.out.println("a");
b();
lock.unlock();
}
public void b() {
lock.lock();
System.out.println("b");
c();
lock.unlock();
}
public static void main(String[] args) {
Demo d = new Demo();
new Thread(new Runnable() {
@Override
public void run() {
d.a();
}
}).start();
}
打印的结果是：a,b 而不会是只有a