Java浅谈多线程

程序(program)：为完成特定任务，用某种语言编写的一组指令的集合。即指一段静态的代码。

进程(process)：程序的一次执行过程，或是正在内存中运行的应用程序。程序是静态的，进程是动态的。进程作为操作系统调度和分配资源的最小单位。

线程(thread)：进程可进一步细化为线程，是程序内部的一条执行路径。线程作为CPU调度和执行的最小单位

一、线程创建的四种方式（重点前两种）

1.线程的创建方式一：继承Thread类

Java通过继承Thread类来创建并启动多线程的步骤如下：

  • 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务
  • 创建Thread子类的实例，即创建了线程对象
  • 调用线程对象的start()方法来启动该线程

注意：

  1. 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
  2. run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
  3. 想要启动多线程，必须调用start方法。
  4. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

2. 线程的创建方式二：实现Runnable接口

步骤如下：

  • 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
  • 创建Runnable实现类的实例，并以此实例作为Thread的target参数来创建Thread对象，该Thread对象才是真正
    的线程对象。
  • 调用线程对象的start()方法，启动线程。调用Runnable接口实现类的run方法。

Thread类本身就是runnable接口的实现类，在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象,thread类中的target就会在构造器中赋值为runnable的实现类，在调用start()的时候会调用start0(),在这里会判断target是否为null,如果不为null则调用他的run()

两种方式的对比：

  • 共同点：
    - 启动线程，使用的都是Thread类中定义的start()
    - 创建的线程对象，都是Thread类或其子类的实例。

  • 不同点：一个是类的继承，一个是接口的实现。

建议使用实现Runnable接口的方式。
Runnable方式的好处：① 实现的方式，避免的类的单继承的局限性 ② 更适合处理有共享数据的问题。
③ 实现了代码和数据的分离。

3.创建多线程的方式三：实现Callable （jdk5.0新增的，先了解）

与之前的方式的对比：与Runnable方式的对比的好处：

  • call()可以有返回值，更灵活
  • call()可以使用throws的方式处理异常，更灵活
  • Callable使用了泛型参数，可以指明具体的call()的返回值类型，更灵活

4.创建多线程的方式四：使用线程池（先了解）

此方式的好处：

  • 提高了程序执行的效率。（因为线程已经提前创建好了）
  • 提高了资源的复用率。（因为执行完的线程并未销毁，而是可以继续执行其他的任务）
  • 可以设置相关的参数，对线程池中的线程的使用进行管理

二、Thread类的常用方法和构造器、线程的生命周期

1. 构造器

  • public Thread() :分配一个新的线程对象。
  • public Thread(String name) :分配一个指定名字的新的线程对象。
  • public Thread(Runnable target) :指定创建线程的目标对象，它实现了Runnable接口中的run方法
  • public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

2. 常用方法系列1

  • public void run() :此线程要执行的任务在此处定义代码。
  • public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
  • public String getName() :获取当前线程名称。
  • public void setName(String name)：设置该线程名称。
  • public static Thread currentThread() :返回对当前正在执行的线程对象的引用。在Thread子类中就是this，通常用于主线程和Runnable实现类
  • public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
  • public static void yield()：yield只是让当前线程暂停一下，让系统的线程调度器重新调度一次，希望优先级与当前线程相同或更高的其他线程能够获得执行机会，但是这个不能保证，完全有可能的情况是，当某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。

3. 常用方法系列2

  • public final boolean isAlive()：测试线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态。

  • void join() ：等待该线程终止。

    void join(long millis) ：等待该线程终止的时间最长为 millis 毫秒。如果millis时间到，将不再等待。

    void join(long millis, int nanos) ：等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。

  • public final void stop()：已过时，不建议使用。强行结束一个线程的执行，直接进入死亡状态。run()即刻停止，可能会导致一些清理性的工作得不到完成，如文件，数据库等的关闭。同时，会立即释放该线程所持有的所有的锁，导致数据得不到同步的处理，出现数据不一致的问题。

  • void suspend() / void resume() : 这两个操作就好比播放器的暂停和恢复。二者必须成对出现，否则非常容易发生死锁。suspend()调用会导致线程暂停，但不会释放任何锁资源，导致其它线程都无法访问被它占用的锁，直到调用resume()。已过时，不建议使用。

4. 常用方法系列3

每个线程都有一定的优先级，同优先级线程组成先进先出队列（先到先服务），使用分时调度策略。优先级高的线程采用抢占式策略，获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。

  • Thread类的三个优先级常量：
    • MAX_PRIORITY（10）：最高优先级
    • MIN _PRIORITY （1）：最低优先级
    • NORM_PRIORITY （5）：普通优先级，默认情况下main线程具有普通优先级。
  • public final int getPriority() ：返回线程优先级
  • public final void setPriority(int newPriority) ：改变线程的优先级，范围在[1,10]之间。

三、线程的生命周期

Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下一些状态：

3.1 JDK1.5之前：5种状态

线程的生命周期有五种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、死亡（Dead）。CPU需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。

1.新建

当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。此时它和其他Java对象一样，仅仅由JVM为其分配了内存，并初始化了实例变量的值。此时的线程对象并没有任何线程的动态特征，程序也不会执行它的线程体run()。

2.就绪

但是当线程对象调用了start()方法之后，就不一样了，线程就从新建状态转为就绪状态。JVM会为其创建方法调用栈和程序计数器，当然，处于这个状态中的线程并没有开始运行，只是表示已具备了运行的条件，随时可以被调度。至于什么时候被调度，取决于JVM里线程调度器的调度。

注意：

程序只能对新建状态的线程调用start()，并且只能调用一次，如果对非新建状态的线程，如已启动的线程或已死亡的线程调用start()都会报错IllegalThreadStateException异常。

3.运行

如果处于就绪状态的线程获得了CPU资源时，开始执行run()方法的线程体代码，则该线程处于运行状态。如果计算机只有一个CPU核心，在任何时刻只有一个线程处于运行状态，如果计算机有多个核心，将会有多个线程并行(Parallel)执行。

当然，美好的时光总是短暂的，而且CPU讲究雨露均沾。对于抢占式策略的系统而言，系统会给每个可执行的线程一个小时间段来处理任务，当该时间用完，系统会剥夺该线程所占用的资源，让其回到就绪状态等待下一次被调度。此时其他线程将获得执行机会，而在选择下一个线程时，系统会适当考虑线程的优先级。

4.阻塞

当在运行过程中的线程遇到如下情况时，会让出 CPU 并临时中止自己的执行，进入阻塞状态：

  • 线程调用了sleep()方法，主动放弃所占用的CPU资源；
  • 线程试图获取一个同步监视器，但该同步监视器正被其他线程持有；
  • 线程执行过程中，同步监视器调用了wait()，让它等待某个通知（notify）；
  • 线程执行过程中，同步监视器调用了wait(time)
  • 线程执行过程中，遇到了其他线程对象的加塞（join）；
  • 线程被调用suspend方法被挂起（已过时，因为容易发生死锁）；

当前正在执行的线程被阻塞后，其他线程就有机会执行了。针对如上情况，当发生如下情况时会解除阻塞，让该线程重新进入就绪状态，等待线程调度器再次调度它：

  • 线程的sleep()时间到；
  • 线程成功获得了同步监视器；
  • 线程等到了通知(notify)；
  • 线程wait的时间到了
  • 加塞的线程结束了；
  • 被挂起的线程又被调用了resume恢复方法（已过时，因为容易发生死锁）；

5.死亡

线程会以以下三种方式之一结束，结束后的线程就处于死亡状态：

  • run()方法执行完成，线程正常结束
  • 线程执行过程中抛出了一个未捕获的异常（Exception）或错误（Error）
  • 直接调用该线程的stop()来结束该线程（已过时）

4.2 JDK1.5及之后：6种状态

在java.lang.Thread.State的枚举类中这样定义：

public enum State {
	NEW,
	RUNNABLE,
	BLOCKED,
	WAITING,
	TIMED_WAITING,
	TERMINATED;
}

  • NEW（新建）：线程刚被创建，但是并未启动。还没调用start方法。

  • RUNNABLE（可运行）：这里没有区分就绪和运行状态。因为对于Java对象来说，只能标记为可运行，至于什么时候运行，不是JVM来控制的了，是OS来进行调度的，而且时间非常短暂，因此对于Java对象的状态来说，无法区分。

  • Teminated（被终止）：表明此线程已经结束生命周期，终止运行。

  • 重点说明，根据Thread.State的定义，阻塞状态分为三种：BLOCKED、WAITING、TIMED_WAITING。

    • BLOCKED（锁阻塞）：在API中的介绍为：一个正在阻塞、等待一个监视器锁（锁对象）的线程处于这一状态。只有获得锁对象的线程才能有执行机会。
      • 比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。
    • TIMED_WAITING（计时等待）：在API中的介绍为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。
      • 当前线程执行过程中遇到Thread类的sleep或join，Object类的wait，LockSupport类的park方法，并且在调用这些方法时，设置了时间，那么当前线程会进入TIMED_WAITING，直到时间到，或被中断。
    • WAITING（无限等待）：在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。
      • 当前线程执行过程中遇到遇到Object类的wait，Thread类的join，LockSupport类的park方法，并且在调用这些方法时，没有指定时间，那么当前线程会进入WAITING状态，直到被唤醒。
        • 通过Object类的wait进入WAITING状态的要有Object的notify/notifyAll唤醒；
        • 通过Condition的await进入WAITING状态的要有Condition的signal方法唤醒；
        • 通过LockSupport类的park方法进入WAITING状态的要有LockSupport类的unpark方法唤醒
        • 通过Thread类的join进入WAITING状态，只有调用join方法的线程对象结束才能让当前线程恢复；

说明：当从WAITING或TIMED_WAITING恢复到Runnable状态时，如果发现当前线程没有得到监视器锁，那么会立刻转入BLOCKED状态。

我们在翻阅API的时候会发现Timed Waiting（计时等待） 与 Waiting（无限等待） 状态联系还是很紧密的，
比如Waiting（无限等待） 状态中wait方法是空参的，而timed waiting（计时等待） 中wait方法是带参的。
这种带参的方法，其实是一种倒计时操作，相当于我们生活中的小闹钟，我们设定好时间，到时通知，可是
如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了，那么这种设计方案其实是一举两
得。如果没有得到（唤醒）通知，那么线程就处于Timed Waiting状态，直到倒计时完毕自动醒来；如果在倒
计时期间得到（唤醒）通知，那么线程从Timed Waiting状态立刻唤醒。

四、线程的安全问题（重难点）

当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程只有读操作，那么不会发生线程安全问题。但是如果多个线程中对资源有读和写的操作，就容易出现线程安全问题。

1.同步机制解决线程安全问题

1.1同步代码块

synchronized 关键字可以用于某个区块前面，表示只对这个区块的资源实行互斥访问。
格式:

synchronized 关键字可以用于某个区块前面，表示只对这个区块的资源实行互斥访问。
格式:

说明：

  • 需要被同步的代码，即为操作共享数据的代码。
  • 共享数据：即多个线程都需要操作的数据。比如：ticket
  • 需要被同步的代码，在被synchronized包裹以后，就使得一个线程在操作这些代码的过程中，其它线程必须等待。
  • 同步监视器,俗称锁。哪个线程获取了锁，哪个线程就能执行需要被同步的代码。
  • 同步监视器，可以使用任何一个类的对象充当。但是，多个线程必须共用同一个同步监视器。

注意：

  • 在实现Runnable接口的方式中，同步监视器可以考虑使用：this。
  • 在继承Thread类的方式中，同步监视器要慎用this，可以考虑使用：当前类.class。
1.2同步方法

synchronized 关键字直接修饰方法，表示同一时刻只有一个线程能进入这个方法，其他线程在外面等着。

public synchronized void method(){
    可能会产生线程安全问题的代码
}

说明：
如果操作共享数据的代码完整的声明在了一个方法中，那么我们就可以将此方法声明为同步方法即可。
非静态的同步方法，默认同步监视器是this
静态的同步方法，默认同步监视器是当前类本身。

synchronized好处：解决了线程的安全问题。

synchronized弊端：在操作共享数据时，多线程其实是串行执行的，意味着性能低。

2.JDK5.0新特性：Lock(锁)解决线程安全问题

创建步骤：

  • 步骤1. 创建Lock的实例，需要确保多个线程共用同一个Lock实例!需要考虑将此对象声明为static final
  • 步骤2. 执行lock()方法，锁定对共享资源的调用
  • 步骤3. unlock()的调用，释放对共享数据的锁定

synchronized与Lock的对比

  1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域、遇到异常等自动解锁
  2. Lock只有代码块锁，synchronized有代码块锁和方法锁
  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类），更体现面向对象。
  4. （了解）Lock锁可以对读不加锁，对写加锁，synchronized不可以
  5. （了解）Lock锁可以有多种获取锁的方式，可以从sleep的线程中抢到锁，synchronized不可以

说明：开发建议中处理线程安全问题优先使用顺序为：

• Lock ----> 同步代码块 ----> 同步方法

五、同步机制相关的问题

5.1单例模式设计的线程安全问题

5.1.1饿汉式

饿汉式：在类初始化时就直接创建单例对象，而类初始化过程是没有线程安全问题的

5.1.2懒汉式

当多个线程同时调用getInstance()方法来获取一个实例时，有可能造成线程安全问题。所以要进行处理。
形式一：用进程同步机制解决

package com.atguigu.single.lazy;

public class LazyOne {
    private static LazyOne instance;

    private LazyOne(){}

    //方式1：
    public static synchronized LazyOne getInstance1(){
        if(instance == null){
            instance = new LazyOne();
        }
        return instance;
    }
    //方式2：
    public static LazyOne getInstance2(){
        synchronized(LazyOne.class) {
            if (instance == null) {
                instance = new LazyOne();
            }
            return instance;
        }
    }
    //方式3：
    public static LazyOne getInstance3(){
        if(instance == null){
            synchronized (LazyOne.class) {
                try {
                    Thread.sleep(10);//加这个代码，暴露问题
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(instance == null){
                    instance = new LazyOne();
                }
            }
        }

        return instance;
    }
    /*
    注意：上述方式3中，有指令重排问题
    mem = allocate(); 为单例对象分配内存空间
    instance = mem;   instance引用现在非空，但还未初始化
    ctorSingleton(instance); 为单例对象通过instance调用构造器
    从JDK2开始，分配空间、初始化、调用构造器会在线程的工作存储区一次性完成，然后复制到主存储区。但是需要   
    volatile关键字，避免指令重排。
    */
    
}

形式二：使用内部类

package com.atguigu.single.lazy;

public class LazySingle {
    private LazySingle(){}
    
    public static LazySingle getInstance(){
        return Inner.INSTANCE;
    }
    
    private static class Inner{
        static final LazySingle INSTANCE = new LazySingle();
    }
    
}

内部类只有在外部类被调用才加载，产生INSTANCE实例；又不用加锁。
此模式具有之前两个模式的优点，同时屏蔽了它们的缺点，是最好的单例模式。
此时的内部类，使用enum进行定义，也是可以的。

5.2死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
诱发死锁的原因：

  • 互斥条件
  • 占用且等待
  • 不可抢夺（或不可抢占）
  • 循环等待

解决死锁：

死锁一旦出现，基本很难人为干预，只能尽量规避。可以考虑打破上面的诱发条件。

  • 针对条件1：互斥条件基本上无法被破坏。因为线程需要通过互斥解决安全问题。

  • 针对条件2：可以考虑一次性申请所有所需的资源，这样就不存在等待的问题。

  • 针对条件3：占用部分资源的线程在进一步申请其他资源时，如果申请不到，就主动释放掉已经占用的资源。

  • 针对条件4：可以将资源改为线性顺序。申请资源时，先申请序号较小的，这样避免循环等待问题。

以上4个条件，同时出现就会触发死锁。

六、线程的通信

当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些通信机制，可以协调它们的工作，以此实现多线程共同操作一份数据。

6.1 等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。

在一个线程满足某个条件时，就进入等待状态（wait() / wait(time)）， 等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）;或可以指定wait的时间，等时间到了自动唤醒；在有多个线程进行等待时，如果需要，可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

  1. wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态是 WAITING 或 TIMED_WAITING。它还要等着别的线程执行一个特别的动作，也即“通知（notify）”或者等待时间到，在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
  2. notify：则选取所通知对象的 wait set 中的一个线程释放；
  3. notifyAll：则释放所通知对象的 wait set 上的全部线程。

注意：

被通知的线程被唤醒后也不一定能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。

总结如下：

  • 如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE（可运行） 状态；
  • 否则，线程就从 WAITING 状态又变成 BLOCKED（等待锁） 状态

6.2 举例

例题：使用两个线程打印 1-100。线程1, 线程2 交替打印

class Communication implements Runnable {
    int i = 1;
    public void run() {
        while (true) {
            synchronized (this) {
                notify();
                if (i <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + i++);
                } else
                    break;
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

6.3 调用wait和notify需注意的细节

  1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
  2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
  3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。否则会报java.lang.IllegalMonitorStateException异常。

6.4 生产者与消费者问题

等待唤醒机制可以解决经典的“生产者与消费者”的问题。生产者与消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个（多个）共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。

生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

举例：

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

类似的场景，比如厨师和服务员等。

生产者与消费者问题中其实隐含了两个问题：

  • 线程安全问题：因为生产者与消费者共享数据缓冲区，产生安全问题。不过这个问题可以使用同步解决。
  • 线程的协调工作问题：
    • 要解决该问题，就必须让生产者线程在缓冲区满时等待(wait)，暂停进入阻塞状态，等到下次消费者消耗了缓冲区中的数据的时候，通知(notify)正在等待的线程恢复到就绪状态，重新开始往缓冲区添加数据。同样，也可以让消费者线程在缓冲区空时进入等待(wait)，暂停进入阻塞状态，等到生产者往缓冲区添加数据之后，再通知(notify)正在等待的线程恢复到就绪状态。通过这样的通信机制来解决此类问题。

代码实现：

public class ConsumerProducerTest {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Producer p1 = new Producer(clerk);
		
		Consumer c1 = new Consumer(clerk);
		Consumer c2 = new Consumer(clerk);
		
		p1.setName("生产者1");
		c1.setName("消费者1");
		c2.setName("消费者2");
		
		p1.start();
		c1.start();
		c2.start();
	}
}

//生产者
class Producer extends Thread{
	private Clerk clerk;
	
	public Producer(Clerk clerk){
		this.clerk = clerk;
	}
	
	@Override
	public void run() {
		
		System.out.println("=========生产者开始生产产品========");
		while(true){
			
			try {
				Thread.sleep(40);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			//要求clerk去增加产品
			clerk.addProduct();
		}
	}
}

//消费者
class Consumer extends Thread{
	private Clerk clerk;
	
	public Consumer(Clerk clerk){
		this.clerk = clerk;
	}
	@Override
	public void run() {
		System.out.println("=========消费者开始消费产品========");
		while(true){
			
			try {
				Thread.sleep(90);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			//要求clerk去减少产品
			clerk.minusProduct();
		}
	}
}

//资源类
class Clerk {
	private int productNum = 0;//产品数量
	private static final int MAX_PRODUCT = 20;
	private static final int MIN_PRODUCT = 1;
	
	//增加产品
	public synchronized void addProduct() {
		if(productNum < MAX_PRODUCT){
			productNum++;
			System.out.println(Thread.currentThread().getName() + 
					"生产了第" + productNum + "个产品");
			//唤醒消费者
			this.notifyAll();
		}else{
			
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	//减少产品
	public synchronized void minusProduct() {
		if(productNum >= MIN_PRODUCT){
			System.out.println(Thread.currentThread().getName() + 
					"消费了第" + productNum + "个产品");
			productNum--;
			
			//唤醒生产者
			this.notifyAll();
		}else{
			
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
}

6.5 面试题：区分sleep()和wait()

相同点：一旦执行，都会使得当前线程结束执行状态，进入阻塞状态。

不同点：

① 定义方法所属的类：sleep():Thread中定义。 wait():Object中定义

② 使用范围的不同：sleep()可以在任何需要使用的位置被调用； wait():必须使用在同步代码块或同步方法中

③ 都在同步结构中使用的时候，是否释放同步监视器的操作不同：sleep():不会释放同步监视器 ;wait():会释放同步监视器

④ 结束等待的方式不同：sleep()：指定时间一到就结束阻塞。 wait():可以指定时间也可以无限等待直到notify或notifyAll。

posted @ 2025-05-28 01:23  StephZh  阅读(26)  评论(0)    收藏  举报