一、公平锁与非公平锁
-
公平锁:不允许插队,线程排队执行。
-
非公平锁:允许插队。比如先来的线程a要1小时执行完,后来的线程b只要1秒钟。这是可以让b先执行。默认都是非公平锁(synchronized,lock)
lock可以指定为公平锁。
二、可重入锁
-
所有的锁都是可重入的
看下面代码理解可重入的意思
synchronized版本
public class Demo1 { public static void main(String[] args) { MyClass1 myClass1 = new MyClass1(); new Thread(()->{ myClass1.fun1(); },"a").start(); new Thread(()->{ myClass1.fun1(); },"b").start(); } } class MyClass1{ public synchronized void fun1(){ System.out.println(Thread.currentThread().getName()+":fun1"); fun2(); //调用fun2 fun2中也加了锁,因为是同一把锁,所以不需要重新获取 } public synchronized void fun2(){ System.out.println(Thread.currentThread().getName()+":fun2"); } }
lock版本
public class Demo2 { public static void main(String[] args) { MyClass2 myClass2 = new MyClass2(); new Thread(()->{ myClass2.fun1(); },"a").start(); new Thread(()->{ myClass2.fun1(); },"b").start(); } } class MyClass2{ final Lock lock = new ReentrantLock(); public void fun1(){ lock.lock(); //lock()和unlock()一定要配对使用 如果写了lock()没写unlock()则会一直卡住 lock.lock(); try { System.out.println(Thread.currentThread().getName() + ":fun1"); fun2(); //调用fun2。fun2中也加了锁,这是不同的锁 } finally { lock.unlock(); lock.unlock(); } } public void fun2(){ lock.lock(); //这里的锁和fun1中不是同一把锁 try { System.out.println(Thread.currentThread().getName() + ":fun2"); } finally { lock.unlock(); //如果和fun1中是同一把锁 这里释放了 fun1的锁也释放了 } } }
这里要注意一点,虽然和synchronized实现了一样的效果,但是在两个方法中是加了两把不同的锁。
三、自旋锁
-
自定义自旋锁
/** * 自定义自旋锁 */ public class SpinLockDemo { //这里的引用值为null AtomicReference<Thread> atomicReference = new AtomicReference<>(); //加锁 public void myLock(){ Thread thread = Thread.currentThread(); System.out.println(thread.getName()+"-> 加锁"); //自旋 //第一个线程进来后会马上修改掉原来的引用值null,并设置为thread //第二个线程只能一直循环,也就是所谓的自旋,直到第一个线程解锁,即设置引用值为null //这个比较和设置两个操作是原子的不能打断 while(!atomicReference.compareAndSet(null,thread)){ } } //解锁 public void unMyLock(){ Thread thread = Thread.currentThread(); System.out.println(thread.getName() + "-> 解锁"); atomicReference.compareAndSet(thread,null); } }
-
测试类
public class SpinLockTest { public static void main(String[] args) { SpinLockDemo spinLockDemo = new SpinLockDemo(); new Thread(()->{ spinLockDemo.myLock(); try{ TimeUnit.SECONDS.sleep(3); }catch (InterruptedException e) { e.printStackTrace(); }finally { spinLockDemo.unMyLock(); } },"A").start(); try { //主线程暂停1秒 让线程A先执行 TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(()->{ spinLockDemo.myLock(); spinLockDemo.unMyLock(); },"B").start(); } }
打印结果 一定是A先解锁 B再解锁。线程A在自旋的过程中加了锁,线程B只能等待。线程A自旋完成,并释放锁,线程B才能拿到锁,开始自旋,自旋完成,释放锁。或者说自旋的过程是原子性的,不能打断。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9DQpS2gj-1657320204883)(G:\学习\JUC-Java并发编程\JUC学习笔记\image-20200428073022362.png)]
四、死锁
-
死锁产生的原因
多个线程按照不同的顺序对多个资源进行加锁,在释放资源前尝试获取其他资源,就会产生死锁。
-
例子
public class DeadLockTest { public static void main(String[] args) { final String source1 = "source1"; final String source2 = "source2"; //两个线程按不同的顺序获取资源 new Thread(new MyThread(source1,source2),"T1").start(); new Thread(new MyThread(source2,source1),"T2").start(); } } class MyThread implements Runnable{ //资源1 private String source1; //资源2 private String source2; public MyThread(String source1, String source2) { this.source1 = source1; this.source2 = source2; } @Override public void run() { synchronized (source1){ System.out.println("线程 "+Thread.currentThread().getName() + "获取到资源 " + source1); System.out.println("线程 "+Thread.currentThread().getName() + "尝试获取资源 " + source2); synchronized(source2){ System.out.println("线程 "+Thread.currentThread().getName() + "获取到资源 " + source2); } } } }
上面两个线程会产生死锁
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lwc4s8jk-1657320204885)(G:\学习\JUC-Java并发编程\JUC学习笔记\image-20200428080424306.png)]
在idea中查看线程死锁的原因
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pCow4a5S-1657320204886)(G:\学习\JUC-Java并发编程\JUC学习笔记\image-20200428080750760.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GWijAWfT-1657320204887)(G:\学习\JUC-Java并发编程\JUC学习笔记\image-20200428080831405.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wpnIOFUt-1657320204888)(G:\学习\JUC-Java并发编程\JUC学习笔记\image-20200428080916865.png)]