进程和线程的关系
（1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程是操作系统可识别的最小执行和调度单位。
（2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。 同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量。
（3）处理机分给线程，即真正在处理机上运行的是线程。
（4）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步
一个线程的生命周期:
线程是一个动态执行的过程，它也有一个从产生到死亡的过程。
- 新建状态:
使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
- 就绪状态:
当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
- 运行状态:
如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
- 阻塞状态:
如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：
等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
- 死亡状态:
一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。
线程的优先级
每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。
Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。
默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。
具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。
但是，线程优先级不能保证线程执行的顺序， 而且非常依赖于平台。
创建一个线程
Java 提供了三种创建线程的方法：
- 通过实现 Runnable 接口；
- 通过继承 Thread 类本身；
- 通过 Callable 和 Future 创建线程。
通过实现 Runnable 接口来创建线程：
创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。
为了实现 Runnable，一个类只需要执行一个方法调用 run()，
你可以重写该方法，重要的是理解的 run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。
在创建一个实现 Runnable 接口的类之后，你可以在类中实例化一个线程对象。
Thread 定义了几个构造方法，下面的这个是我们经常使用的：
这里，threadOb 是一个实现 Runnable 接口的类的实例，并且 threadName 指定新线程的名字。
新线程创建之后，你调用它的 start() 方法它才会运行。
下面是一个创建线程并开始让它执行的实例：
class RunnableDemo implements Runnable {
private Thread t;
private String threadName;
RunnableDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// 让线程睡眠一会
Thread.sleep(50);
}
}catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
RunnableDemo R1 = new RunnableDemo( "Thread-1");
R1.start();
RunnableDemo R2 = new RunnableDemo( "Thread-2");
R2.start();
}
}
运行结果:
Creating Thread-1 Starting Thread-1 Creating Thread-2 Starting Thread-2 Running Thread-1 Thread: Thread-1, 4 Running Thread-2 Thread: Thread-2, 4 Thread: Thread-1, 3 Thread: Thread-2, 3 Thread: Thread-1, 2 Thread: Thread-2, 2 Thread: Thread-1, 1 Thread: Thread-2, 1 Thread Thread-1 exiting. Thread Thread-2 exiting.
通过start( )方法启动的线程。不管R1.start( )调用的run( )方法是否执行完，都继续执行R2.start( )。如果下面有别的代码也同样不需要等待th2.start( )执行完而继续执行。
继承Thread类创建线程类：
创建一个线程的第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。
继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。
该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例。
class ThreadDemo extends Thread {
private Thread t;
private String threadName;
ThreadDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// 让线程睡眠一会
Thread.sleep(50);
}
}catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
ThreadDemo T1 = new ThreadDemo( "Thread-1");
T1.start();
ThreadDemo T2 = new ThreadDemo( "Thread-2");
T2.start();
}
}
使用ExecutorService、Callable、Future实现由返回结果的多线程：
这种方式是之前没有尝试过的，ExecutorService是一个线程池接口，可返回值的任务必须实现Callable接口，无返回值得任务必须实现Runnable接口。执行Callable任务后，可以获取一个Future对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合ExecutorService接口就可以实现有返回结果的多线程了。
- /**
- * 有返回值的线程
- */
- @SuppressWarnings("unchecked")
- class Test {
- public static void main(String[] args) throws ExecutionException,
- InterruptedException {
- System.out.println("----程序开始运行----");
- Date date1 = new Date();
- int taskSize = 5;
- // 创建一个线程池
- ExecutorService pool = Executors.newFixedThreadPool(taskSize);
- // 创建多个有返回值的任务
- List<Future> list = new ArrayList<Future>();
- for (int i = 0; i < taskSize; i++) {
- Callable c = new MyCallable(i + " ");
- // 执行任务并获取Future对象
- Future f = pool.submit(c);
- // System.out.println(">>>" + f.get().toString());
- list.add(f);
- }
- // 关闭线程池
- pool.shutdown();
- // 获取所有并发任务的运行结果
- for (Future f : list) {
- // 从Future对象上获取任务的返回值，并输出到控制台
- System.out.println(">>>" + f.get().toString());
- }
- Date date2 = new Date();
- System.out.println("----程序结束运行----，程序运行时间【"
- + (date2.getTime() - date1.getTime()) + "毫秒】");
- }
- }
- class MyCallable implements Callable<Object> {
- private String taskNum;
- MyCallable(String taskNum) {
- this.taskNum = taskNum;
- }
- public Object call() throws Exception {
- System.out.println(">>>" + taskNum + "任务启动");
- Date dateTmp1 = new Date();
- Thread.sleep(1000);
- Date dateTmp2 = new Date();
- long time = dateTmp2.getTime() - dateTmp1.getTime();
- System.out.println(">>>" + taskNum + "任务终止");
- return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
- }
- }
Thread 方法
下表列出了Thread类的一些重要方法：
| 序号 | 方法描述 |
|---|---|
| 1 | public void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 |
| 2 | public void run() 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。 |
| 3 | public final void setName(String name) 改变线程名称，使之与参数 name 相同。 |
| 4 | public final void setPriority(int priority) 更改线程的优先级。 |
| 5 | public final void setDaemon(boolean on) 将该线程标记为守护线程或用户线程。 |
| 6 | public final void join(long millisec) 等待该线程终止的时间最长为 millis 毫秒。 |
| 7 | public void interrupt() 中断线程。 |
| 8 | public final boolean isAlive() 测试线程是否处于活动状态。 |
测试线程是否处于活动状态。 上述方法是被Thread对象调用的。下面的方法是Thread类的静态方法。
| 序号 | 方法描述 |
|---|---|
| 1 | public static void yield() 暂停当前正在执行的线程对象，并执行其他线程。 |
| 2 | public static void sleep(long millisec) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。 |
| 3 | public static boolean holdsLock(Object x) 当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。 |
| 4 | public static Thread currentThread() 返回对当前正在执行的线程对象的引用。 |
| 5 | public static void dumpStack() 将当前线程的堆栈跟踪打印至标准错误流。 |
线程池
1、线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。（是什么）
2、那么，我们为什么需要用到线程池呢？每次用的时候手动创建不行吗？
在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或"切换过度"而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。（为什么）
线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快；另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。（什么用）
3、线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。
- Executors：线程池创建工厂类
- public static ExecutorServicenewFixedThreadPool(int nThreads)：返回线程池对象
- ExecutorService：线程池类
- Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行
- Future 接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
4、这里介绍两种使用线程池创建线程的方法
1）：使用Runnable接口创建线程池
使用线程池中线程对象的步骤：
- 1、创建线程池对象
- 2、创建 Runnable 接口子类对象
- 3、提交 Runnable 接口子类对象
- 4、关闭线程池
Test.java 代码如下：
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test { public static void main(String[] args) { //创建线程池对象 参数5，代表有5个线程的线程池 ExecutorService service = Executors.newFixedThreadPool(5); //创建Runnable线程任务对象 TaskRunnable task = new TaskRunnable(); //从线程池中获取线程对象 service.submit(task); System.out.println("----------------------"); //再获取一个线程对象 service.submit(task); //关闭线程池 service.shutdown(); } }
TaskRunnable.java 接口文件如下：
public class TaskRunnable implements Runnable{ @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("自定义线程任务在执行"+i); } } }
2）使用Callable接口创建线程池
Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。
ExecutorService：线程池类
<T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的 call() 方法
Future 接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
使用线程池中线程对象的步骤：
- 1、创建线程池对象
- 2、创建 Callable 接口子类对象
- 3、提交 Callable 接口子类对象
- 4、关闭线程池
Test.java 代码如下：
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test{ public static void main(String[] args) { ExecutorService service = Executors.newFixedThreadPool(3); TaskCallable c = new TaskCallable(); //线程池中获取线程对象，调用run方法 service.submit(c); //再获取一个 service.submit(c); //关闭线程池 service.shutdown(); } }
TaskCallable.java 接口文件如下：
import java.util.concurrent.Callable; public class TaskCallable implements Callable<Object>{ @Override public Object call() throws Exception { for (int i = 0; i < 1000; i++) { System.out.println("自定义线程任务在执行"+i); } return null; } }
方法:
currentThread()方法:
currentThread()方法可以返回代码段正在被哪个线程调用的信息。
|
1
2
3
4
5
|
public class Run1{
public static void main(String[] args){
System.out.println(Thread.currentThread().getName());
}
}
|
sleep()方法:
但是有一点要非常注意，sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。看下面这个例子就清楚了：
public
class
Test {
private
int
i =
10
;
private
Object object =
new
Object();
public
static
void
main(String[] args)
throws
IOException {
Test test =
new
Test();
MyThread thread1 = test.
new
MyThread();
MyThread thread2 = test.
new
MyThread();
thread1.start();
thread2.start();
}
class
MyThread
extends
Thread{
@Override
public
void
run() {
synchronized
(object) {
i++;
System.out.println(
"i:"
+i);
try
{
System.out.println(
"线程"
+Thread.currentThread().getName()+
"进入睡眠状态"
);
Thread.currentThread().sleep(
10000
);
}
catch
(InterruptedException e) {
// TODO: handle exception
}
System.out.println(
"线程"
+Thread.currentThread().getName()+
"睡眠结束"
);
i++;
System.out.println(
"i:"
+i);
}
}
}
}
输出结果：
从上面输出结果可以看出，当Thread-0进入睡眠状态之后，Thread-1并没有去执行具体的任务。只有当Thread-0执行完之后，此时Thread-0释放了对象锁，Thread-1才开始执行。
注意，如果调用了sleep方法，必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后，不一定会立即得到执行，因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态。
yield()方法：
调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。
代码：
public
class
MyThread
extends
Thread{
@Override
public
void
run() {
long
beginTime=System.currentTimeMillis();
int
count=
0
;
for
(
int
i=
0
;i<
50000000
;i++){
count=count+(i+
1
);
//Thread.yield();
}
long
endTime=System.currentTimeMillis();
System.out.println(
"用时："
+(endTime-beginTime)+
" 毫秒！"
);
}
}
public
class
Run {
public
static
void
main(String[] args) {
MyThread t=
new
MyThread();
t.start();
}
}
start()方法：
start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。
run()方法：
run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。
getId()
getId()的作用是取得线程的唯一标识
代码：
|
1
2
3
4
5
6
|
public class Test {
public static void main(String[] args) {
Thread t= Thread.currentThread();
System.out.println(t.getName()+" "+t.getId());
}
}
|
输出：
|
1
|
main 1
|
isAlive()方法
方法isAlive()的功能是判断当前线程是否处于活动状态
代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class MyThread extends Thread{
@Override
public void run() {
System.out.println("run="+this.isAlive());
}
}
public class RunTest {
public static void main(String[] args) throws InterruptedException {
MyThread myThread=new MyThread();
System.out.println("begin =="+myThread.isAlive());
myThread.start();
System.out.println("end =="+myThread.isAlive());
}
}
|
程序运行结果：
|
1
2
3
|
begin ==false
run=true
end ==false
|
方法isAlive()的作用是测试线程是否偶处于活动状态。什么是活动状态呢？活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备开始运行的状态，就认为线程是“存活”的。
有个需要注意的地方
|
1
|
System.out.println("end =="+myThread.isAlive());
|
虽然上面的实例中打印的值是true,但此值是不确定的。打印true值是因为myThread线程还未执行完毕，所以输出true。如果代码改成下面这样，加了个sleep休眠：
|
1
2
3
4
5
6
7
|
public static void main(String[] args) throws InterruptedException {
MyThread myThread=new MyThread();
System.out.println("begin =="+myThread.isAlive());
myThread.start();
Thread.sleep(1000);
System.out.println("end =="+myThread.isAlive());
}
|
则上述代码运行的结果输出为false,因为mythread对象已经在1秒之内执行完毕。
join()方法
在很多情况下，主线程创建并启动了线程，如果子线程中要进行大量耗时运算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join()方法了。方法join()的作用是等待线程对象销毁。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public class Thread4 extends Thread{
public Thread4(String name) {
super(name);
}
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(getName() + " " + i);
}
}
public static void main(String[] args) throws InterruptedException {
// 启动子进程
new Thread4("new thread").start();
for (int i = 0; i < 10; i++) {
if (i == 5) {
Thread4 th = new Thread4("joined thread");
th.start();
th.join();
}
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}
|
执行结果：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
main 0
main 1
main 2
main 3
main 4
new thread 0
new thread 1
new thread 2
new thread 3
new thread 4
joined thread 0
joined thread 1
joined thread 2
joined thread 3
joined thread 4
main 5
main 6
main 7
main 8
main 9
|
由上可以看出main主线程等待joined thread线程先执行完了才结束的。如果把th.join()这行注释掉，运行结果如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
main 0
main 1
main 2
main 3
main 4
main 5
main 6
main 7
main 8
main 9
new thread 0
new thread 1
new thread 2
new thread 3
new thread 4
joined thread 0
joined thread 1
joined thread 2
joined thread 3
joined thread 4
|
getName和setName
用来得到或者设置线程名称。
getPriority和setPriority
用来获取和设置线程优先级。
setDaemon和isDaemon
用来设置线程是否成为守护线程和判断线程是否是守护线程。
守护线程
在Java线程中有两种线程，一种是User Thread（用户线程），另一种是Daemon Thread(守护线程)。
Daemon的作用是为其他线程的运行提供服务，比如说GC线程。其实User Thread线程和Daemon Thread守护线程本质上来说去没啥区别的，唯一的区别之处就在虚拟机的离开：如果User Thread全部撤离，那么Daemon Thread也就没啥线程好服务的了，所以虚拟机也就退出了。
守护线程并非虚拟机内部可以提供，用户也可以自行的设定守护线程，方法：public final void setDaemon(boolean on) ；但是有几点需要注意：
- thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。 （备注：这点与守护进程有着明显的区别，守护进程是创建后，让进程摆脱原会话的控制+让进程摆脱原进程组的控制+让进程摆脱原控制终端的控制；所以说寄托于虚拟机的语言机制跟系统级语言有着本质上面的区别）
- 在Daemon线程中产生的新线程也是Daemon的。 （这一点又是有着本质的区别了：守护进程fork()出来的子进程不再是守护进程，尽管它把父进程的进程相关信息复制过去了，但是子进程的进程的父进程不是init进程，所谓的守护进程本质上说就是“父进程挂掉，init收养，然后文件0,1,2都是/dev/null，当前目录到/”）
- 不是所有的应用都可以分配给Daemon线程来进行服务，比如读写操作或者计算逻辑。因为在Daemon Thread还没来的及进行操作时，虚拟机可能已经退出了。
守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。
面试题
线程和进程有什么区别？
答：一个进程是一个独立(self contained)的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。
如何在Java中实现线程？
答：
创建线程有两种方式：
一、继承 Thread 类，扩展线程。
二、实现 Runnable 接口。
启动一个线程是调用run()还是start()方法？
答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM 调度并执行，这并不意味着线程就会立即运行。run()方法是线程启动后要进行回调（callback）的方法。
Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行，它们有什么区别?
答：sleep()方法（休眠）是线程类（Thread）的静态方法，调用此方法会让当前线程暂停执行指定的时间，将执行机会（CPU）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复（线程回到就绪状态，请参考第66题中的线程状态转换图）。wait()是Object类的方法，调用对象的wait()方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify()方法（或notifyAll()方法）时才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态。
线程的sleep()方法和yield()方法有什么区别？
答：
① sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会；yield()方法只会给相同优先级或更高优先级的线程以运行的机会；
② 线程执行sleep()方法后转入阻塞（blocked）状态，而执行yield()方法后转入就绪（ready）状态；
③ sleep()方法声明抛出InterruptedException，而yield()方法没有声明任何异常；
④ sleep()方法比yield()方法（跟操作系统CPU调度相关）具有更好的可移植性。
请说出与线程同步以及线程调度相关的方法。
答：
- wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁；
- sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理InterruptedException异常；
- notify()：唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且与优先级无关；
- notityAll()：唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而是让它们竞争，只有获得锁的线程才能进入就绪状态；