wait 和 sleep 的区别

两个方法：Object 中定义的wait方法和Thread类中定义的sleep方法的区别？
相同之处：都可能让线程从Runnble状态进入Timed-Waiting状态

wait sleep
定义在Object类 定义在Thread类
必须要先持有锁，并且会释放锁 不释放锁
改变线程状态为：WAITING 或 TIMED_WAITING 改变线程状态为：TIMED_WAITING
放在同步代码块中才可以wait，并且是在锁对象上调用wait方法 代码位置没有限制，在线程类上调用sleep方法
状态从WAITING 可能变会 RUNNABLE，但也可能变为BLOCKED，取决于有没有拿到锁 状态直接变回RUNNABLE，跟锁无关

如果当前线程没持有锁，而直接在锁对象上调用wait方法，会抛出如下异常
image.png
但是，如果直接调用Thread.sleep方法，是不会有异常的。

  2. /**
  3.  * wait 和 sleep 的区别
  4.  *
  5.  */
  6. public class Demo3 {
  8.     public static void main(String[] args) throws InterruptedException {
  10.         // sleep 没有代码位置的限制
  11.         Thread.sleep(1000);
  13.         // 创建一个对象，并且这个对象就是一把锁
  14.         Object lock = new Object();
  16. //        lock.wait(); //Exception in thread "main" java.lang.IllegalMonitorStateException
  18.         synchronized (lock){ // main 线程去申请锁，锁是lock对象
  20.             // 创建一个线程 ， 申请获取同一把锁
  21.             new Thread(new Runnable() {
  22.                 @Override
  23.                 public void run() {
  24.                     // 等待一秒钟，在申请锁
  25.                     try {
  26.                         TimeUnit.SECONDS.sleep(1);
  27.                     } catch (InterruptedException e) {
  28.                         e.printStackTrace();
  29.                     }
  30.                     synchronized (lock){
  31.                         // 模拟业务处理
  32.                         System.out.println(Thread.currentThread().getName()+"：获取到了锁");
  33.                         // 唤醒所有在该锁上wait的线程
  34.                         lock.notifyAll();
  35.                     }
  36.                 }
  37.             },"A").start();
  40.             // 做一些业务处理
  41.             System.out.println(Thread.currentThread().getName()+":获取到到了锁");
  42.             // 做完本线程的任务之后，想要释放锁，让其他线程有机会那到这个锁，就可以wait
  43.             lock.wait(); // 线程会进入WAITING 状态
  44.             System.out.println(Thread.currentThread().getName()+":运行结束");
  45.         }
  47.     }
  49. }

synchronize 关键字

作用：如果某个线程想要进入synchronize关键字修饰的代码块或者方法，那么该线程必须要先抢到synchronize关键字对应的那把锁。相当于同一时刻，加了synchronize关键字的代码块或者方法，只能由一个线程进行执行。

使用场景 锁是什么
修饰代码块 代码中显式指定一个锁对象
修饰实例方法 锁是实例对象 this
修饰静态方法 锁是一个Class对象（类名.class）

修饰代码块的语法：

  1.         //  同步代码块 ， 同一时间只允许一个线程进入同步代码块 
  2.         synchronized (锁对象){
  4.         }

错误代码示范：

  1. public class SyncDemo01 {
  3.     public void test1(){
  5.         synchronized (new Object()){
  6.             for (int i=0;i<20;i++) {
  7.                 System.out.println(Thread.currentThread().getName()+":"+i);
  8.             }
  9.         }
  11.     }
  13.     public static void main(String[] args) {
  14.         final SyncDemo01 syncDemo01 = new SyncDemo01();
  16.         final Thread threadA = new Thread(() -> syncDemo01.test1(),"A");
  17.         final Thread threadB = new Thread(() -> syncDemo01.test1(),"B");
  19.         threadA.start();
  20.         threadB.start();
  21.     }
  23. }
  1.     /**
  2.      * 当使用 synchronized 修饰实例方法时， 锁是什么？ 锁就是this对象
  3.      */
  4.     public synchronized void test1(){
  6.     }
  1.     public synchronized static void test2(){
  3.     }
  1. package com.qf.thread;
  3. public class SyncDemo01 {
  5.     public Object lock = new Object();
  7.     public void test1(){
  8.         synchronized (SyncDemo01.class){
  9.             for (int i=0;i<20;i++) {
  10.                 System.out.println(Thread.currentThread().getName()+":"+i);
  11.             }
  12.         }
  14.     }
  16.     // 锁对象是什么呢？ this
  17.     public synchronized void test2(){
  18.         for (int i=0;i<20;i++) {
  19.             System.out.println(Thread.currentThread().getName()+":"+i);
  20.         }
  21.     }
  24.     // synchronized 修饰静态方法，锁是什么呢？ 是当前类的class对象
  25.     // final Class<SyncDemo01> syncDemo01Class = SyncDemo01.class;
  26.     // SyncDemo01.class是不是单例？ 是的 。 当jvm类加载器加载SyncDemo01的时候，自动创建了该class对象，并且是单例
  28.     public synchronized static void test3(){
  29.         for (int i=0;i<20;i++) {
  30.             System.out.println(Thread.currentThread().getName()+":"+i);
  31.         }
  32.     }
  36.     public static void main(String[] args) {
  37.         final SyncDemo01 o1 = new SyncDemo01();
  38.         final Thread threadA = new Thread(() -> o1.test1(),"A");
  39.         final Thread threadB = new Thread(() -> o1.test3(),"B");
  40.         threadA.start();
  41.         threadB.start();
  42.     }
  46.     public static void p2(){
  47.         final SyncDemo01 o1 = new SyncDemo01();
  48.         final Thread threadA = new Thread(() -> o1.test1(),"A");
  50.         final Thread threadB = new Thread(() -> o1.test2(),"B");
  51.         threadA.start();
  52.         threadB.start();
  53.     }
  56.     public static void p1(){
  57.         final SyncDemo01 o1 = new SyncDemo01();
  58.         final SyncDemo01 o2 = new SyncDemo01();
  60.         final Thread threadA = new Thread(() -> o1.test1(),"A");
  61.         final Thread threadB = new Thread(() -> o2.test1(),"B");
  63.         threadA.start();
  64.         threadB.start();
  65.     }
  67. }

思考案例：
开启两个线程，执行实例方法m，方法m为循环打印1-20个数字。在不开启同步的情况下，会是什么效果？
如果开启synchronized同步，会是什么效果？
注意：同步的原则，必须在相同的锁对象上进行同步！

思考：使用同步代码块还是使用同步方法呢？

  1. package com.qf.sy2103.thread02;
  3. /**
  4.  * 思考：使用同步代码块还是使用同步方法呢？
  5.  * 推荐用法：尽可能减少同步代码的范围。在必须要进行同步的地方使用 代码块方式开启同步。
  6.  */
  7. public class ThreadDemoChoose {
  10.     public void test1(String path){
  12.         //1. 读取指定 path的文件 ，并把文件的内容读取出来进行分析
  14.         //2. 把分析的结果写入到某个指定的文件中
  15.         synchronized (this){
  17.         }
  19.     }
  21. }

思考：持有锁的线程如果出现异常，锁是否会被释放？(练习)

  1. /**
  2.  * synchronize 到底锁的是什么
  3.  * synchronized 代表的语义是开启一段同步代码块
  4.  * 同步代码块：一个特殊的代码块，只能有一个线程进入到同步代码块中，其他线程进不来
  5.  * 为什么线程能进入同步代码块呢？ 能进入的线程，一定是申请到了可以进入同步代码块的锁
  6.  * 锁是什么？  一个java对象，可以是锁。 类.class ，Demo4.class 可以是一把锁。
  7.  */
  8. package com.qf.sy2103.thread02;
  10. import lombok.SneakyThrows;
  12. public class SynchronizedDemo {
  14.     public static void test3(){
  15.         System.out.println("test3 stated..");
  17.         synchronized (SynchronizedDemo.class){  //  可以使用 当前实例对象 （this）
  18.             for (int i = 0; i < 100; i++) {
  19.                 System.out.println(Thread.currentThread().getName() +":" + i);
  20.             }
  21.         }
  22.     }
  25.     /**
  26.      * 锁是什么 ？ 类名.class
  27.      * 当类 SynchronizedDemo 被jvm 加载之后，会在堆内存中创建一个对象，这个对象就是 SynchronizedDemo.class
  28.      * 是一个 类型为 Class<SynchronizedDemo> 的对象
  29.      */
  30.     public synchronized static void test2(){
  31.         System.out.println("test2 start..");
  32.         for (int i = 0; i < 100; i++) {
  33.             System.out.println(Thread.currentThread().getName() +":" + i);
  34.         }
  35.     }
  40.     public void test0() throws InterruptedException {
  42. //        final Object lock = new Object();
  44.         System.out.println("test0 stated..");
  46.         synchronized (this){  //  可以使用 当前实例对象 （this）
  47.             for (int i = 0; i < 100; i++) {
  48.                 System.out.println(Thread.currentThread().getName() +":" + i);
  49.             }
  50.         }
  52.     }
  54.     /**
  55.      * 当使用 synchronized 修饰实例方法时， 锁是什么？ 锁就是this对象
  56.      */
  57.     public synchronized void test1(){
  58.         System.out.println("test1 start..");
  59.         for (int i = 0; i < 100; i++) {
  60.             System.out.println(Thread.currentThread().getName() +":" + i);
  61.         }
  63.     }
  66.     public static void main(String[] args) {
  68. //        p1();
  70. //        p2();
  72.         final Thread t1 = new Thread(new Runnable() {
  73.             @Override
  74.             public void run() {
  75.                 SynchronizedDemo.test2();
  76.             }
  77.         });
  79.         final Thread t2 = new Thread(new Runnable() {
  80.             @Override
  81.             public void run() {
  82.                 SynchronizedDemo.test3();
  83.             }
  84.         });
  86.         t1.setName("t1");
  87.         t2.setName("t2");
  88.         t1.start();
  89.         t2.start();
  91.     }
  93.     private static void p2() {
  94.         final Thread t1 = new Thread(new Runnable() {
  95.             @Override
  96.             public void run() {
  97.                 SynchronizedDemo.test2();
  98.             }
  99.         });
  101.         final Thread t2 = new Thread(new Runnable() {
  102.             @Override
  103.             public void run() {
  104.                 SynchronizedDemo.test2();
  105.             }
  106.         });
  108.         t1.setName("t1");
  109.         t2.setName("t2");
  110.         t1.start();
  111.         t2.start();
  112.     }
  114.     public static void p1(){
  115.         final SynchronizedDemo demo = new SynchronizedDemo();
  117.         final Thread t1 = new Thread(new Runnable() {
  118.             @SneakyThrows
  119.             @Override
  120.             public void run() {
  121.                 demo.test0();
  122.             }
  123.         },"t1");
  125.         final Thread t2 = new Thread(new Runnable() {
  126.             @Override
  127.             public void run() {
  128.                 demo.test1();
  129.             }
  130.         },"t2");
  132.         t1.start();
  133.         t2.start();
  134.     }
  136. }
  1. package com.qf.sy2103.thread02;
  3. /**
  4.  * 如下代码能否成功同步
  5.  */
  6. public class SynchronizedDemo2 {
  9.     public synchronized void test1(){
  10.         System.out.println("test1 started...");
  11.         for (int i = 0; i < 100; i++) {
  12.             System.out.println(Thread.currentThread().getName()+":"+i);
  13.         }
  14.     }
  16.     public synchronized void test2(){
  17.         System.out.println("test2 started...");
  18.         for (int i = 0; i < 100; i++) {
  19.             System.out.println(Thread.currentThread().getName()+":"+i);
  20.         }
  21.     }
  25.     public static void main(String[] args) {
  27.         final SynchronizedDemo2 d1 = new SynchronizedDemo2();
  29.         final SynchronizedDemo2 d2 = new SynchronizedDemo2();
  31.         final Thread t1 = new Thread(new Runnable() {
  32.             @Override
  33.             public void run() {
  34.                 d1.test1();
  35.             }
  36.         });
  38.         final Thread t2 = new Thread(new Runnable() {
  39.             @Override
  40.             public void run() {
  41.                 d2.test2();
  42.             }
  43.         });
  45.         t1.start();
  46.         t2.start();
  48.     }
  49. }
  1. package com.qf.sy2103.thread02;
  3. /**
  4.  * 如下代码能否成功同步
  5.  */
  6. public class SynchronizedDemo2 {
  9.     public synchronized void test1(){
  10.         System.out.println("test1 started...");
  11.         for (int i = 0; i < 100; i++) {
  12.             System.out.println(Thread.currentThread().getName()+":"+i);
  13.         }
  14.     }
  16.     public synchronized void test2(){
  17.         System.out.println("test2 started...");
  18.         for (int i = 0; i < 100; i++) {
  19.             System.out.println(Thread.currentThread().getName()+":"+i);
  20.         }
  21.     }
  23.     public synchronized static void test3(){
  24.         System.out.println("test3 started...");
  25.         for (int i = 0; i < 100; i++) {
  26.             System.out.println(Thread.currentThread().getName()+":"+i);
  27.         }
  28.     }
  32.     public static void main(String[] args) {
  34.         final SynchronizedDemo2 d1 = new SynchronizedDemo2();
  36.         final SynchronizedDemo2 d2 = new SynchronizedDemo2();
  38.         final Thread t1 = new Thread(new Runnable() {
  39.             @Override
  40.             public void run() {
  41.                 d1.test3();
  42.             }
  43.         });
  45.         final Thread t2 = new Thread(new Runnable() {
  46.             @Override
  47.             public void run() {
  48.                 d2.test3();
  49.             }
  50.         });
  52.         t1.start();
  53.         t2.start();
  55.     }
  56. }