目录
为什么用ReentrantLock,而不用synchronized:
ReentrantLock简介:
- ReentrantLock是一个可重入的互斥锁,又被称为“独占锁”。
- ReentrantLock锁在同一个时间点只能被一个线程锁持有;可重入表示,ReentrantLock锁可以被同一个线程多次获取。
- ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下,线程依次排队获取锁;而“非公平锁”在锁是可获取状态时,不管自己是不是在队列的开头都会获取锁。
为什么用ReentrantLock,而不用synchronized:
有的时候需要多个方法公用一个锁,同时只有一个线程一个方法执行,所以用ReentrantLock,而不是用synchronized。
示例:
先看示例效果:
开锁的效果:
不开锁的效果:
ReentrantLock锁util:
package com.boot.common.util;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author lie
* @Description
*/
public class LockUtil {
private static ReentrantLock lock = new ReentrantLock();
public static ReentrantLock getLock() {
return lock;
}
}
线程一:
package com.gao.test.thread.demo;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author lie
* @Description
*/
public class ThreadTest1 extends Thread{
@Override
public void run() {
ReentrantLock lock = LockUtil.getLock();
lock.lock();
try {
for (int i = 0; i < 20; i++) {
try {
System.out.println("子线程①号:第 "+(i+1)+" 次");
sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
线程二:
package com.gao.test.thread.demo;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author lie
* @Description
*/
public class ThreadTest2 extends Thread{
@Override
public void run() {
ReentrantLock lock = LockUtil.getLock();
lock.lock();
try {
for (int i = 0; i < 20; i++) {
try {
System.out.println("子线程二号:第 "+(i+1)+" 次");
sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
main:
package com.gao.test.thread.demo;
import com.gao.test.thread.TestThread01;
/**
* @Author lie
* @Description
*/
public class Demo {
public static void main(String[] args) {
ThreadTest2 thread2 = new ThreadTest2();
thread2.start();
ThreadTest1 thread1 = new ThreadTest1();
thread1.start();
}
}