活锁出现在两个线程互相改变对方的结束条件，最后谁也无法结束，例如

    1. public class TestLiveLock {
    2.     static volatile int count = 10;
    3.     static final Object lock = new Object();
    5.     public static void main(String[] args) {
    6.         new Thread(()->{
    7.             //期望减到0退出循环
    8.             while (count>0){
    9.                 try {
    10.                     Thread.sleep(200);
    11.                 } catch (InterruptedException e) {
    12.                     e.printStackTrace();
    13.                 }
    14.                 count--;
    15.                 System.out.println("count:{}"+count);
    16.             }
    17.         },"t1").start();
    19.         new Thread(()->{
    20.             //期望超过20退出循环
    21.             while (count<20){
    22.                 try {
    23.                     Thread.sleep(200);
    24.                 } catch (InterruptedException e) {
    25.                     e.printStackTrace();
    26.                 }
    27.                 count++;
    28.                 System.out.println("count:{}"+count);
    29.             }
    30.         },"t2").start();
    31.     }
    32. }

    虽然没有死锁的真正加锁（即synchronized操作），但是两个线程确实无法结束，出现的效果如下：
    image.png