公平锁非公平锁
- 公平锁:是指多个线程按照申请锁的顺序来获取锁,类似排队打饭,先来后到。
- 非公平锁:是指多个线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程比现申请的线程优先获取锁,在高并发的情况下,有可能会造成优先级反转或者饥饿现象。
// 无参
public ReentrantLock() {
sync = new NonfairSync();
}
// 有参
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
区别
并发包中的 ReentrantLock 的创建可以指定构造函数 的 boolean类型来得到公平锁或者非公平锁,默认是非公平锁!
公平锁:就是很公平,在并发环境中,每个线程在获取到锁时会先查看此锁维护的等待队列,如果为空,或者当前线程是等待队列的第一个,就占有锁,否则就会加入到等待队列中,以后会按照FIFO的规则从队列中取到自己。
非公平锁:非公平锁比较粗鲁,上来就直接尝试占有锁,如果尝试失败,就会采用类似公平锁那种方式。
Java ReentrantLock 而言,通过构造函数指定该锁是否是公平锁,默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。对于Synchronized而言,也是一种非公平锁。
public class ReenTrantLock {
public static void main(String[] args) {
Tickets tickets = new Tickets();
new Thread(()->{
for (int i = 0; i <40; i++) {
tickets.sale();
}
},"AA").start();
new Thread(()->{
for (int i = 0; i <40; i++) {
tickets.sale();
}
},"BB").start();
new Thread(()->{
for (int i = 0; i <40; i++) {
tickets.sale();
}
},"CC").start();
}
}
class Tickets{
private int ticket=30;
ReentrantLock lock = new ReentrantLock(true);
//卖票
public void sale(){
lock.lock();
try {
if (ticket>0) {
System.out.println(Thread.currentThread().getName() + "卖出" + (ticket--) + ",剩余" + ticket);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
可重入锁
可重入锁(也叫递归锁)
指的是同一线程外层函数获得锁之后,内层递归函数仍然能获取该锁的代码,在同一个线程在外层方法获取锁的时候,在进入内层方法会自动获取锁。
也就是说,线程可以进入任何一个它已经拥有的锁,所同步着的代码块。 好比家里进入大门之后,就可以进入里面的房间了;
ReentrantLock、Synchronized 就是一个典型的可重入锁;
可重入锁最大的作用就是避免死锁
synchronized隐式------可重入锁
public class SyncLockDemo {
//synchronized隐式锁,上锁解锁自动完成
//synchronized同步方法验证synchronized是可重入锁
public synchronized void add(){
add();
}
public static void main(String[] args) {
new SyncLockDemo().add();//java.lang.StackOverflowError
//
Object o = new Object();
//synchronized同步代码块验证synchronized是可重入锁
new Thread(()->{
synchronized (o){
System.out.println(Thread.currentThread().getName()+"外层");
synchronized (o){
System.out.println(Thread.currentThread().getName()+"中层");
synchronized (o){
System.out.println(Thread.currentThread().getName()+"外层");
}
}
}
},"T1").start();
}
}
lock显示----可重入锁
public class SyncLockDemo {
public static void main(String[] args) {
Object o = new Object();
Lock lock = new ReentrantLock();
//演示lock显示锁
new Thread(()->{
try {
lock.lock();
System.out.println(Thread.currentThread().getName()+"外层");
try {
lock.lock();
System.out.println(Thread.currentThread().getName()+"中层");
try {
lock.lock();
System.out.println(Thread.currentThread().getName()+"内层");
} finally {
lock.unlock();
}
} finally {
lock.unlock();
}
} finally {
lock.unlock();
}
},"T1").start();
}
}
死锁
什么是死锁?
两个或两个以上线程在执行过程中,因为争夺资源而造成的一种互相等待的现象,如果没有外力干涉,就无法执行下去。
产生死锁的原因:
- 系统资源不足
- 进程运行推进顺序不合适
- 资源分配不当
快速写一个死锁
public class deadLockDemo {
static Object a = new Object();
static Object b = new Object();
public static void main(String[] args) {
new Thread(()->{
synchronized (a){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"持有锁a,试图获取锁b");
synchronized (b){
System.out.println(Thread.currentThread().getName()+"获取锁b");
}
}
},"A").start();
new Thread(()->{
synchronized (b){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"持有锁b,试图获取锁a");
synchronized (a){
System.out.println(Thread.currentThread().getName()+"获取锁a");
}
}
},"B").start();
}
}
验证是否死锁
(1)jps 类似于linux ps - ef
(2)jstack jvm自带堆栈跟踪工具
1、查看JDK目录的bin目录
2、使用 jps -l 命令定位进程号
3、使用 jstack 进程号 找到死锁查看