一、前言
线程间的协作方法主要有:wait、notify、notifyAll、sleep、yield、join,本文首先介绍下线程的状态有哪些,然后解释下各个方法的含义以及作用,最后从底层原理解释下它们之间的区别。
二、正文
1.线程的状态
Java中线程中状态可分为六种:
-
初始(NEW):新创建了一个线程对象,但还没有调用start()方法。
-
运行(RUNNABLE):Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“运行”。
线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法,线程进入就绪状态,等待CPU资源,此时处于就绪状态(ready)。
就绪状态的线程在获得CPU时间片后变为运行中状态(running)。
-
阻塞(BLOCKED):表示线程被阻塞,可能正在尝试进入
synchronized
关键字修饰的同步代码块、方法,等待获取监视器锁(monitor )。
-
等待(WAITING):通常调用Object.wait()会进入该状态,直到其他线程调用
Object.notify()
或Object.notifyAll()
才会唤醒。 -
超时等待(TIMED_WAITING):有限时间的等待状态,通常调用
Object.wait(long timeout)
或Object.wait(long timeout, int nanos)
会进入该状态,与等待状态类似,区别就是时间到了之后如果没有被Object.notify()
或Object.notifyAll()
唤醒的话会自动唤醒。 -
终止(TERMINATED):表示该线程已经执行完毕。
线程状态图如下:
2.状态详细说明
(1)初始状态(NEW)
实现Runnable接口和继承Thread可以得到一个线程类,new一个实例出来,线程就进入了初始状态。
(2)就绪状态(RUNNABLE之READY)
- 就绪状态只是说你有资格运行,调度程序(Cpu)没有挑选到你,你就永远是就绪状态。
- 调用线程的start()方法,此线程进入就绪状态。
- 当前线程sleep()方法结束,其他线程join()结束,等待用户输入完毕,某个线程拿到对象锁,这些线程也将进入就绪状态。
- 当前线程时间片用完了,调用当前线程的yield()方法,当前线程进入就绪状态。
- 锁池里的线程拿到对象锁后,进入就绪状态。
(3)运行中状态(RUNNABLE之RUNNING)
就绪状态的线程获取到CPU时间片后,进入运行状态。
(4)阻塞状态(BLOCKED)
阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。
(5)等待(WAITING)
处于这种状态的线程不会被分配CPU执行时间,它们要等待被显式地唤醒,否则会处于无限期等待的状态。
(6)超时等待(TIMED_WAITING)
处于这种状态的线程不会被分配CPU执行时间,不过无须无限期等待被其他线程显示地唤醒,在达到一定时间后它们会自动唤醒。
(7)终止状态(TERMINATED)
- 当线程的run()方法完成时,或者主线程的main()方法完成时,我们就认为它终止了。这个线程对象也许是活的,但是它已经不是一个单独执行的线程。线程一旦终止了,就不能复生。
- 在一个终止的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常。
3.线程的协作方法
1.wait、notify、notifyAll这三个方法属于Object类。
2.sleep、yield、join这三个方法属于Thread类。
问:wait、notify、notifyAll这三个方法作用是实现线程间协作,但是为什么不属于Thread类,而是属于Object类?
(1)我们首先要知道,Java所有的类都继承自Object类。
(2)我们要知道wait方法的底层实现原理,wait实际是等待对象的monitor,由于Java中的每一个对象都有一个内置的monitor对象,自然所有的类都理应有wait/notify方法。
3.1wait、notify、notifyAll方法的使用
wait、notify、notifyAll这三个方法属于Object类。
1.wait方法
JDK中一共提供了这三个版本的方法,
(1)wait()方法的作用是将当前运行的线程挂起(即让其进入阻塞状态),直到notify或notifyAll方法来唤醒线程。
(2)wait(long timeout),该方法与wait()方法类似,唯一的区别就是在指定时间内,如果没有notify或notifAll方法的唤醒,也会自动唤醒。
(3)至于wait(long timeout,long nanos),本意在于更精确的控制调度时间,不过从目前版本来看,该方法貌似没有完整的实现该功能,其源码(JDK1.8)如下:
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos > 0) {
timeout++;
}
wait(timeout);
}
从源码来看,JDK8中对纳秒的处理,只做了四舍五入,所以还是按照毫秒来处理的,可能在未来的某个时间点会用到纳秒级别的精度。虽然JDK提供了这三个版本,其实最后都是调用wait(long timeout)方法来实现的,wait()方法与wait(0)等效,而wait(long timeout,int nanos)从上面的源码可以看到也是通过wait(long timeout)来完成的。
下面我们通过一个栗子来看下wait()的用法:
public class ThreadTest {
public static void main(String[] args) {
Object object = new Object();
new Thread(new Runnable() {
@Override
public void run() {
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
直接执行,我们将会得到以下异常:
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:502)
at com.xiangyu.demo.ThreadTest$1.run(ThreadTest.java:10)
at java.lang.Thread.run(Thread.java:748)
出错的代码在:object.wait();
。这里我们需要了解以下事实:
- 无论是执行对象的 wait、notify 还是 notifyAll 方法,必须保证当前运行的线程取得了该对象的控制权(monitor)
- 如果在没有控制权的线程里执行对象的以上三种方法,就会报 java.lang.IllegalMonitorStateException 异常。
- JVM 基于多线程,默认情况下不能保证运行时线程的时序性
在上面的示例代码中,我们 new 了一个 Thread,但是对象 object 的控制权仍在主线程里。所以会报 java.lang.IllegalMonitorStateException 。
我们可以通过同步锁来获得对象控制权,例如:synchronized 代码块。对以上的示例代码做改造:
public class ThreadTest {
public static void main(String[] args) {
Object object = new Object();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (object){ // 修改处
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}
再次执行,代码不再报错。
我们可以得到以下结论:
- 调用对象的
wait()
和notify()
方法,需要先取得对象的控制权 - 可以使用
synchronized (object)
来取得对于 object 对象的控制权 - 在 Java 中任何一个时刻,对象的控制权只能被一个线程拥有
2.notify、notifyAll方法
这两个方法均为 native 方法,在JDK 1.8 中的关于notify()
的JavaDoc如下:
Wakes up a single thread that is waiting on this object’s monitor. If any threads are waiting on this object, one of them is chosen to be awakened.
译为:
唤醒此 object 控制权下的一个处于 wait 状态的线程。若有多个线程处于此 object 控制权下的 wait 状态,只有一个会被唤醒。
也就是说,如果有多个线程在 wait 状态,我们并不知道哪个线程会被唤醒。
在JDK 1.8 中的关于notifyAll()
的JavaDoc如下:
Wakes up all threads that are waiting on this object’s monitor.
译为:
唤醒所有处于此 object 控制权下的 wait 状态的线程。
有了对wait方法原理的理解,notify方法和notifyAll方法就很容易理解了。既然wait方式是通过对象的monitor对象来实现的,所以只要在同一对象上去调用notify/notifyAll方法,就可以唤醒对应对象monitor上等待的线程了。notify和notifyAll的区别在于前者只能唤醒monitor上的一个线程,对其他线程没有影响,而notifyAll则唤醒所有的线程。
下面我们通过一个题来更好的理解wait和notify是如何应用的:
启动两个线程, 一个输出 1,3,5,7…99, 另一个输出 2,4,6,8…100 最后 STDOUT 中按序输出 1,2,3,4,5…100
题目要求用 Java 的 wait + notify 机制来实现,重点考察对于多线程可见性的理解。下面给出此题的解法:
public class ThreadTest {
private final Object flag = new Object();
public static void main(String[] args) {
ThreadTest threadTest = new ThreadTest();
ThreadA threadA = threadTest.new ThreadA();
threadA.start();
ThreadB threadB = threadTest.new ThreadB();
threadB.start();
}
class ThreadA extends Thread {
@Override
public void run() {
synchronized (flag) {
for (int i = 1; i <= 100; i += 2) {
flag.notify();
System.out.println(i); // 奇数
try {
flag.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class ThreadB extends Thread {
@Override
public void run() {
synchronized (flag) {
for (int i = 2; i <= 100; i += 2) {
flag.notify();
System.out.println(i); // 偶数
if (i == 100) {
// 当输出了最后一个数字的时候,不能再wait了
break;
}
try {
flag.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
通过运行,可以看到输出结果是:1,2,3,4,5…100,符合题目的要求。
3.2 sleep、yield、join方法解析
sleep、yield、join这三个方法属于Thread类。
1.sleep
sleep方法的作用是让当前线程暂停指定的时间(毫秒),sleep方法是最简单的方法,在上述的例子中也用到过,比较容易理解。唯一需要注意的是其与wait方法的区别。最简单的区别是,wait方法依赖于同步,而sleep方法可以直接调用。而更深层次的区别在于sleep方法只是暂时让出CPU的执行权,并不释放锁。而wait方法则需要释放锁。
下面来看一个栗子:
public class SleepTest {
public synchronized void sleepMethod() {
System.out.println("Sleep start---------");
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Sleep end---------");
}
public synchronized void waitMethod() {
System.out.println("Wait start---------");
try {
wait(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Wait end---------");
}
public static void main(String[] args) {
SleepTest sleepTest1 = new SleepTest();
for (int i = 0; i < 3; i++) {
new Thread(new Runnable() {
@Override
public void run() {
sleepTest1.sleepMethod();
}
}).start();
}
try {
// 暂停10s,等待上面线程运行完
Thread.sleep(10000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("-------分割线--------");
SleepTest sleepTest2 = new SleepTest();
for (int i = 0; i < 3; i++) {
new Thread(new Runnable() {
@Override
public void run() {
sleepTest2.waitMethod();
}
}).start();
}
}
}
输出结果如下:
Sleep start---------
Sleep end---------
Sleep start---------
Sleep end---------
Sleep start---------
Sleep end---------
-------分割线--------
Wait start---------
Wait start---------
Wait start---------
Wait end---------
Wait end---------
Wait end---------
这个结果的区别很明显,通过sleep方法实现的暂停,程序是顺序进入同步块的,只有当上一个线程执行完成的时候,下一个线程才能进入同步方法,sleep暂停期间一直持有monitor对象锁,其他线程是不能进入的。而wait方法则不同,当调用wait方法后,当前线程会释放持有的monitor对象锁,因此,其他线程还可以进入到同步方法,线程被唤醒后,需要竞争锁,获取到锁之后再继续执行。
2、yield方法
yield方法的作用是暂停当前线程,以便其他线程有机会执行,不过不能指定暂停的时间,并且也不能保证当前线程马上停止。yield方法只是将Running状态转变为Runnable状态。我们还是通过一个栗子来看下:
public class YieldTest implements Runnable {
@Override
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName() + ": " + i);
Thread.yield();
}
}
public static void main(String[] args) {
YieldTest runn = new YieldTest();
Thread t1 = new Thread(runn,"FirstThread");
Thread t2 = new Thread(runn,"SecondThread");
t1.start();
t2.start();
}
}
输出结果如下:
FirstThread: 0
SecondThread: 0
FirstThread: 1
SecondThread: 1
FirstThread: 2
SecondThread: 2
FirstThread: 3
SecondThread: 3
FirstThread: 4
SecondThread: 4
这个例子就是通过yield方法来实现两个线程的交替执行。不过请注意:这种交替并不一定能得到保证,源码中也对这个问题进行说明。
3、join方法
join方法的作用是父线程等待子线程执行完成后再执行,换句话说就是将异步执行的线程合并为同步的线程。JDK中提供三个版本的join方法,其实现与wait方法类似,join()方法实际上执行的join(0),而join(long millis, int nanos)也与wait(long millis, int nanos)的实现方式一致,暂时对纳秒的支持也是不完整的。我们可以看下join方法的源码,这样更容易理解:
public final void join() throws InterruptedException {
join(0);
}
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
public final synchronized void join(long millis, int nanos)
throws InterruptedException {
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
join(millis);
}
大家重点关注一下join(long millis)方法的实现,可以看出join方法就是通过wait方法来将线程的阻塞,如果join的线程还在执行,则将当前线程阻塞起来,直到join的线程执行完成,当前线程才能执行。不过有一点需要注意,这里的join只调用了wait方法,却没有对应的notify方法,原因是Thread的start方法中做了相应的处理,所以当join的线程执行完成以后,会自动唤醒主线程继续往下执行。下面我们通过一个例子来演示join方法的作用:
(1)不使用join方法:
public class JoinTest implements Runnable{
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + " start-----");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " end------");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
for (int i=0;i<5;i++) {
Thread test = new Thread(new JoinTest());
test.start();
}
System.out.println("Finished~~~");
}
}
输出结果如下:
Finished~~~
Thread-0 start-----
Thread-1 start-----
Thread-2 start-----
Thread-4 start-----
Thread-3 start-----
Thread-0 end------
Thread-1 end------
Thread-2 end------
Thread-4 end------
Thread-3 end------
(2)使用join方法:
public class JoinTest implements Runnable{
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + " start-----");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " end------");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
for (int i=0;i<5;i++) {
Thread test = new Thread(new JoinTest());
test.start();
try {
test.join();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Finished~~~");
}
}
输出结果如下:
Thread-0 start-----
Thread-0 end------
Thread-1 start-----
Thread-1 end------
Thread-2 start-----
Thread-2 end------
Thread-3 start-----
Thread-3 end------
Thread-4 start-----
Thread-4 end------
Finished~~~
对比两段代码的执行结果很容易发现,在没有使用join方法之前,线程是并发执行的,而使用join方法后,所有线程是顺序执行的。
4.同步队列状态
- 当前线程想调用对象A的同步方法时,发现对象A的锁被别的线程占有,此时当前线程进入同步队列。简言之,同步队列里面放的都是想争夺对象锁的线程。
- 当一个线程1被另外一个线程2唤醒时,1线程进入同步队列,去争夺对象锁。
- 同步队列是在同步的环境下才有的概念,一个对象对应一个同步队列。
- 线程等待时间到了或被notify/notifyAll唤醒后,会进入同步队列竞争锁,如果获得锁,进入RUNNABLE状态,否则进入BLOCKED状态等待获取锁。
5.几个方法的比较
- Thread.sleep(long millis),一定是当前线程调用此方法,当前线程进入TIMED_WAITING状态,但不释放对象锁,millis后线程自动苏醒进入就绪状态。作用:给其它线程执行机会的最佳方式。
- Thread.yield(),一定是当前线程调用此方法,当前线程放弃获取的CPU时间片,但不释放锁资源,由运行状态变为就绪状态,让OS再次选择线程。 作用:让相同优先级的线程轮流执行,但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。该方法与sleep()类似,只是不能由用户指定暂停多长时间。
- thread.join()/thread.join(long millis),当前线程里调用其它线程t的join方法,当前线程进入WAITING/TIMED_WAITING状态,当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到,当前线程一般情况下进入RUNNABLE状态,也有可能进入BLOCKED状态(因为join是基于wait实现的)。
- Object.wait(),当前线程调用对象的wait()方法,当前线程释放对象锁,进入等待队列,状态变为wait状态。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。如果获得锁,进入RUNNABLE状态,否则进入BLOCKED状态等待获取锁。
- LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines), 当前线程进入WAITING/TIMED_WAITING状态。对比wait方法,不需要获得锁就可以让线程进入WAITING/TIMED_WAITING状态,需要通过LockSupport.unpark(Thread thread)唤醒。
6.创建线程的四种方法
Thread
线程运行的过程会产生很多信息,这些信息都保存在Thread类中的成员变量里面,常见的有:
a.线程的ID是唯一标识getId()
b.线程的名称:getName(),如果不设置线程名称默认为“Thread-xx”
c.线程的优先级:getPriority,线程优先级从1-10,其中数字越大表示优先级别越高,同时获得JVM调度执行的可能性越大。
1.继承Thread类
步骤:
1,定义一个类继承Thread类。
2,覆盖Thread类中的run方法。
3,直接创建Thread的子类对象创建线程。
4,调用start方法开启线程并调用线程的任务run方法执行。
可以通过Thread的getName获取线程的名称 Thread-编号(从0开始),主线程的名字就是main。
下面来看下实际的栗子:
class Demo extends Thread
{
/**
*线程名称
*/
private String name;
Demo(String name)
{
//父类构造函数,改线程的名称
super(name);
//this.name = name;
}
//***run方法中定义就是线程要运行的任务代码。***
public void run()
{
for(int x=0; x<10; x++)
{
System.out.println(name+"....x="+x+".....name="+Thread.currentThread().getName());
}
}
}
class ThreadDemo2
{
public static void main(String[] args)
{
Demo d1 = new Demo("旺财");
Demo d2 = new Demo("xiaoqiang");
d1.start();//开启线程,调用run方法。
d2.start();
System.out.println("over...."+Thread.currentThread().getName());
}
}
2.通过实现Runnable接口,覆盖run方法。(常用)
1,定义类实现Runnable接口。
2,覆盖接口中的run方法,将线程的任务代码封装到run方法中。
3,通过Thread类创建线程对象,并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。
为什么?因为线程的任务都封装在Runnable接口子类对象的run方法中。
所以要在线程对象创建时就必须明确要运行的任务。
思想:将线程的任务通过Runnable接口封装成了对象。
4,调用线程对象的start方法开启线程。
实现Runnable接口的好处:
1,将线程的任务从线程的子类中分离出来,进行了单独的封装,按照面向对象的思想将任务封装成对象。
2,避免了java单继承的局限性。
下面来看下实际的栗子:
//准备扩展Demo类的功能,让其中的内容可以作为线程的任务执行。
//通过接口的形式完成。
class Demo implements Runnable{
public void run()
{
show();
}
public void show()
{
for(int x=0; x<20; x++)
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
}
class ThreadDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
}
}
3.实现Callable接口
与使用Runnable相比, Callable功能更强大些:
1.相比run()方法,可以有返回值
2.方法可以抛出异常
3.支持泛型的返回值
4.需要借助FutureTask类,比如获取返回结果
Future接口
1.可以对具体Runnable、Callable任务的执行结果进行取消、查询是
否完成、获取结果等。
2.FutrueTask是Futrue接口的唯一的实现类。
3.FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行,又可以作为Future得到Callable的返回值。
//1.创建一个实现Callable的实现类
class Stu implements Callable {
//2.实现call方法,将此线程需要执行的操作放到call()中
@Override
public Object call() throws Exception {
int sum=0;
for (int i = 1; i <=100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class Bank {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
Stu stu = new Stu();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象
FutureTask futureTask = new FutureTask(stu);
//5.FutureTask的对象作为参数传递到Thread类的构造器中创建Thread,并调用start()
new Thread(futureTask).start();
try {
Object sum = futureTask.get();
System.out.println("总和为"+sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
4.使用线程池
背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程, 对性能影响很大。
思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。
好处:
1.提高响应速度(减少了创建新线程的时间)
2.降低资源消耗(重复利用线程池中线程,不需要每次都创建)
3.便于线程管理
//创建并使用多线程的第四种方法:使用线程池
class MyThread implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
if(i % 2 ==0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
// 1.提供指定线程的数量
ExecutorService service = Executors.newFixedThreadPool(10);
//设置线程的属性
ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
//service1.setMaximumPoolSize(15);
//service1.setCorePoolSize();*/
// 2.将Runnable实现类的对象作为形参传递给ExecutorService的submit()方法中,开启线程
// 并执行相关的run()
service.execute(new MyThread());//适用于Runnable
//service.submit();适用于Callable
// 3.结束线程的使用
service.shutdown();
}
}
三、总结
本文首先介绍了线程有哪几种状态,每种状态什么时候发生。然后介绍了线程的协作方法,详细讲解了每种协作方法的作用,并比较了这几种协作方法的异同。最后讲解了线程四种创建方法。
最后引用我很佩服的一个人经常说的话:你知道的越多,你不知道的越多!
文章参考:
https://segmentfault.com/a/1190000038392244#
https://www.cnblogs.com/paddix/p/5381958.html