大家推荐个靠谱的公众号程序员探索之路,公众号内点击网赚获取彩蛋,大家一起加油,这个公众号已经接入图灵
1.基本使用:
static int i = 1;
public static void main(String[] args) {
ReentrantLock reentrantLock = new ReentrantLock();
for (int m = 0; m < 10;m++){
new Thread(new Runnable() {
@Override
public void run() {
try {
reentrantLock.lock();
System.out.println(Thread.currentThread().getName()+" i = "+i);
i = i + 1;
} catch (Exception e) {
e.printStackTrace();
} finally {
reentrantLock.unlock();
}
}
}).start();
}
}
结果:
Thread-0 i = 1
Thread-1 i = 2
Thread-2 i = 3
Thread-3 i = 4
Thread-4 i = 5
Thread-5 i = 6
Thread-8 i = 7
Thread-6 i = 8
Thread-7 i = 9
Thread-9 i = 10
注意:ReentrantLock持有的锁是需要手动去unlock()的,所以一般是在finally中进行unlock
2.Condition 作用:condition.await()/condition.signal()/condition.signalAll()和await/notify/notifyAll作用类似
Condition更灵活 一个ReentrantLock 实例可以new出来很多个Condition 一个Condition实例只能唤醒它await的线程
public static void main(String[] args) {
ReentrantLock reentrantLock = new ReentrantLock();
Condition condition = reentrantLock.newCondition();
for (int m = 0; m < 10;m++){
new Thread(new Runnable() {
@Override
public void run() {
try {
reentrantLock.lock();
System.out.println(Thread.currentThread().getName()+"等待中...");
condition.await();
System.out.println(Thread.currentThread().getName()+"等待结束");
} catch (Exception e) {
e.printStackTrace();
} finally {
reentrantLock.unlock();
}
}
}).start();
}
//睡一会 让上面所有的线程都进入等待状态
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
reentrantLock.lock();
condition.signal();
reentrantLock.unlock();
}
condition.signal();是唤醒该condition queue中的第一个线程
public final void signal() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignal(first);
}
/** First node of condition queue. */
private transient Node firstWaiter;
3.公平锁/非公平锁 :非公平锁不是按照线程排队顺序来获取锁的,也就是随机获取,有可能导致有的线程一致获取不到锁
ReentrantLock 的构造函数可以来指定公平/非公平锁 默认是非公平
ReentrantLock reentrantLock = new ReentrantLock(); //非公平
ReentrantLock reentrantLock = new ReentrantLock(false); //非公平
ReentrantLock reentrantLock = new ReentrantLock(true); //公平
//非公平示例
public static void main(String[] args) {
ReentrantLock reentrantLock = new ReentrantLock();
for (int m = 0; m < 10;m++){
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName()+"start run....");
reentrantLock.lock();
System.out.println(Thread.currentThread().getName()+"获取了锁");
} catch (Exception e) {
e.printStackTrace();
} finally {
reentrantLock.unlock();
}
}
}).start();
}
}
Thread-2start run....
Thread-1start run....
Thread-0start run....
Thread-5start run....
Thread-3start run....
Thread-8start run....
Thread-4start run....
Thread-9start run....
Thread-7start run....
Thread-6start run....
Thread-2获取了锁
Thread-0获取了锁
Thread-1获取了锁
Thread-5获取了锁
Thread-3获取了锁
Thread-8获取了锁
Thread-4获取了锁
Thread-9获取了锁
Thread-7获取了锁
Thread-6获取了锁
//公平示例
.......
ReentrantLock reentrantLock = new ReentrantLock(true);
.......
Thread-1start run....
Thread-1获取了锁
Thread-7start run....
Thread-0start run....
Thread-2start run....
Thread-6start run....
Thread-3start run....
Thread-7获取了锁
Thread-4start run....
Thread-5start run....
Thread-8start run....
Thread-9start run....
Thread-0获取了锁
Thread-2获取了锁
Thread-6获取了锁
Thread-3获取了锁
Thread-4获取了锁
Thread-5获取了锁
Thread-8获取了锁
Thread-9获取了锁
4.getHoldCount() 获取 当前线程调用lock的次数 也证明了ReentrantLock 是可重入锁
static final ReentrantLock reentrantLock = new ReentrantLock(true);
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
try {
reentrantLock.lock();
System.out.println("reentrantLock的调用次数:"+reentrantLock.getHoldCount());
sout();
} catch (Exception e) {
e.printStackTrace();
} finally {
reentrantLock.unlock();
}
}
}).start();
}
public static void sout(){
try {
reentrantLock.lock();
System.out.println("我是sout方法,reentrantLock的调用次数"+reentrantLock.getHoldCount());
} finally {
reentrantLock.unlock();
}
}
reentrantLock的调用次数:1
我是sout方法,reentrantLock的调用次数2
5.isFair() 获取是否是公平锁
6.getQueueLength() 获取等待锁的线程数---注意这个数可能不准确 线程在获取后有可能获取到锁了
示例:
static final ReentrantLock reentrantLock = new ReentrantLock(true);
public static void main(String[] args) {
for (int m = 0; m < 10;m++){
new Thread(new Runnable() {
@Override
public void run() {
try {
reentrantLock.lock();
} catch (Exception e) {
e.printStackTrace();
} finally {
//注意我这里故意没有释放锁 正常写代码时不要这样
// reentrantLock.unlock();
}
}
}).start();
}
//让上面所有的线程有足够的时间启动
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("等待:"+reentrantLock.getQueueLength());
}
结果:等待:9
7.hasQueuedThreads() 是否有线程正在等待锁
8.hasQueuedThread(Thread实例) 判断Thread是否在等待
示例:
static final ReentrantLock reentrantLock = new ReentrantLock(true);
public static void main(String[] args) {
Thread[] ts = new Thread[10];
for (int m = 0; m < 10;m++){
ts[m] = new Thread(new Runnable() {
@Override
public void run() {
try {
reentrantLock.lock();
} catch (Exception e) {
e.printStackTrace();
} finally {
//注意我这里故意没有释放锁 正常写代码时不要这样
// reentrantLock.unlock();
}
}
});
ts[m].start();
}
//让上面所有的线程有足够的时间启动
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ts[0].getName()+"是否在等待"+reentrantLock.hasQueuedThread(ts[0]));
System.out.println(ts[1].getName()+"是否在等待"+reentrantLock.hasQueuedThread(ts[1]));
}
结果:
Thread-0是否在等待true
Thread-1是否在等待false
9.isHeldByCurrentThread()/isLocked() 当前线程是否持有锁/是否有任意线程持有锁
示例:
static final ReentrantLock reentrantLock = new ReentrantLock(true);
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
try {
reentrantLock.lock();
System.out.println(Thread.currentThread().getName() + "持有锁");
System.out.println(Thread.currentThread().getName() + "是否持有锁" + reentrantLock.isHeldByCurrentThread());
System.out.println("是否有任意线程持有锁" + reentrantLock.isLocked());
} catch (Exception e) {
e.printStackTrace();
} finally {
//注意我这里故意没有释放锁 正常写代码时不要这样
// reentrantLock.unlock();
}
}
}).start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//开启另外一个线程查询
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "是否持有锁" + reentrantLock.isHeldByCurrentThread());
System.out.println("是否有任意线程持有锁" + reentrantLock.isLocked());
}
}).start();
}
结果:
Thread-0持有锁
Thread-0是否持有锁true
是否有任意线程持有锁true
Disconnected from the target VM, address: '127.0.0.1:55741', transport: 'socket'
Thread-1是否持有锁false
是否有任意线程持有锁true
10.尝试(指定时间内)获取锁:tryLock/tryLock(*, TimeUnit.*)
static int i = 1;
public static void main(String[] args) {
ReentrantLock reentrantLock = new ReentrantLock();
for (int m = 0; m < 10;m++){
new Thread(new Runnable() {
@Override
public void run() {
try {
if (reentrantLock.tryLock(2, TimeUnit.SECONDS)){
System.out.println(Thread.currentThread().getName()+" i = "+i);
i = i + 1;
}else {
System.out.println(Thread.currentThread().getName()+"获取锁失败");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//注意我这里没有释放锁
// reentrantLock.unlock();
}
}
}).start();
}
}
Thread-1 i = 1
Thread-8获取锁失败
Thread-4获取锁失败
Thread-3获取锁失败
Thread-2获取锁失败
Thread-0获取锁失败
Thread-5获取锁失败
Thread-9获取锁失败
Thread-6获取锁失败
Thread-7获取锁失败
11.getWaitQueueLength(Condition condition)
类似getQueueLength(),不过此方法的前提是condition。比如5个线程,每个线程都执行了同一个condition的await()方法,那么方法调用的返回值是5,
因为5个线程都在等待获得锁
12.hasWaiters(Condition condition)
查询是否有线程正在等待与此锁有关的condition条件。比如5个线程,每个线程都执行了同一个condition的await()方法,那么方法调用的返回值是true,
因为它们都在等待condition
13.lockInterruptibly()
如果当前线程未被中断,则获取锁
14.getWaitingThreads(Condition condition)
返回一个collection,它包含可能正在等待与此锁相关给定条件的那些线程,因为构造结果的时候实际线程可能动态变化,因此返回的collection只是尽力的估计值
15.synchronized和ReentrantLock的对比
1、synchronized是关键字,是语法层面的实现,因此synchronized获取锁以及释放锁都是jvm帮助完成的;
ReentrantLock是类层面的实现,因此锁的获取以及锁的释放都需要自己去操作。特别再次提醒,ReentrantLock在lock()完了,一定要手动unlock()
2、synchronized简单,同时意味着不灵活,而ReentrantLock的锁机制给用户的使用提供了极大的灵活性。
这点在1.7版本的Hashtable和ConcurrentHashMap中体现得淋漓尽致。synchronized一锁就锁整个Hash表,而ConcurrentHashMap则利用ReentrantLock实现了锁分离,
锁的只是segment而不是整个Hash表
3、synchronized是不公平锁,而ReentrantLock可以指定锁是公平的还是非公平的
4、synchronized实现等待/通知机制通知的线程是随机的,ReentrantLock实现等待/通知机制可以有选择性地通知
5、和synchronized相比,ReentrantLock提供了多种方法用于锁信息的获取,比如可以知道lock是否被当前线程获取、lock被同一个线程调用了几次、
lock是否被任意线程获取等等
总结起来,我认为如果只需要锁定简单的方法、简单的代码块,那么考虑使用synchronized,复杂的多线程处理场景下可以考虑使用ReentrantLock。
最重要的时具体场景具体分析