1.公平锁、非公平锁
Synchronized非公平锁,Lock可以自己设置公平or非公平。
默认非公平。
java Lock lock=new ReentrantLock(true);
(公平锁)一群人排队上厕所。
**优点:**所有人都能上厕所,等着就完了。
**缺点:**所有人都要站在厕所门口排队(所有线程唤醒CPU开销大)。
(非公平锁)一群人抢着上厕所,抢不到就等下次再抢。
**优点:**不用大家排队(没必要所有线程都唤醒CPU开销小)前一个线程执行完了随机给一个人发消息说可以来上厕所了notify,前一个线程执行完了给所有人发消息说可以来上厕所了,然后一群人抢notifyall。
**缺点:**总抢不到的人容易拉裤子里。
2.可重入锁,递归锁
拿到外面的锁,就可以拿到里面的锁,自动获得。
无论如何执行结果都是
AA AB BA BB
public class LockTest {
public static void main(String[] args){
new Thread(()->{
A();
},"A").start();
new Thread(()->{
A();
},"B").start();
}
public static synchronized void A(){
System.out.println(Thread.currentThread().getName()+"A");
B();
}
public static synchronized void B(){
System.out.println(Thread.currentThread().getName()+"B");
}
}
ReentrantLock版本,同理
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockTest2{
public static void main(String[] args){
new Thread(()->{
A();
},"A").start();
new Thread(()->{
A();
},"B").start();
}
static Lock lock=new ReentrantLock();
public static void A(){
lock.lock(); //拿到第一把锁 锁必须配对
System.out.println(Thread.currentThread().getName()+"A");
B();//拿到第二把锁
lock.unlock();
}
public static void B(){
lock.lock();
System.out.println(Thread.currentThread().getName()+"B");
lock.unlock();
}
}
3.自旋锁
不断循环自身,直到成功为止。例如,GetAndAddInt不断使用CAS进行比较。
核心:while
class Self {
AtomicReference<Thread> atomicReference=new AtomicReference<>();
public void myLock(){
Thread thread=Thread.currentThread();
System.out.println(thread.getName()+"自旋");
//自旋锁
while(!atomicReference.compareAndSet(null,thread)){
}
}
public void myUnLock(){
Thread thread=Thread.currentThread();
System.out.println(thread.getName()+"解锁");
atomicReference.compareAndSet(thread,null);
}
}
public class test{
public static void main(String[] args) {
Self self=new Self();
new Thread(()->{
self.myLock();
self.myUnLock();
},"T1").start();
new Thread(()->{
self.myLock();
self.myUnLock();
},"T2").start();
}
}
4.死锁
A持有A锁,等待获取B锁。
B持有B锁,等待获取A锁。
二者均不能释放锁,也不能强行剥夺锁。
1、互斥条件:一个资源每次只能被一个进程使用;
2、请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放;
3、不剥夺条件:进程已获得的资源,在末使用完之前,不能强行剥夺;
4、循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系;
import java.util.concurrent.TimeUnit;
class A implements Runnable{
private String lockA;
private String lockB;
public A(String lockA,String lockB){
this.lockA=lockA;
this.lockB=lockB;
}
@Override
public void run() {
synchronized (lockA){
System.out.println(Thread.currentThread().getName()+"lock:"+lockA+"-get:"+lockB);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB){
System.out.println(Thread.currentThread().getName()+"lock:"+lockB+"-get:"+lockA);
}
}
}
}
public class MyThread1{
public static void main(String[] args) {
String lockA="lockA";
String lockB="lockB";
new Thread((new A(lockA,lockB))).start();
new Thread((new A(lockB,lockA))).start();
}
}
解决方法:
查看日志,查看堆栈信息
使用JPS定位进程号:jps -l
使用JSTACK找到该进程查看堆栈信息:jstack 15936(Found 1 deadlock.)
排查代码,最后破坏死锁条件。