对Java的多线程的理解

说说对Java线程的理解

下面是AI的回答

Java线程就是Java程序里面可以同时运行多个任务。Java提供了几种创建和管理线程的方式，其中一种是继承Thread类，另一种是实现Runnable接口或Callable接口。jdk5提供了线程池，可以更方便地创建、启动和终止线程。在多线程编程中，需要注意线程安全、死锁、线程阻塞等问题，可以使用synchronized关键字保证线程安全，使用Lock接口和Condition接口避免死锁问题，使用Thread.sleep()方法避免线程阻塞问题。

一、了解基本概念——线程、进程、程序

程序(program)：程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。
进程(process)：进程是程序的一次执行过程，或是正在运行的一个程序。
- 是一个动态的过程（有生命周期）：有它自身的产生、存在和消亡的过程。如：运行中的QQ，运行中的MP3播放器
- 一道程序可以被执行多次，也就是由一道程序可以同时出现多个进程。
- 程序是静态的，进程是动态的
- 进程作为系统资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程(thread)：进程可进一步细化为线程，是一个程序内部的一条执行路径。
- 在一个进程内，可以同时执行多条线程。（相当于一段时间内，可以有三台车同时走三条路线）
- 线程作为系统(CPU)调度和执行的单位。
- 若一个进程同一时间并行执行多个线程，就是支持多线程的。如一个软件同时打开不同的界面。
- 一个进程中的多个线程共享相同的内存单元/内存地址空间。
  - 系统分配进程的内存单元/地址空间被该进程内部的多个线程所共享。（系统不会分配内存给线程）

程序、进程、线程的关联？

三者不是包含与被包含的关系
进程是程序的运行时形态（让程序动起来）
线程是程序的执行路线（程序动起来了得知道该做什么，可以两只手干活，同时做不同是事情）

提示：程序、进程、线程是一个广泛的概念。比如：操作系统也是一道程序、桌面应用也称一道程序。和软件的概念差不多。

理解：用Java的角度

一个项目就是一个程序，一个项目的运行就是一个进程，一个项目（进程）可以有多条执行路线（线程）同时执行，
从内存的角度上看：一个进程有一片内存区域，线程没有，线程用的是进程的（多个线程共用进程的内存）（线程在进程的范围内活动，线程可以理解为进程的活动轨迹，进程可以理解为程序的活动）
一个Java应用程序java.exe进程，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
JVM本质上是一个程序。

开发体会： 我们在编写Java程序中会必须考虑程序的线程；而进程是由用户系统控制的，我们开发者控制不了，也无须考虑。

理解Java程序的进程：

Java代码是程序，但系统不能直接执行。（不能在系统上直接运行）
JVM本质上也是程序，每被系统调用执行一次，创建一道进程，在这道JVM进程内才可以执行Java代码(或叫java程序)。
换句话说，Java程序的进程本质上是JVM的进程。

JVM进程的内存分析：

内存结构：
在一个JVM进程中：每个线程拥有独立的运行栈和程序计数器(pc)，换句话说：一个JVM进程有多份栈空间和程序计数器
- 好处：线程切换的开销小
在一个JVM进程中：多个线程从同一堆中分配对象，换句话说：一个JVM进程只有一份堆空间、一份方法区
- 好处：可以访问相同的变量和对象。这就使得线程间通信更简便、高效。
- 坏处：但多个线程操作共享的系统资源可能就会带来安全的隐患。

二、Java中多线程的体现——Thread类

一个Java应用程序进程，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。线程之间相互影响。

Java语言的JVM允许程序同时运行多个线程，它通过java.lang.Thread类来体现。

java.lang.Thread：是线程的抽象表示形式。jdk文档中Thread类中就有说明：Thread是程序中的线程。

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程。

Thread类的特性：

每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
特别的，要通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
- 想要启用新的线程，必须调用该线程对象的start方法。
  1. start方法的作用：
    1. 启动当前线程
    2. 调用当前线程的run()
  2. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出异常：“IllegalThreadStateException”。
- 如果自己手动调用run()方法，那么就只是普通方法，没有启用新的线程。
- run()方法由JVM调用，什么时候调用，执行的过程控制都由操作系统的CPU调度决定。

Thread类的构造器：

Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread(Runnable target, String name)：创建新的Thread对象

理解：

一个线程在Java中体现为一个Thread类的对象
线程的执行内容就是Thread类对象的run()的执行内容
如何启动一个线程呢？
4. 调用Thread对象的start()

Thread类的常用方法：即提供了线程相关的功能操作

void start() : 启动线程，并执行对象的run()方法
void run() : 线程在被调度时执行的操作
String getName() : 返回线程的名称
void setName(String name):设置该线程名称
static Thread currentThread() : 返回当前线程。在Thread类及子类中就是this，通常用于主线程和Runnable实现类
static void yield() ：线程让步，释放当前的CPU执行权
1. 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
1. 低优先级的线程也可以获得执行
static void sleep(long millis) ： (指定时间:毫秒)
1. 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
2. 睡眠期间被中断时抛出InterruptedException异常
stop() : 强制线程生命期结束，不推荐使用。是过时的(Deprecated）
suspend()：将线程挂起。不推荐使用，容器造成死锁。是过时的(Deprecated）
resume()：搭配suspend()使用，也是过时的。不推荐使用。
boolean isAlive() ：返回boolean，判断线程是否还活着

三、创建线程的四种方式

官方API文档中说明了创建子线程的方式

JDK1.5之前创建新执行线程有两种方法：
1. 继承Thread类的方式
2. 实现Runnable接口的方式
JDK1.5新增了两者种创建新执行线程的方法：
1. 实现Callable接口
2. 使用线程池

思考： 为什么不用直接创建Thread类的对象来创建新的线程呢？

答：线程的执行，本质上就是Thread类对象里run()方法的执行，直接创建Thread类虽然创建了新的线程，但并不能让该线程执行想要的操作，失去了意义。所以我们创建Thread类的对象的同时必须想办法重写该对象的run()，将想执行的操作放进去，官方给我们提供了几种方式。

方式一：继承Thread类

步骤：

定义子类继承Thread类。
子类中重写Thread类中的run方法。（将此线程执行的操作写在run()中）
创建Thread子类对象，即创建了线程对象。
调用线程对象start方法：启动线程，调用run方法。

举例：输出100以内的偶数

//1.定义子类继承Thread类。
class MyThread extends Thread {//2.子类中重写Thread类中的run方法。@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.print(i);}}
}
public class Test {public static void main(String[] args) {//3.创建Thread子类对象，即创建了线程对象。//4.调用线程对象start方法：启动线程，调用run方法。//new MyThread().run();//行吗？不行new MyThread().start();}
}//*********************简单化**************************
class Test {public static void main(String[] args) {//创建Thread的匿名子类对象new Thread() {@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.print(i);}} }.start();}
}

方式二：实现Runnable

步骤：

定义子类，实现Runnable接口。
子类中重写Runnable接口中的run方法。
创建Runnable接口的子类的对象
通过将Runnable接口的子类对象作为实际参数传递给Thread类的含参构造器中来创建线程对象

调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

//源码中Thread类的run()是这样的。其中target是Thread类的属性：private Runnable target;
//结论：使用含参构造器创建Thread对象，传入Runnable对象时会将对象赋给target，target不为空，run()就会调用target也就是Runnable对象里的run()。
public void run() {if (target != null) {target.run();}
}

落地代码：输出100以内的偶数

//1.定义子类，实现Runnable接口。
class MyThread implements Runnable {//2.子类中重写Runnable接口中的run方法。@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.print(i);}}
}
public class Test {public static void main(String[] args) {//3。创建Runnable接口的子类的对象Runnable r = new MyThread();//4. 通过将Runnable接口的子类对象作为实际参数传递给Thread类的含参构造器中来创建线程对象//2. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。new Thread(r).start();}
}

继承方式和实现方式的联系与区别：

联系：Thread类实现了Runnable接口。

 //jdk8源码：public class Thread implements Runnable {

区别：
1. 继承Thread：线程代码存放Thread子类run方法中。
2. 实现Runnable：线程代码存在接口的子类的run方法。

实现Runnable方式的好处：（开发中推荐使用实现Runnable的方式）

避免了单继承的局限性。
1. 当一个类继承了Thread类，就不能再继承其他的类了（这是不方便的）。

多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

举例说明：

class Base extends Thread {public Base(Runnable r) {super(r);}public Base() {}@Overridepublic void run() {System.out.println("这是Base");}
}
class Sub implements Runnable {@Overridepublic void run() {System.out.println("这是Sub");}
}
class Test {public static void main(String[] args) {Runnable r = new Sub();new Base(r).start();//这是Base}
}

方式三：实现Callable接口

与使用Runnable相比，Callable功能更强大些

相比run()方法，call()可以有返回值
call()方法可以抛出异常
Callable支持泛型，call()支持泛型的返回值
需要借助FutureTask类，比如获取返回结果、创建Thread对象

Future接口

可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等操作。
FutrueTask是Futrue接口的唯一的实现类
FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

使用Callable接口创建新的线程：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;//1.创建一个实现Callable的实现类
class NumThread implements Callable {//2.重写Callable的Call方法，将此线程需要执行的操作声明在call()中@Overridepublic Object call() {//可以加throws//遍历一百以内偶数，并返回所有偶数的和int sum = 0;for (int i = 1; i <= 100; i++) {if (i % 2 == 0) {System.out.println(i);sum += i;}}return sum;}}class Test {public static void main(String[] args) {//3.创建Callable接口实现类的对象NumThread numThread = new NumThread();//4.将此Callable接口实现类的对象作为参数，调用FutureTask的含参构造器，创建FutureTask的对象。FutureTask futureTask = new FutureTask(numThread);//5.将FutureTask对象作为参数传递到Thread类的构造器中，创建Thread类的对象，调用start()：启动线程，调用call()new Thread(futureTask).start();//new Thread(numThread).start();//不行。所以Callable接口需借助FutureTask对象来创建新线程。try {//6.可以获取call()的返回值。//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值Object sum = futureTask.get();System.out.println(sum);} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}}
}

方式四：使用线程池

背景： 经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路： 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处：

提高响应速度（减少了创建新线程的时间）
降低资源消耗、提高资源的重用率（重复利用线程池中线程，不需要每次都创建）
便于线程的管理

Java中线程池由相关API体现

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor。包含一系列操作线程池的方法，

常用方法如下：
1. void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
2. <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用来执行Callable
3. void shutdown() ：关闭连接池
常见属性：
1. corePoolSize：核心池的大小
2. maximumPoolSize：最大线程数
3. keepAliveTime：线程没有任务时最多保持多长时间后会终止

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池。

常用方法如下：
1. Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
2. Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
3. Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
4. Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

线程池的使用：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;class NumThread implements Runnable {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + " : " + i);}}
}
class Num2Thread implements Callable {@Overridepublic Object call() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + " : " + i);}return null;}
}public class Test {public static void main(String[] args) {//1.使用线程池工厂类提供指定线程数量的线程池ExecutorService service = Executors.newFixedThreadPool(10);//2.调用新的线程，执行指定的线程操作。需要提供实现Runnable/Callable接口实现类的对象service.execute(new NumThread());//适用于Runnableservice.submit(new Num2Thread());//适用于Callable//3.关闭线程池service.shutdown();}
}

四、线程的调度策略

Java中线程的调度策略：CPU分配给线程的策略

同优先级线程组成先进先出队列（先到先服务），使用时间片策略

时间片策略
对高优先级的线程，使用优先调度的抢占式策略

抢占式策略：高优先级的线程抢占CPU的概率高

Java线程的优先级

线程的优先级等级
- MAX_PRIORITY：10
- MIN _PRIORITY：1
- NORM_PRIORITY：5
Thread类中涉及优先级的方法：
1. getPriority() ：返回线程优先值
2. setPriority(int newPriority) ：改变线程的优先级
说明：
1. 线程创建时继承父线程的优先级
2. 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

五、守护线程与用户线程

Java中的线程分为两类：一种是守护线程，一种是用户线程。

说明：

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
（main）主线程就是一个典型的用户线程。新建的Thread类对象默认是用户线程。
守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程
Java垃圾回收就是一个典型的守护线程。
若JVM中都是守护线程，当前JVM将退出。形象理解：兔死狗烹，鸟尽弓藏

六、线程的生命周期

JDK中用Thread.State类（Thread的内部枚举类）定义了线程的六种状态： NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED

分析理解：要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪： 处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行： 当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞： 在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡： 线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

图解：

在这里插入图片描述

备注：

阻塞只是临时状态，并不是最终状态。
死亡是最终状态。

七、线程的同步机制

同步：多线程在排队执行使用同一资源。
异步：多线程各干各的，使用不同资源。

多线程的安全问题：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

对于多条操作共享数据的语句：只能让一个线程都执行完，在执行过程中（即使该线程被阻塞），其他线程都不可以参与执行。Java对于多线程的安全问题提供了专业的解决方式：同步机制

1. synchronized

语法如下：

同步代码块：操作需要被同步的代码。

synchronized (同步监视器){ //同步监视器自己指定：任意对象。// 需要被同步的代码；（即操作共享数据的代码）
}

例如：

class W implements Runnable {private int ticket = 100;public void run() {synchronized (this) {while (ticket > 0) {System.out.println(currentThread().getName() + "卖票：" + ticket--);}  }}
}

synchronized还可以放在方法声明中，表示整个方法为同步方法。

public synchronized void show() { ... } //发现没有设置同步监视器的地方？同步方法使用的是默认的同步监视器

同步机制的使用说明（总结：注意两点：同步监视器(锁) 、共享数据）

synchronized的锁(同步监视器)是什么？ 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。

同步方法的锁，是固定的：一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this）
- 静态方法的是：当前类对象：当前类名.class
- 非静态方法的是：当前对象：this
同步代码块的锁：自己指定，开发中很多时候也指定为this或类名.class（类对象）。

锁的使用注意点：必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全。

理解：当一个线程A要想进入同步代码中，得先获得该同步代码的锁。只有一把锁时，能保证一个线程在拥有锁并执行的时候，另外的线程得不到锁直到该线程释放锁。若有多把锁时，同样会造成多个线程同时执行语句造成线程安全问题。

class W extends Thread {private int ticket = 100;public void run() {//synchronized(this) {//此时，多个线程并没有共用一把锁，因为每造一个线程，就新建了一个对象synchronized(W.class) {//此时，能保证多个线程用一把锁，类对象是唯一的！...}}
}
class Test {public static void main(String[] args) {new W().start();new W().start();}
}

因为同步时被锁住的资源只能被一个线程使用，缺点就是操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程。所以在使用同步锁的时候需要尽量注意这些问题：

同步的范围：要锁住所有安全问题的代码，尽量避免圈住没有安全问题的代码。
释放锁的情形有：
1. 当前线程的同步方法、同步代码块执行结束。
2. 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
4. 当前线程在同步代码块、同步方法中执行了线程对象的wait() 方法，当前线程暂停，并释放锁。
注意以下操作不会释放锁：
1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。（应尽量避免使用suspend()和resume()来控制线程）

死锁问题

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
要避免死锁。死锁举例代码如下：

public class DeadLockTest {public static void main(String[] args) {final StringBuffer s1 = new StringBuffer();final StringBuffer s2 = new StringBuffer();new Thread() {public void run() {synchronized (s1) {s2.append("A");//极大增加死锁概率：// try {//     Thread.sleep(1000);// } catch (Exception e) {//     e.printStackTrace();// }synchronized (s2) {s2.append("B");System.out.print(s1);System.out.print(s2);} }}}.start();new Thread() {public void run() {synchronized (s2) {s2.append("C");//极大增加死锁概率：// try {//     Thread.sleep(1000);// } catch (Exception e) {//     e.printStackTrace();// }synchronized (s1) {s1.append("D");System.out.print(s2);System.out.print(s1);} }}}.start();}
}
/**
运行结果？
两种情况：
1.ABABCD
2.死锁
*/

2. Lock接口（jdk5新增）

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁可以使用Lock对象充当。
- Lock就没有同步监视器的概念了。Lock的实现类的对象充当锁。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。 锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式地加锁、释放锁

使用：

  class A{private final ReentrantLock lock = new ReenTrantLock();public void m(){lock.lock();//保证线程安全的代码; unlock();}}//注意：如果同步代码有异常，要将unlock()写入finally语句块:lock.lock();try{//保证线程安全的代码; }finally{lock.unlock(); }

举例：

  class Window extends Thread {private static ticket = 100;private static ReentrantLock lock = new ReenTrantLock();//注意：可以为非static吗？在这里不可以，Lock对象充当同步锁，多线程共享统一资源要保证锁的唯一。public void run() {lock.lock();while (ticket > 0) {System.out.println(currentThread().getName() + "卖票：" + ticket--);}lock.unlock();}}

synchronized与Lock的对比

Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

开发体会：

优先使用顺序（性能从大到小）： Lock —> 同步代码块（已经进入了方法体，分配了相应资源）—> 同步方法（在方法体之外）

ReentrantLock的使用

构造器：
1. ReentrantLock()
2. ReentrantLock(Boolean fair) ：如果传参为true：例如线程A、B、C在锁前排队时，如果让A进去了，跑完之后A再回来排队，会让B和C先跑。
…

八、wait()、notify()、notifyAll()

线程之间的通信表现为wait()与notify()和notifyAll() 的使用。

wait() ：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源(当前线程会释放锁)，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后该线程才会重新进入就绪状态，等待CPU时间的分配。
notify() ：唤醒正在排队等待同步资源的线程中优先级最高者结束等待。（只能唤醒一个wait()中的线程）
notifyAll () ：唤醒正在排队等待资源的所有线程结束等待。（唤醒所有wait()中的线程）

使用说明：

这三个方法只有在synchronized方法或synchronized代码块中才能使用（也不能用在使用Lock对象的同步代码中），否则会报java.lang.IllegalMonitorStateException异常。
需要注意的是，如果一个线程调用了对象的wait()方法，那么该线程必须先获得该对象的锁才能进入等待状态。如果没有获得该对象的锁，那么会抛出IllegalMonitorStateException异常。此外，如果当前线程被中断，那么会抛出InterruptedException异常。（就是该线程要获得该对象的锁才能执行wait()，然后释放锁）
wait()方法和notify()方法必须在同一个对象上调用，这是因为它们是关联的。如果一个线程调用了对象的wait()方法，那么其他线程必须调用同一对象的notify()方法或notifyAll()方法才能唤醒该线程。
这三个方法的调用者必须是synchronized方法或synchronized代码块中的同步监视器。否则报异常。
这三个方法是声明在java.lang.Object类中的。

因为这三个方法必须由锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。

sleep()和wait()的异同？

同：一旦执行方法，都可以使得当前的线程进入阻塞状态。
异：
1. 两个方法声明的位置不同：Thread类中的声明sleep()，Object类中声明wait()
2. 调用的要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在synchronized方法或synchronized代码块中。
3. 关于是否释放同步监视器：如果两个方法都使用在同步代码中，sleep()不会释放同步监视器，而wait()会释放同步监视器。