多线程回顾

开启多线程

  1. 继承Thread类，重写run方法，然后通过类的start()方法开启一个新的线程 ```java public class Demo1 { public static void main(String[] args) {
    1.  new MyThread().start();
    2.  while (true) {
    3.      System.out.println("main()方法正在运行");
    4.      try {
    5.          Thread.sleep(2);
    6.      } catch (InterruptedException e) {
    7.          e.printStackTrace();
    8.      }
    9.  }
    10.  /**
    11.   * 两个打印语句交替打印
    12.   */
    } }

class MyThread extends Thread { @Override public void run() { while (true) { System.out.println(“MyThread类的run()方法运行”); try { Thread.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } } } }

  2. 2. 实现runnable接口，通过该类的实例对象构建线程类，在通过线程对象的start()方法开启多线程
  3. ```java
  4. public class Demo1 {
  5.     public static void main(String[] args) {
  6.         MyThread myThread = new MyThread();
  7.         Thread thread = new Thread(myThread);
  8.         thread.start();
  9.         while (true) {
  10.             System.out.println("main()方法运行");
  11.             try {
  12.                 Thread.sleep(2);
  13.             } catch (InterruptedException e) {
  14.                 e.printStackTrace();
  15.             }
  16.         }
  17.     }
  18. }
  20. class MyThread implements Runnable {
  21.     @Override
  22.     public void run() {
  23.         while (true) {
  24.             System.out.println("MyThread类的run()方法运行");
  25.             try {
  26.                 Thread.sleep(2);
  27.             } catch (InterruptedException e) {
  28.                 e.printStackTrace();
  29.             }
  30.         }
  31.     }
  32. }
  1. 实现Callable接口实现多线程，但是只有Runnable类型的参数才能构造Thread，而FutureTask类继承了Runnable接口且可以使用Callable类型参数构造，可以把FutureTask看作是适配器Adapter，连接Thread类和Callable的实现类， Callable接口相对于Runnable，可以获得线程异步执行的返回值，但get()获取返回值时会阻塞主线程 ```java public class Demo1 { public static void main(String[] args) {
    1.  MyThread myThread = new MyThread();
    2.  FutureTask<String> ft = new FutureTask<>(myThread);
    3.  new Thread(ft).start();
    4.  try {
    5.      String myThreadReturn = ft.get();
    6.      System.out.println(myThreadReturn);
    7.  } catch (InterruptedException e) {
    8.      e.printStackTrace();
    9.  } catch (ExecutionException e) {
    10.      e.printStackTrace();
    11.  }
    12.  System.out.println("main()方法执行");
    } }

class MyThread implements Callable { @Override public String call() throws Exception { Thread.sleep(5000); return “MyThread的返回值”; } }

  1. <a name="wmv6k"></a>
  2. ## 设置线程优先级
  4. - Thread类中的setPriority()方法
  5. - 线程优先级默认为5，可设置为1-10
  6. ```java
  7. public class Demo3 {
  8.     public static void main(String[] args) {
  9.         Thread A = new Thread(new Task(), "A");
  10.         Thread B = new Thread(new Task(), "B");
  11.         A.setPriority(1);
  12.         B.setPriority(10);
  13.         A.start();
  14.         B.start();
  15.     }
  16. }
  18. class Task implements Runnable {
  19.     @Override
  20.     public void run() {
  21.         System.out.println(Thread.currentThread().getName() + "正在运行方法");
  22.     }
  23. }

线程让步

  • run方法中，满足了某个条件后通过调用yield()方法将CPU执行权让给优先级相同或更高的线程 ```java public class Demo4 { public static void main(String[] args) {
    1.   Thread A = new Thread(new Task4(), "A");
    2.   Thread B = new Thread(new Task4(), "B");
    3.   /* 线程优先级为1-10，默认为5 */
    4.   A.setPriority(1);
    5.   B.setPriority(10);
    6.   A.start();
    7.   B.start();
    } }

class Task4 implements Runnable { @Override public void run() { for (int i = 0; i < 6; i++) { if (i == 3) { System.out.println(Thread.currentThread().getName() + “线程让步”); Thread.yield(); } System.out.println(Thread.currentThread().getName() + “ “ + i); } } }

  1. <a name="KkGVi"></a>
  2. ## 线程插队
  4. - 本线程执行过程中，调用别的线程的join()方法，即可将本线程阻塞，待被调用线程执行完成后再唤醒本线程
  5. ```java
  6. public class Demo5 {
  7.     public static void main(String[] args) throws InterruptedException {
  8.         Thread t = new Thread(new Task5(), "A");
  9.         t.start();
  10.         for (int i = 0; i < 10; i++) {
  11.             if (i == 2) {
  12.                 t.join();
  13.             }
  14.             System.out.println(Thread.currentThread().getName() + " " + i);
  15.         }
  16.     }
  17. }
  19. class Task5 implements Runnable {
  20.     @Override
  21.     public void run() {
  22.         for (int i = 0; i < 50; i++) {
  23.             System.out.println(Thread.currentThread().getName() + " " + i);
  24.         }
  25.     }
  26. }

线程同步

同步方法

  • 多线程下要想不出现安全问题，就必须保证同一时刻只有一个线程能访问资源，可以为操作资源的方法加入锁，或把方法加入同步代码块中
  • 并不是给run方法加synchronized，而是给操作单个资源的方法加synchronized
  • 对于Synchronized修饰的方法，因为有不同的线程进入该方法中被阻塞，所以在操作资源前仍需要对资源的可操作性进行判断，否则资源唤醒后没有验证可操作性直接修改资源，就会出错 ```java public class Demo6 { public static void main(String[] args) {
    1.   TicketWarehouse6 tw = new TicketWarehouse6();
    2.   new Thread(tw, "A").start();
    3.   new Thread(tw, "B").start();
    4.   new Thread(tw, "C").start();
    5.   new Thread(tw, "D").start();
    } }

class TicketWarehouse6 implements Runnable {

  1. private int tickets = 100;
  3. @Override
  4. public void run() {
  5.     while (tickets > 0) {
  6.         sell();
  7.     }
  8. }
  10. public synchronized void sell() {
  11.     try {
  12.         //模拟卖票时的处理时间
  13.         Thread.sleep(20);
  14.     } catch (InterruptedException e) {
  15.         e.printStackTrace();
  16.     }
  17.     if (tickets > 0) {
  18.         System.out.println(Thread.currentThread().getName() + " 卖出了第 " 
  19.                            + (100 - (--tickets)) + " 张票");
  20.     }
  21. }

}

  1. <a name="xMiFC"></a>
  2. #### 同步代码块
  4. - 把操作单个资源方法放入到同步代码块中
  5. ```java
  6. public class Demo7 {
  7.     public static void main(String[] args) {
  8.         TicketWarehouse7 tw = new TicketWarehouse7();
  9.         new Thread(tw, "A").start();
  10.         new Thread(tw, "B").start();
  11.         new Thread(tw, "C").start();
  12.         new Thread(tw, "D").start();
  13.     }
  14. }
  16. class TicketWarehouse7 implements Runnable {
  18.     private int tickets = 100;
  20.     @Override
  21.     public void run() {
  22.         while (tickets > 0) {
  23.             synchronized (TicketWarehouse7.class) {
  24.                 sell();
  25.             }
  26.         }
  27.     }
  29.     public void sell() {
  30.         try {
  31.             //模拟卖票时的处理时间
  32.             Thread.sleep(20);
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         }
  36.         if (tickets > 0) {
  37.             System.out.println(Thread.currentThread().getName() + " 卖出了第 " 
  38.                                + (100 - (--tickets)) + " 张票");
  39.         }
  40.     }
  41. }

模拟一个死锁

  • A拿到了A锁，想通过拿到B锁执行方法后释放A锁；B拿到了B锁，想通过拿到A锁执行方法后释放B锁

  • 两者都互相持有对方想要的资源，程序无法执行，产生了死锁

    1. public class Demo8 {
    2.   public static void main(String[] args) {
    3.       Object A = new Object();
    4.       Object B = new Object();
    6.       new Thread(()->{
    7.           synchronized (A) {
    8.               System.out.println(Thread.currentThread().getName() + " 拿到了 A 锁");
    9.               try {
    10.                   Thread.sleep(200);
    11.               } catch (InterruptedException e) {
    12.                   e.printStackTrace();
    13.               }
    14.               synchronized (B) {
    15.                   System.out.println(Thread.currentThread().getName() + " 拿到了 B 锁");
    16.               }
    17.           }
    18.       }, "线程 A").start();
    20.       new Thread(()->{
    21.           synchronized (B) {
    22.               System.out.println(Thread.currentThread().getName() + " 拿到了 A 锁");
    23.               try {
    24.                   Thread.sleep(200);
    25.               } catch (InterruptedException e) {
    26.                   e.printStackTrace();
    27.               }
    28.               synchronized (A) {
    29.                   System.out.println(Thread.currentThread().getName() + " 拿到了 B 锁");
    30.               }
    31.           }
    32.       }, "线程 B").start();
    33.   }
    34. }

    并发编程

  • 并发：单个CPU的操作系统在进行多线程操作时，将CPU时间划分为若干个时间段，再将时间段分配给各个线程执行，再一个时间段内只运行一个线程，其他线程处于挂起状态。

  • 并行：多CPU操作系统进行多线程操作，不同的CPU执行不同的线程，即线程之间不抢占CPU资源。

    sleep和wait区别

  1. sleep只让出CPU，不释放同步资源锁；wait会释放同步资源锁，notify才能解除线程的wait状态

  2. sleep可以在任何地方使用，wait只能在同步方法或同步代码块中使用

    Lock锁

    使用三部曲

  3. 创建锁

  4. 操作资源前加锁
  5. 操作完资源后解锁 ```java public class Demo1SynchronizedAndLock { public static void main(String[] args) {
    1.  TicketWarehouse tw = new TicketWarehouse();
    2.  new Thread(() -> {
    3.      for (int i = 0; i < 50; i++) {
    4.          try {
    5.              tw.sell();
    6.          } catch (InterruptedException e) {
    7.              e.printStackTrace();
    8.          }
    9.      }
    10.  }, "A").start();
    11.  new Thread(() -> {
    12.      for (int i = 0; i < 50; i++) {
    13.          try {
    14.              tw.sell();
    15.          } catch (InterruptedException e) {
    16.              e.printStackTrace();
    17.          }
    18.      }
    19.  }, "B").start();
    20.  new Thread(() -> {
    21.      for (int i = 0; i < 50; i++) {
    22.          try {
    23.              tw.sell();
    24.          } catch (InterruptedException e) {
    25.              e.printStackTrace();
    26.          }
    27.      }
    28.  }, "C").start();
    } }

class TicketWarehouse { private int tickets = 100;

  1. ReentrantLock lock = new ReentrantLock();
  3. public void sell() throws InterruptedException {
  4.     lock.lock();
  5.     if (tickets > 0) {
  6.         TimeUnit.MILLISECONDS.sleep(100);
  7.         System.out.println(Thread.currentThread().getName() + " 卖出了第 " 
  8.                            + (100 - (--tickets)) + " 张票");
  9.     }
  10.     lock.unlock();
  11. }

}

  1. <a name="mKIyn"></a>
  2. ### Lock锁与synchronized的区别
  4. - synchronized是Java内置关键字，而Lock是一个类
  5. - synchronized无法获取锁的状态，Lock可以判断是否获取到了锁
  6. - synchronized会自动释放锁，Lock必须手动释放，不然会产生死锁
  7. - synchronized 线程1获取到锁后线程2只会等待，而Lock对于这种情况线程2不一定会等待
  8. - synchronized可重入锁，不可中断，Lock可重入锁，可以判断锁，可以设置公平与非公平
  9. - synchronized适合少量的代码同步，Lock适合大量的代码同步
  11. <a name="zlpRt"></a>
  12. ## 生产者消费者
  13. <a name="l1sz5"></a>
  14. ### synchronized版
  16. - Data类中有一个资源属性，一个增加资源的方法，一个减少资源方法
  17. - increase()方法中判断资源为1则进入等待状态，否则增加资源，唤醒其他线程
  18. - decrease()方法中判断资源为0则进入等待状态，否则减少资源，唤醒其他线程
  19. - 老问题：在操作资源时必须先对资源的可操作性进行判断
  20. ```java
  21. public class Demo2SynchronizedPC {
  22.     public static void main(String[] args) {
  23.         Data2 data = new Data2();
  24.         new Thread(() -> {
  25.             for (int i = 0; i < 50; i++) {
  26.                 try {
  27.                     data.decrease();
  28.                 } catch (InterruptedException e) {
  29.                     e.printStackTrace();
  30.                 }
  31.             }
  32.         }, "消费者1").start();
  33.         new Thread(() -> {
  34.             for (int i = 0; i < 50; i++) {
  35.                 try {
  36.                     data.decrease();
  37.                 } catch (InterruptedException e) {
  38.                     e.printStackTrace();
  39.                 }
  40.             }
  41.         }, "消费者2").start();
  42.         new Thread(() -> {
  43.             for (int i = 0; i < 50; i++) {
  44.                 try {
  45.                     data.increase();
  46.                 } catch (InterruptedException e) {
  47.                     e.printStackTrace();
  48.                 }
  49.             }
  50.         }, "生产者1").start();
  51.         new Thread(() -> {
  52.             for (int i = 0; i < 50; i++) {
  53.                 try {
  54.                     data.increase();
  55.                 } catch (InterruptedException e) {
  56.                     e.printStackTrace();
  57.                 }
  58.             }
  59.         }, "生产者2").start();
  60.     }
  61. }
  63. class Data2 {
  65.     private int number = 0;
  67.     //+1
  68.     public synchronized void increase() throws InterruptedException {
  69.         while (number != 0) {
  70.             this.wait();
  71.         }
  72.         number++;
  73.         System.out.println(Thread.currentThread().getName() + "进行了 +1 操作，number=>" + number);
  74.         this.notifyAll();
  75.     }
  77.     //-1
  78.     public synchronized void decrease() throws InterruptedException {
  79.         while (number == 0) {
  80.             this.wait();
  81.         }
  82.         number--;
  83.         System.out.println(Thread.currentThread().getName() + "进行了 -1 操作，number=>" + number);
  84.         this.notifyAll();
  85.     }
  86. }

Lock版

  • 创建一个lock锁以后，通过lock锁获取condition对象
  • 线程的等待方法为condition.await(); 唤醒其他线程的方法为condition.signalAll();
  • 不要忘记lock.unlock()解锁！！ ```java public class Demo3LockPC { public static void main(String[] args) {
    1.   Data3 data = new Data3();
    2.   new Thread(() -> {
    3.       for (int i = 0; i < 50; i++) {
    4.           data.increase();
    5.       }
    6.   }, "生产者1").start();
    7.   new Thread(() -> {
    8.       for (int i = 0; i < 50; i++) {
    9.           data.decrease();
    10.       }
    11.   }, "消费者1").start();
    12.   new Thread(() -> {
    13.       for (int i = 0; i < 50; i++) {
    14.           data.decrease();
    15.       }
    16.   }, "消费者2").start();
    17.   new Thread(() -> {
    18.       for (int i = 0; i < 50; i++) {
    19.           data.increase();
    20.       }
    21.   }, "生产者2").start();
    } }

class Data3 { private int number = 0;

  1. Lock lock = new ReentrantLock();
  2. Condition condition = lock.newCondition();
  4. public void increase() {
  5.     lock.lock();
  6.     try {
  7.         while (number != 0) {
  8.             condition.await();  //等待
  9.         }
  10.         number++;
  11.         System.out.println(Thread.currentThread().getName() + " -> " + number);
  12.         condition.signalAll();  //通知其他线程
  13.     } catch (Exception e) {
  14.         e.printStackTrace();
  15.     } finally {
  16.         lock.unlock();
  17.     }
  18. }
  20. public void decrease() {
  21.     lock.lock();
  22.     try {
  23.         while (number == 0) {
  24.             condition.await();
  25.         }
  26.         number--;
  27.         System.out.println(Thread.currentThread().getName() + " -> " + number);
  28.         condition.signalAll();
  29.     } catch (Exception e) {
  30.         e.printStackTrace();
  31.     } finally {
  32.         lock.unlock();
  33.     }
  34. }

}

  1. <a name="crlBG"></a>
  2. ## Lock锁的优势
  4. - 精准唤醒某个线程
  5. - 创建两个线程，分别调用了方法B和方法C，都被阻塞
  6. - 再创建一个新的线程，通过conditionC.signal();来唤醒调用方法C的那个线程
  7. ```java
  8. public class Demo4Condition {
  10.     public static void main(String[] args) throws InterruptedException {
  11.         Task4 task = new Task4();
  12.         /* 线程B和C使用根据不同的条件而相机进入阻塞状态 */
  13.         new Thread(task::printB, "B").start();
  14.         new Thread(task::printC, "C").start();
  16.         /* 创建一个新的线程唤醒指定的线程（根据不同的condition），没被唤醒的线程仍是阻塞状态 */
  17.         new Thread(task::printA, "A").start();
  18.     }
  20. }
  22. class Task4 {
  24.     private int flag = 1;
  26.     Lock lock = new ReentrantLock();
  27.     Condition conditionB = lock.newCondition();
  28.     Condition conditionC = lock.newCondition();
  30.     public void printA() {
  31.         lock.lock();
  32.         /*
  33.         唤醒C
  34.          */
  35.         conditionC.signal();
  36. //        conditionB.signal();
  37.         lock.unlock();
  38.     }
  40.     public void printB() {
  41.         lock.lock();
  42.         try {
  43.             conditionB.await();
  44.             System.out.println(Thread.currentThread().getName() + "： B");
  45.         } catch (InterruptedException e) {
  46.             e.printStackTrace();
  47.         } finally {
  48.             lock.unlock();
  49.         }
  50.     }
  52.     public void printC() {
  53.         lock.lock();
  54.         try {
  55.             conditionC.await();
  56.             System.out.println(Thread.currentThread().getName() + "： C");
  57.         } catch (InterruptedException e) {
  58.             e.printStackTrace();
  59.         } finally {
  60.             lock.unlock();
  61.         }
  62.     }
  64. }

8锁问题

  1. 先发短信还是先打电话？ ```java public class Demo1 { public static void main(String[] args) throws InterruptedException {
    1.  Phone phone = new Phone();
    2.  new Thread(phone::sendSMS, "A").start();
    3.  TimeUnit.SECONDS.sleep(1);
    4.  new Thread(phone::call, "B").start();
    } }

class Phone { public synchronized void sendSMS() { System.out.println(“发短信”); }

  1. public synchronized void call() {
  2.     System.out.println("打电话");
  3. }

}

  1. **结果：**先发短信，再打电话，但不是程序的顺序执行原因
  3. 2. 在1的基础上，让发短信延迟4秒中
  4. ```java
  5. public synchronized void sendSMS() {
  6.     TimeUnit.SECONDS.sleep(4);
  7.     System.out.println("发短信");
  8. }

结果：还是先发短信再打电话，不是顺序执行的原因，是因为synchronized锁的对象是phone（同一个对象）， 谁先拿到谁执行，另一个等待。

  1. 在Phone类中添加一个普通方法hello()，此时再运行 ```java … new Thread(()->{
    1.  phone.hello();
    }).start(); …

class Phone{ … public void hello(){ … } }

  1. **结果：**先执行hello()，因为普通方法不受synchronized影响，但是如果把延迟4秒去掉，那么就会变为顺序执行
  3. 4. 再创建一个Phone对象，两个线程调用两个不同对象的方法
  4. ```java
  5. public class Demo4 {
  6.     public static void main(String[] args) throws Exception {
  7.         Phone4 phone1 = new Phone4();
  8.         Phone4 phone2 = new Phone4();
  9.         new Thread(()->{
  10.             try {
  11.                 phone1.sendSMS();
  12.             } catch (Exception e) {
  13.                 e.printStackTrace();
  14.             }
  15.         }, "A").start();
  16.         TimeUnit.SECONDS.sleep(1);
  17.         new Thread(phone2::call, "B").start();
  18.     }
  19. }
  21. class Phone4 {
  22.     public synchronized void sendSMS() throws Exception {
  23.         TimeUnit.SECONDS.sleep(4);
  24.         System.out.println("发短信");
  25.     }
  26.     public synchronized void call() {
  27.         System.out.println("打电话");
  28.     }
  29. }

结果：先打电话再发短信，执行：线程A开启，延迟4秒后执行 -> 等待1秒 -> 线程B开启 -> 线程B执行 -> 线程A等待结束，执行

  1. 两个synchronized方法都加上static关键字，一个对象调用两个方法，两个对象调用两个方法

    1. class Phone5 {
    2.  public static synchronized void sendSMS() throws Exception {
    3.      TimeUnit.SECONDS.sleep(4);
    4.      System.out.println("发短信");
    5.  }
    7.  public static synchronized void call() {
    8.      System.out.println("打电话");
    9.  }
    10. }

    结果：结果都是先发短信后打电话，因为这时锁的就不是对象了，而是类Class，Class只有一份，不管有多少个对象，谁先拿到Class的锁，谁就先执行

  2. 类的两个方法，只有一个是static修饰，使用同一个对象调用两个方法 ```java public class Demo7 { public static void main(String[] args) throws Exception {

    1.  Phone7 phone = new Phone7();
    2.  new Thread(()->{
    3.      try {
    4.          phone.sendSMS();
    5.      } catch (Exception e) {
    6.          e.printStackTrace();
    7.      }
    8.  }, "A").start();
    10.  TimeUnit.SECONDS.sleep(1);
    12.  new Thread(()->{
    13.      try {
    14.          phone.call();
    15.      } catch (Exception e) {
    16.          e.printStackTrace();
    17.      }
    18.  }, "B").start();

    } }

class Phone7 { public static synchronized void sendSMS() throws Exception { TimeUnit.SECONDS.sleep(4); System.out.println(“发短信”); }

  1. public synchronized void call() {
  2.     System.out.println("打电话");
  3. }

}

  1. **结果：**先打电话再发短信，因为锁的是两个不同的对象，一个是类模板，一个是对象调用者
  3. 7.  在6的基础上使用两个对象调用两个方法
  5. **结果：**还是先打电话再发短信，两把锁锁的是不同的对象 
  6. <a name="54bbba80"></a>
  7. ### 结论
  8. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/21390724/1630314900935-a254a7d2-27f7-4974-b620-80b5d1dc59e4.png#clientId=u79faf74b-ca4c-4&from=paste&height=119&id=u5a74d229&margin=%5Bobject%20Object%5D&name=image.png&originHeight=119&originWidth=917&originalType=binary&ratio=1&size=13362&status=done&style=none&taskId=u8d4f95d1-24fe-497d-9a74-943ce0bdde8&width=917)
  9. <a name="QLI5F"></a>
  10. ## 不安全的集合类
  12. - 在并发环境下，List、Set、Map都是不安全的，修改可能会出现java.util.ConcurrentModificationException  
  13. <a name="fAgwT"></a>
  14. ### 解决方案
  15. <a name="zulbl"></a>
  16. #### Collection.synchronized
  18. - 使用ArrayList或Set构造一个线程安全的ArrayList或HashSet
  19. ```java
  20. List list = Collections.synchronizedList(new ArrayList<>());
  21. Set<Object> set = Collections.synchronizedSet(new HashSet<>());

Vector代替List

使用线程安全的集合类

  • CopyOnWriteArrayList
  • CopyOnWriteArraySet

  • ConcurrentMap

    辅助工具

    CountDownLatch

  • 类似于一个计数器，调用countDown()方法可以减少计数器，当计数器归零时候执行countDownLatch.await()后面的代码

    1. public class Demo01TestCountDownLatch {
    2.   public static void main(String[] args) throws InterruptedException {
    3.       CountDownLatch countDownLatch = new CountDownLatch(24);
    4.       for (int i = 1; i <= 24; i++) {
    5.           System.out.println("现在是第" + i + "个小时");
    6.           countDownLatch.countDown();
    7.       }
    8.       countDownLatch.await();
    9.       /* 计数器归零了，开始执行以下代码 */
    10.       System.out.println("已经过了24个小时");
    11.   }
    12. }

    CyclickBarrier

  • 允许一组线程互相等待，以达到一个共同的屏障点后开始执行某操作。

  • 创建CyclickBarrier对象的时候可以指定多少个线程达到共同屏障点后执行什么样的操作

    1. public class Demo02TestCyclickBarrier {
    2.   public static void main(String[] args) {
    3.       /* 允许一组线程相互等待，到达一个共同的屏障点后才继续执行操作 */
    4.       CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
    5.           System.out.println("可以召唤神龙了");
    6.       });
    7.       for (int i = 1; i <= 7; i++) {
    8.           int finalI = i;
    9.           new Thread(() -> {
    10.               System.out.println(Thread.currentThread().getName() + " 收集了 " + finalI + " 星珠");
    11.               try {
    12.                   //执行完毕后进入等待状态
    13.                   cyclicBarrier.await();
    14.               } catch (InterruptedException e) {
    15.                   e.printStackTrace();
    16.               } catch (BrokenBarrierException e) {
    17.                   e.printStackTrace();
    18.               }
    19.           }, String.valueOf(i)).start();
    20.       }
    21.   }
    22. }

    Semaphore

  • 计数信号量，acquire获取许可，release释放许可，通常用于限制访问同一资源的线程数量

    1. public class Demo03TestSemaphore {
    2.   public static void main(String[] args) {
    3.       //总共由两个信号量，多个线程竞争，使用完毕后释放信号量
    4.       Semaphore semaphore = new Semaphore(2);
    5.       for (int i = 0; i < 10; i++) {
    6.           new Thread(() -> {
    7.               try {
    8.                   semaphore.acquire();
    9.                   System.out.println(Thread.currentThread().getName() + " 获得了许可证");
    10.                   Thread.sleep(2000);
    11.               } catch (InterruptedException e) {
    12.                   e.printStackTrace();
    13.               } finally {
    14.                   semaphore.release();
    15.               }
    16.           }, String.valueOf(i)).start();
    18.       }
    19.   }
    20. }

    读写锁

  • 写的时候只允许一个线程去写，但读的时候可以允许多个线程去读，这种场景可以使用读写锁（有些也叫独占锁、共享锁）实现。

  • 读写锁相对于普通的公平锁/非公平锁，细粒度更高
  • 在不加锁的情况下运行，可能会出现一个key还没写入完毕，另一个线程的key就开始写入了，因此我们对于put方法加上写锁，对于get方法加上读锁 ```java ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

public void put(String key, String value) { readWriteLock.writeLock().lock(); try { System.out.println(Thread.currentThread().getName() + “ 开始写入 “ + key + “ - “ + value); map.put(key, value); System.out.println(Thread.currentThread().getName() + “ 写入完毕”); } catch (Exception e) { e.printStackTrace(); } finally { readWriteLock.writeLock().unlock(); } }

public String get(String key) { String s = “”; readWriteLock.readLock().lock(); try { System.out.println(Thread.currentThread().getName() + “ 读取 “ + key + “ 的内容”); s = map.get(key); System.out.println(Thread.currentThread().getName() + “ 读取的内容为 “ + s); return s; } catch (Exception e) { e.printStackTrace(); } finally { readWriteLock.readLock().unlock(); return s; } }

  2. - 改进后只有完全执行完put方法后，其他线程才能进行put方法，达到了我们想要的效果。
  3. <a name="nIIai"></a>
  4. ## 阻塞队列
  5. <a name="tBQE7"></a>
  6. ### 关系树
  7. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/21390724/1630336774083-f661c2a0-cd2c-4356-a236-8755bb67a198.png#clientId=u3cc455d9-2476-4&from=paste&height=627&id=uc5382d25&margin=%5Bobject%20Object%5D&name=image.png&originHeight=627&originWidth=799&originalType=binary&ratio=1&size=39173&status=done&style=none&taskId=u40e69d6a-a19a-413f-be6b-9f90eceffdb&width=799)
  8. <a name="Zymyx"></a>
  9. ### ArrayBlockingQueue
  10. | **方式** | **抛出异常** | **不会抛出异常，有返回值** | **阻塞 等待** | **超时 等待** |
  11. | --- | --- | --- | --- | --- |
  12. | **添加** | add | offer | put | offer(timenum，timeUnit) |
  13. | **移除** | remove | poll | take | poll(timenum，timeUnit) |
  14. | **判断队列首** | element | peek | - | - |
  16. ```java
  17. /**
  18.  * 有返回值，抛出异常
  19.  * add remove element
  20.  */
  21. public static void test1() {
  22.     ArrayBlockingQueue<Object> queue1 = new ArrayBlockingQueue<>(3);     //初始化大小为3
  23.     System.out.println(queue1.add("1"));
  24.     System.out.println(queue1.add("2"));
  25.     System.out.println(queue1.add("3"));
  26.     System.out.println(queue1.element());    //队首元素
  27.     System.out.println(queue1.remove());
  28.     System.out.println(queue1.remove());
  29.     System.out.println(queue1.remove());
  30.     System.out.println(queue1.remove());     //没有元素了还使用remove()方法，则会抛出异常
  31. }
  33. /**
  34.  * 不抛出异常，有返回值
  35.  * offer poll peek
  36.  */
  37. public static void test2() {
  38.     ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<>(3);
  39.     System.out.println(queue.offer("1"));
  40.     System.out.println(queue.offer("2"));
  41.     System.out.println(queue.offer("3"));
  42.     System.out.println(queue.peek());
  43.     System.out.println(queue.poll());
  44.     System.out.println(queue.poll());
  45.     System.out.println(queue.poll());
  46.     System.out.println(queue.poll());       //不抛出异常，直接返回null
  47. }
  49. /**
  50.  * 阻塞等待
  51.  * put take
  52.  */
  53. public static void test3() throws InterruptedException {
  54.     ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<>(3);
  55.     queue.put("1");
  56.     queue.put("2");
  57.     queue.put("3");
  58.     System.out.println(queue.peek());
  59.     System.out.println(queue.take());
  60.     System.out.println(queue.take());
  61.     System.out.println(queue.take());
  62.     System.out.println(queue.take());     //取不到元素，会进入阻塞状态
  63. }
  65. /**
  66.  * 超时等待
  67.  * offer poll(time)
  68.  */
  69. public static void test4() throws InterruptedException {
  70.     ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<>(3);
  71.     queue.offer("1");
  72.     queue.offer("2");
  73.     queue.offer("3");
  74.     System.out.println(queue.poll(2, TimeUnit.SECONDS));
  75.     System.out.println(queue.poll(2, TimeUnit.SECONDS));
  76.     System.out.println(queue.poll(2, TimeUnit.SECONDS));
  77.     System.out.println(queue.poll(2, TimeUnit.SECONDS));     //等待两秒，若还没有取到元素则返回null
  78. }

同步队列

  • 可以看作是容量为1的队列，放入一个元素后必须取出来才能继续放进去，底层采用lock锁保证线程安全

    1. public class Demo {
    2.   public static void main(String[] args) {
    3.       SynchronousQueue<Object> queue = new SynchronousQueue<>();
    5.       new Thread(() -> {
    6.           try {
    7.               System.out.println(Thread.currentThread().getName() + " put 1");
    8.               queue.put("1");
    9.               System.out.println(Thread.currentThread().getName() + " put 2");
    10.               queue.put("2");
    11.               System.out.println(Thread.currentThread().getName() + " put 3");
    12.               queue.put("3");
    13.           } catch (InterruptedException e) {
    14.               e.printStackTrace();
    15.           }
    16.       }, "T1").start();
    18.       new Thread(() -> {
    19.           try {
    20.               System.out.println(Thread.currentThread().getName() + " take " + queue.take());
    21.               TimeUnit.SECONDS.sleep(2);
    22.               System.out.println(Thread.currentThread().getName() + " take " + queue.take());
    23.               TimeUnit.SECONDS.sleep(2);
    24.               System.out.println(Thread.currentThread().getName() + " take " + queue.take());
    25.           } catch (InterruptedException e) {
    26.               e.printStackTrace();
    27.           }
    28.       }, "T2").start();
    30.   }
    31. }

    运行结果
    image.png

    线程池

    创建

  • 单个线程

  • 固定线程

  • 弹性伸缩大小

    1. public class Demo {
    2.   public static void main(String[] args) {
    4.       ExecutorService threadPool1 = Executors.newSingleThreadExecutor();
    5.       ExecutorService threadPool2 = Executors.newFixedThreadPool(5);
    6.       ExecutorService threadPool3 = Executors.newCachedThreadPool();
    8.       try {
    9.           for (int i = 0; i < 10; i++) {
    10.               threadPool3.execute(() -> {
    11.                   System.out.println(Thread.currentThread().getName() + " ok");
    12.               });
    13.           }
    14.       } catch (Exception e) {
    15.           e.printStackTrace();
    16.       } finally {
    17.           threadPool3.shutdown();
    18.       }
    20.   }
    21. }

    7大参数

  • 指的是ThreadPoolExecutor 构造器中的7个参数

  • corePoolSize – 要保留在池中的线程数，即使它们处于空闲状态，除非设置了allowCoreThreadTimeOut
  • maximumPoolSize – 池中允许的最大线程数
  • keepAliveTime – 多余空闲线程在终止前等待新任务的最长时间
  • unit – keepAliveTime参数的时间单位
  • workQueue – 用于在执行任务之前保存任务的队列。 这个队列将只保存execute方法提交的Runnable任务
  • threadFactory – 执行程序创建新线程时使用的工厂
  • handler – 执行被阻塞时使用的处理程序，因为达到了线程边界和队列容量

image.png
代码实现

  1. public class Demo2 {
  2.     public static void main(String[] args) {
  4.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 5, 2, TimeUnit.SECONDS,
  5.                 new LinkedBlockingQueue<Runnable>(3),
  6.                 Executors.defaultThreadFactory(),
  7.                 new ThreadPoolExecutor.AbortPolicy());        //默认的策略：丢弃任务并抛出RejectedExecutionException异常
  8.                 //new ThreadPoolExecutor.DiscardPolicy());            丢弃任务，不抛出异常
  9.                 //new ThreadPoolExecutor.DiscardOldestPolicy());    丢弃旧任务（最先加入队列的），再把新任务添加
  10.                 //new ThreadPoolExecutor.CallerRunsPolicy());        由调用线程处理该任务
  12.         try {
  13.             for (int i = 1; i <= 10; i++) {        //这里的10代表有10个任务需要处理，但是整个线程池中最大可容纳8个任务，因此会抛出异常
  14.                 int finalI = i;
  15.                 threadPool.execute(()->{
  16.                     try {
  17.                         TimeUnit.SECONDS.sleep(2);
  18.                     } catch (InterruptedException e) {
  19.                         e.printStackTrace();
  20.                     }
  21.                     System.out.println(Thread.currentThread().getName() + " 执行任务" + finalI + " ok");
  22.                 });
  23.             }
  24.         } catch (Exception e) {
  25.             e.printStackTrace();
  26.         } finally {
  27.             threadPool.shutdown();
  28.         }
  30.     }
  31. }

4种拒绝策略

  • new ThreadPoolExecutor.AbortPolicy()); 默认的策略：丢弃任务并抛出RejectedExecutionException异常
  • new ThreadPoolExecutor.DiscardPolicy()); 丢弃任务，不抛出异常
  • new ThreadPoolExecutor.DiscardOldestPolicy()); 丢弃旧任务（最先加入队列的），再把新任务添加

  • new ThreadPoolExecutor.CallerRunsPolicy()); 由调用线程处理该任务

    如何设置线程池大小

  • CPU密集型：电脑核数是几核就设置几

    1. int cpuNum = Runtime.getRuntime().availableProcessors();        //获取CPU核心数（这里指的是线程数）

  • I/O密集型
    比如程序中有15个大型任务，IO非常占用资源，此时我们可以设置线程数量为IO数的两倍，如30

    函数式接口

    function函数型接口

  • 接受收一个参数并产生结果的函数。这是一个功能接口，其功能方法是apply(Object)

    1. public class TestFunction {
    2.   public static void main(String[] args) {
    3.       Function<String, String> function = new Function<String, String>() {
    4.           @Override
    5.           public String apply(String s) {
    6.               return s;
    7.           }
    8.       };
    9.       System.out.println(function.apply("hello world"));
    11.       //简写
    12.       Function<String, String> function1 = (str) -> {
    13.           //对str进行处理，之后返回处理结果
    14.           return str;
    15.       };
    16.       System.out.println(function1.apply("hello world"));
    18.   }
    19. }

    Predicate断定型接口

  • 也是一个功能函数，但是返回结果是布尔类型

    1. public class TestPredicate {
    2.   public static void main(String[] args) {
    3.       Predicate<String> predicate = (str) -> {
    4.           return str.isEmpty();
    5.       };
    6.       System.out.println(predicate.test("123"));
    7.       System.out.println(predicate.test(""));
    8.   }
    9. }

    Consummer 消费型接口

  • 接受单个输入参数且不返回结果的操作。 与大多数其他功能接口不同， Consumer预计通过副作用进行操作。这是一个功能接口，其功能方法是accept(Object) 

    1. public class TestConsummer {
    2.   public static void main(String[] args) {
    3.       Consumer<String> consumer = (str) -> {
    4.           System.out.println(str);
    5.       };
    6.       consumer.accept("123");
    7.   }
    8. }

    Supplier供给型接口

  • 结果的提供者。没有要求每次调用供应商时都返回一个新的或不同的结果。这是一个函数式接口，其函数式方法是get()

    1. public class TestSupplier {
    2.   public static void main(String[] args) {
    3.       Supplier<Integer> supplier = () -> {
    4.           return 1024;
    5.       };
    6.       System.out.println(supplier.get());
    7.   }
    8. }

    Stream流式计算

    1. public class Demo {
    2.   public static void main(String[] args) {
    3.       User a = new User(1, "a", 20);
    4.       User b = new User(2, "b", 23);
    5.       User c = new User(3, "c", 22);
    6.       User d = new User(4, "d", 26);
    7.       User e = new User(5, "e", 24);
    8.       List<User> users = Arrays.asList(a, b, c, d, e);
    10.       /**
    11.        * 筛选id为偶数
    12.        * 年龄>23
    13.        * 名字转为大写
    14.        * 倒序排序
    15.        * 输出一个
    16.        */
    17.       users.stream()
    18.               .filter(u->{return u.getId()%2==0;})
    19.               .filter(u->{return u.getAge()>23;})
    20.               .map(u->{return u.getName().toUpperCase();})
    21.               .sorted((u1, u2)->{
    22.                   return u2.compareTo(u1);
    23.               })
    24.               .limit(1)
    25.               .forEach(System.out::println);
    27.   }
    28. }

    ForkJoin

    核心思想

    image.png

    工作窃取

  • 空闲线程可以拿到其他线程的未执行完的任务，实现：双端队列

image.png

案例：分解求和

  • 求和类要继承RecursiveTask，重写compute方法
  • 定义小任务（计算小范围的值）

  • 当范围大于某个值以后分解任务，并将其fork压入队列，返回值为各小任务的join结果相加

    1. public class ForkJoinDemo extends RecursiveTask<Long> {
    3.   private long start;
    4.   private long end;
    6.   //临界值
    7.   private long temp = 10000L;
    9.   public ForkJoinDemo(long start, long end) {
    10.       this.start = start;
    11.       this.end = end;
    12.   }
    14.   @Override
    15.   protected Long compute() {
    16.       if ((end - start) < temp) {
    17.           long sum = 0;
    18.           for (long i = start; i < end; i++) {
    19.               sum += i;
    20.           }
    21.           return sum;
    22.       } else {
    23.           long middle = (start + end) / 2;
    24.           ForkJoinDemo forkJoinDemoTask1 = new ForkJoinDemo(start, middle);
    25.           forkJoinDemoTask1.fork();       //将任务压入线程队列
    26.           ForkJoinDemo forkJoinDemoTask2 = new ForkJoinDemo(middle, end);
    27.           forkJoinDemoTask2.fork();
    28.           return forkJoinDemoTask1.join() + forkJoinDemoTask2.join();
    29.       }
    30.   }
    31. }

  • 测试：实例化我们自定义的计算类，然后将其提交给ForkJoinPool，最后用get获取结果

    1. public class Test {
    2.   public static void main(String[] args) throws Exception {
    3.       long start = System.currentTimeMillis();
    4.       ForkJoinPool forkJoinPool = new ForkJoinPool();
    5.       ForkJoinDemo task = new ForkJoinDemo(0, 100_0000_0000L);
    6.       ForkJoinTask<Long> submit = forkJoinPool.submit(task);
    7.       Long aLong = submit.get();
    8.       long end = System.currentTimeMillis();
    9.       System.out.println("sum = " + aLong + "  time = " + (end - start));
    10.   }
    11. }

    异步回调

    runAsync

  • 没有返回值的异步任务

    1. public class TestRunAsync {
    2.   public static void main(String[] args) throws ExecutionException, InterruptedException {
    3.       CompletableFuture<Void> task = CompletableFuture.runAsync(() -> {
    4.           try {
    5.               TimeUnit.SECONDS.sleep(2);
    6.           } catch (InterruptedException e) {
    7.               e.printStackTrace();
    8.           }
    9.           System.out.println(Thread.currentThread().getName());
    10.       });
    11.       System.out.println("123");
    12.       System.out.println(task.get());
    13.   }
    14. }

  • 执行结果

image.png

supplyAsync

  • 有返回值的异步任务，可以自定义程序结束后的success回调和error回调

    1. public class TestSupplyAsync {
    2.   public static void main(String[] args) throws ExecutionException, InterruptedException {
    3.       CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> {
    4.           System.out.println(Thread.currentThread().getName());
    5.           int i = 0;
    6.           try {
    7.               TimeUnit.SECONDS.sleep(1);
    8.               i = 1 / 0;
    9.           } catch (InterruptedException e) {
    10.               e.printStackTrace();
    11.           }
    12.           return i;
    13.       });
    14.       System.out.println(task.whenComplete((t, u) -> {
    15.           //success回调
    16.           System.out.println("t表示正确返回的结果：" + t);
    17.           System.out.println("u表示异常抛出的信息：" + u);
    18.       }).exceptionally((e)->{
    19.           //error回调
    20.           System.out.println(e.getMessage());
    21.           return 404;
    22.       }).get());
    23.   }
    24. }

  • 无异常时

image.png

  • 有异常时

image.png

Volatile与JMM

Volatile

  1. Java虚拟机提供的轻量级的同步机制
  2. 保证可见性，不保证原子性
  3. 禁止指令重排

    JMM

  • Java Memory Model，Java内存模型，是一个概念，也是约定

    模型图

    image.png

    约定

  1. Java对共享变量的操作并不是在主内存中进行的，而是在线程自己的工作内存中
  2. 操作共享变量需要对变量加锁，同时重新读取主内存中该变量的值

  3. 切换到另一个线程的时候需要将变量解锁，同时将值重新写回主内存中

    可见性

    1. public class Demo {
    3.  private static int num = 0;
    5.  public static void main(String[] args) throws InterruptedException {
    7.      new Thread(() -> {
    8.          while (num == 0) {
    9.          }
    10.      }).start();
    12.      Thread.sleep(2000);
    14.      num = 1;
    15.      System.out.println(num);
    17.  }
    18. }
  • 上述代码，由于没有保证num的可见性，即使main线程中改变了num的值，在另一个线程中也没有读取到，所以线程一直没有终止

  • 解决方法：变量num加上volatile修饰符，保证各线程对共享变量的可见性

    原子性

  • 平常我们认为的原子操作，如num++，并不是由一条指令构成，在底层由执行引擎执行多条字节码指令（入栈、相加、出栈）完成

    1. public class Demo3 {
    2.   private static int num = 0;
    4.   private static void add() {
    5.       num++;
    6.   }
    8.   public static void main(String[] args) throws InterruptedException {
    10.       for (int i = 0; i < 200; i++) {
    11.           new Thread(() -> {
    12.               for (int j = 0; j < 10000; j++) {
    13.                   add();
    14.               }
    15.           }).start();
    16.       }
    18.       while (Thread.activeCount() > 2) {
    19.           Thread.yield();
    20.       }
    22.       Thread.sleep(2000);
    23.       System.out.println(num);
    25.   }
    26. }

  • 以上代码理论输出为2000000，但实际上并达不到，即使我们给num加了volatile修饰符

  • 解决方案：
    • 对变量的操作加锁：synchronized、lock
    • 使用AtomicInteger类

image.png

  • AtomicInteger封装了一个Unsafe变量，Unsafe变量的操作都是native方法

    指令重排

  • 源代码 -> 编译器优化重排 -> 指令也可能重排 -> 内存系统也可能会重排 -> 执行

  • 可能造成的影响结果：前提：a b x y这四个值 默认都是0 | 线程A | 线程B | | —- | —- | | x = a | y = b | | b = 1 | a = 2 |

  • 正常的结果： x = 0; y =0; | 线程A | 线程B | | —- | —- | | b = 1 | a = 2 | | x = a | y = b |

  • 可能在线程A中会出现，先执行b=1,然后再执行x=a；在B线程中可能会出现，先执行a=2，然后执行y=b；那么就有可能结果如下：x=2; y=1

volatile 可以避免指令重排

  • 内存屏障
    • 保证特定的操作的执行顺序
    • 保证某些变量的内存可见性

image.png

CAS

概念

  • AtomicXXX 类的一个方法，compareAndSet(expect, update)，expect指期望的值，update指设置的新值

    1. public class Demo {
    2.   public static void main(String[] args) {
    3.       AtomicInteger atomicInteger = new AtomicInteger(123);
    5.       //参数：期待的值，设置的新值
    6.       System.out.println(atomicInteger.compareAndSet(123, 124));        //true
    7.       System.out.println(atomicInteger.get());                        //124
    9.       System.out.println(atomicInteger.compareAndSet(123, 125));        //false
    10.       System.out.println(atomicInteger.get());                        //124
    11.   }
    12. }

  • Unsafe 类

    1. public final int getAndAddInt(Object var1, long var2, int var4) {
    2.   int var5;
    3.   do {
    4.       var5 = this.getIntVolatile(var1, var2);
    5.   } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    7.   return var5;
    8. }

  • 总结： 比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么执行操作，如果不是则一直循环，使用的是自旋锁。

  • 缺点：

    1. 循环耗时
    2. 一次只能保证一个共享变量的原子性
    3. 存在ABA问题

      ABA问题

  • 当一个线程通过CAS修改某个数据的时候，被另一个线程抢先修改但是又改了回去，该线程并不知道数据被修改过了，不影响最终结果

    1. public class TestABA {
    2.   public static void main(String[] args) throws InterruptedException {
    4.       AtomicInteger atomicInteger = new AtomicInteger(123);
    6.       new Thread(() -> {
    7.           try {
    8.               TimeUnit.SECONDS.sleep(2);
    9.           } catch (InterruptedException e) {
    10.               e.printStackTrace();
    11.           }
    12.           boolean b = atomicInteger.compareAndSet(123, 124);
    13.           System.out.println(b);
    14.           System.out.println("修改atomicInteger -> " + atomicInteger.get());
    15.       }, "A").start();
    17.       new Thread(() -> {
    18.           atomicInteger.compareAndSet(123, 125);
    19.           System.out.println("修改atomicInteger -> " + atomicInteger.get());
    20.           atomicInteger.compareAndSet(125, 123);
    21.           System.out.println("修改atomicInteger -> " + atomicInteger.get());
    22.       }, "B").start();
    23.   }
    24. }

  • 解决：使用AtomicStampedReference，定义初始值和版本号，每次对变量的操作都要修改版本号，这样其他线程就可以知道该变量有没有被修改过

    1. public class Demo2 {
    3.   static AtomicStampedReference<Integer> reference = new AtomicStampedReference<>(1, 1);
    5.   public static void main(String[] args) {
    6.       //相当于定义了一个版本号
    8.       new Thread(() -> {
    9.           int stamp = reference.getStamp();      //当前版本号
    10.           System.out.println(Thread.currentThread().getName() + " ==> 当前获取的版本号为：" + stamp);
    11.           try {
    12.               TimeUnit.SECONDS.sleep(2);
    13.           } catch (InterruptedException e) {
    14.               e.printStackTrace();
    15.           }
    16.           //满足特定条件才改变：即初始版本号
    17.           boolean b = reference.compareAndSet(1, 2, 1, reference.getStamp() + 1);
    18.           if (b) {
    19.               System.out.println("修改成功");
    20.           } else {
    21.               System.out.println("修改失败");
    22.           }
    23.       }, "A").start();
    25.       new Thread(() -> {
    26.           reference.compareAndSet(1, 3, reference.getStamp(), reference.getStamp() + 1);
    27.           System.out.println(Thread.currentThread().getName() + " ==> 修改值 1 -> 3，stamp " + reference.getStamp() + " -> " + (reference.getStamp() + 1));
    28.           reference.compareAndSet(3, 1, reference.getStamp(), reference.getStamp() + 1);
    29.           System.out.println(Thread.currentThread().getName() + " ==> 修改值 3 -> 1，stamp " + reference.getStamp() + " -> " + (reference.getStamp() + 1));
    30.       }, "B").start();
    32.   }
    33. }

    各种锁

    公平锁/非公平锁

  • 公平锁：不能够插队，必须先来后到

  • 非公平锁：可以插队（默认）

    1. public ReentrantLock(boolean fair) {
    2.   sync = fair ? new FairSync() : new NonfairSync();
    3. }

    可重入锁

    image.png

  • Synchronized 锁 ```java public class Demo1 { public static void main(String[] args) {

    1.   Phone phone = new Phone();
    2.   new Thread(() -> {
    3.       phone.sms();
    4.   }, "A").start();
    5.   new Thread(() -> {
    6.       phone.sms();
    7.   }, "B").start();

    } }

class Phone { public synchronized void sms() { System.out.println(Thread.currentThread().getName() + “ => sms”); call(); //这里也有锁 }

  1. public synchronized void call() {
  2.     try {
  3.         TimeUnit.SECONDS.sleep(2);
  4.     } catch (InterruptedException e) {
  5.         e.printStackTrace();
  6.     }
  7.     System.out.println(Thread.currentThread().getName() + " => call");
  8. }

}

  2. - lock 锁
  3. ```java
  4. public class Demo2 {
  5.     public static void main(String[] args) {
  6.         Phone2 phone = new Phone2();
  7.         new Thread(()->{
  8.             phone.sms();
  9.         },"A").start();
  10.         new Thread(()->{
  11.             phone.sms();
  12.         },"B").start();
  13.     }
  15. }
  16. class Phone2{
  18.     Lock lock=new ReentrantLock();
  20.     public void sms(){
  21.         lock.lock();         //细节：这个是两把锁，两个钥匙
  22.         //lock.lock();      lock锁必须配对，否则就会死锁在里面
  23.         try {
  24.             System.out.println(Thread.currentThread().getName()+"=> sms");
  25.             call();//这里也有一把锁
  26.         } catch (Exception e) {
  27.             e.printStackTrace();
  28.         }finally {
  29.             lock.unlock();
  30.         }
  31.     }
  32.     public void call(){
  33.         lock.lock();
  34.         try {
  35.             System.out.println(Thread.currentThread().getName() + "=> call");
  36.         }catch (Exception e){
  37.             e.printStackTrace();
  38.         }
  39.         finally {
  40.             lock.unlock();
  41.         }
  42.     }
  43. }

自旋锁

  • 底层使用的是CAS自旋锁 ```java public class TestSpinLock { public static void main(String[] args) throws InterruptedException {

    1.   //使用CAS实现自旋锁
    2.   SpinlockDemo spinlockDemo=new SpinlockDemo();
    3.   new Thread(()->{
    4.       spinlockDemo.myLock();
    5.       try {
    6.           TimeUnit.SECONDS.sleep(3);
    7.       } catch (Exception e) {
    8.           e.printStackTrace();
    9.       } finally {
    10.           spinlockDemo.myunlock();
    11.       }
    12.   },"t1").start();
    14.   TimeUnit.SECONDS.sleep(1);
  1.     new Thread(()->{
  2.         spinlockDemo.myLock();
  3.         try {
  4.             TimeUnit.SECONDS.sleep(3);
  5.         } catch (Exception e) {
  6.             e.printStackTrace();
  7.         } finally {
  8.             spinlockDemo.myunlock();
  9.         }
  10.     },"t2").start();
  11. }

}

class SpinlockDemo {

  1. //thread null
  2. AtomicReference<Thread> atomicReference=new AtomicReference<>();
  4. //加锁
  5. public void myLock(){
  6.     Thread thread = Thread.currentThread();
  7.     System.out.println(thread.getName()+"===> mylock");
  9.     //自旋锁
  10.     while (!atomicReference.compareAndSet(null,thread)){
  11.         System.out.println(Thread.currentThread().getName()+" ==> 自旋中~");
  12.     }
  13. }
  15. //解锁
  16. public void myunlock(){
  17.     Thread thread=Thread.currentThread();
  18.     System.out.println(thread.getName()+"===> myUnlock");
  19.     atomicReference.compareAndSet(thread,null);
  20. }

} ```

  • 自旋的过程可以看作是一个循环，t2进程必须等待t1进程Unlock后，才能Unlock，在这之前进行自旋等待