线程状态切换
线程状态切换
※说明:
- 新创建一个新的线程对象后， 再调用它的start() 方法， 系统会为此线程分配
CPU资源， 使其处于Runnable(可运行) 状态， 这是一个准备运行的阶段。如果
线程抢占到CPU资源， 此线程就处于Running(运行) 状态 - Runnable状态和Running状态可相互切换， 因为有可能线程运行一段时间后，
有其他高优先级的线程抢占了CPU资源， 这时此线程就从Running状态变成
Runnable状态。
线程进入Runnable状态大体分为如下5种情况：
- 调用sleep() 方法后经过的时间超过了指定的休眠时间
- 线程调用的阻塞IO已经返回，阻塞方法执行完毕
- 线程成功地获得了试图同步的监视器
- 线程正在等待某个通知，其他线程发出了通知
- 处于挂起状态的线程调用了resume恢复方法
- Blocked是阻塞的意思， 例如遇到了一个IO操作， 此时CPU处于空闲状态， 可
能会转而把CPU时间片分配给其他线程， 这时也可以称为“暂停”状态。Blocked
状态结束后， 进入Runnable状态， 等待系统重新分配资源
出现阻塞的情况大体分为如下5种:
- 线程调用sleep方法， 主动放弃占用的处理器资源。
- 线程调用了阻塞式IO方法，在该方法返回前，该线程被阻塞。
- 线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有。
- 线程等待某个通知。
- 程序调用了suspend方法将该线程挂起。此方法容易导致死锁， 尽量避免使用该方
法。
- run() 方法运行结束后进入销毁阶段， 整个线程执行完毕。
每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了将
要获得锁的线程，阻塞队列存储了被阻塞的线程。一个线程被唤醒后，才会进入就
绪队列， 等待CPU的调度； 反之， 一个线程被wait后， 就会进入阻塞队列， 等待下
一次被唤醒。
wait()方法 释放锁; notify()方法 不释放锁
当wait()方法执行后,会自动释放锁,notify()方法执行后,锁不会自动释放
参考:https://gitee.com/kaixinshow/java-concurrent-learn
package:com.zhxin.threadLab.notify.chapter1 下的示例
代码如下:
ThreadA.java
package com.zhxin.threadLab.notify.chapter1;
/**
* @ClassName ThreadA
* @Description // wait
* @Author singleZhang
* @Email 405780096@qq.com
* @Date 2020/11/28 0028 上午 10:46
**/
public class ThreadA extends Thread {
private Object lock;
public ThreadA(Object object){
super();
this.lock = object;
}
@Override
public void run(){
try{
synchronized (lock){
System.out.println("begin wait! time=" + System.currentTimeMillis());
lock.wait();
System.out.println("end wait! time=" + System.currentTimeMillis());
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
ThreadB.java
package com.zhxin.threadLab.notify.chapter1;
/**
* @ClassName ThreadB
* @Description // notify
* @Author singleZhang
* @Email 405780096@qq.com
* @Date 2020/11/28 0028 上午 10:54
**/
public class ThreadB extends Thread {
private Object lock;
public ThreadB(Object object){
this.lock = object;
}
@Override
public void run(){
synchronized (lock){
System.out.println("begin notify! time="+System.currentTimeMillis());
lock.notify();
System.out.println("end notify! time="+System.currentTimeMillis());
}
}
}
RunWaitAndNotify.java
package com.zhxin.threadLab.notify.chapter1;
/**
* @ClassName RunWaitAndNotify
* @Description // Thread wait notify Test
* // 示例中可以看出，wait需要等notify后边的代码执行完后才得到锁，继续执行
* @Author singleZhang
* @Email 405780096@qq.com
* @Date 2020/11/28 0028 上午 10:56
**/
public class RunWaitAndNotify {
public static void main(String[] args){
try{
Object lock = new Object(); // 提供同一个锁对象
ThreadA a = new ThreadA(lock);
a.start();
Thread.sleep(1000);
ThreadB b = new ThreadB(lock);
b.start();
} catch (InterruptedException e){
e.printStackTrace();
}
}
}
运行示例结果如下:
waitAndNotify
※notify()只能唤醒一个线程,notifyAll()可以唤醒所以等待线程。
※wait(long) 限定等待时间，超过后自动唤醒,在其间可以由notify或notifyAll唤醒
wati/notify 最经典的案例就是"生产者/消费者"模式
生产者-消费者实现方式有
- synchronized结合wait+notify实现
- 用Lock类实现
- 使用BlockingQueue阻塞队列实现
synchronized结合wait+notify实现"生产者/消费者"模式
参考案例:https://gitee.com/kaixinshow/java-concurrent-learn
package:com.zhxin.threadLab.notify.chapter2
代码如下
Producer.java
package com.zhxin.threadLab.notify.chapter2;
/**
* @ClassName Productor
* @Description //生产者类
* @Author singleZhang
* @Email 405780096@qq.com
* @Date 2020/11/28 0028 下午 2:14
**/
public class Producer {
private String lock;
public Producer(String lock){
super();
this.lock = lock;
}
public void setValue(){
try{
synchronized (lock){
if(!ValueObject.value.equals("")){
lock.wait();
}
String value = "threadNme =" +Thread.currentThread().getName()+"设值,time="+System.currentTimeMillis();
System.out.println("value值:"+value);
ValueObject.value = value;
lock.notifyAll();
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
Consumer.java
package com.zhxin.threadLab.notify.chapter2;
/**
* @ClassName Consumer
* @Description //消费者
* @Author singleZhang
* @Email 405780096@qq.com
* @Date 2020/11/28 0028 下午 2:24
**/
public class Consumer {
private String lock;
public Consumer(String lock){
this.lock = lock;
}
public void getValue(){
try{
synchronized (lock){
if(ValueObject.value.equals("")){
lock.wait();
}
System.out.println("get的值是:"+ValueObject.value);
ValueObject.value = "";
lock.notifyAll();
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
ValueObject.java
package com.zhxin.threadLab.notify.chapter2;
/**
* @ClassName ValueObject
* @Description //值对象
* @Author singleZhang
* @Email 405780096@qq.com
* @Date 2020/11/28 0028 下午 2:13
**/
public class ValueObject {
public static String value = "";
}
测试RunThreadTest.java
package com.zhxin.threadLab.notify.chapter2;
/**
* @ClassName RunThreadTest
* @Description //生产者 消费者 示例
* @Author singleZhang
* @Email 405780096@qq.com
* @Date 2020/11/28 0028 下午 2:27
**/
public class RunThreadTest {
public static void main(String[] args){
String lock = new String("");
ThreadP p = new ThreadP(new Producer(lock));
p.start();
ThreadC c = new ThreadC(new Consumer(lock));
c.start();
}
}
执行结果如下
生产者/消费者模式
多生产与多消费:操作值-假死
是否考虑过这类情况:如果全部线程都进入waiting状态，则程序就不再执行任何业务功能了，整个项目呈停止状态。这个就是假死,假死的现象其实就是进入waiting状态。这在生产者/消费者模式里常见。
假死的原因:
由于唤醒线程调用的是notify()唤醒单个线程，所以有可能唤醒的是同类的线程，也就是生产者唤醒的是生产者，消费者唤醒的是消费者。导致最后几个线程都处于waiting状态。
解决办法:
唤醒的时候采用notifyAll()唤醒所有的线程唤醒所有的线程，避免只唤醒同类线程。
sleep/yield/join方法解析
这组方法跟上面方法的最明显区别是：这几个方法都位于Thread类中，而上面三个方法都位于*Object类中。
- sleep
sleep方法的作用是让当前线程暂停指定的时间（毫秒）。
Thread.sleep(1000);//线程暂停1秒
sleep与wait方法的区别:
- wait方法依赖于同步，而sleep方法可以直接调用
- sleep方法只是暂时让出CPU的执行权，并不释放锁。而wait方法则需要释放锁。
- yield方法
yield方法的作用是暂停当前线程，以便其他线程有机会执行，不过不能指定暂停的时间，并且也不能保证当前线程马上停止。yield方法只是将Running状态转变为Runnable状态。
※很少有场景要用到该方法，主要使用的地方是调试和测试
3.join方法
- void join()
- void join(long millis)
- void join(long millis, int nanos)
join方法的作用是父线程等待子线程执行完成后再执行，换句话说就是将异步执行的线程合并为同步的线程。JDK中提供三个版本的join方法，其实现与wait方法类似，join()方法实际上执行的join(0)，而join(long millis, int nanos)也与wait(long millis, int nanos)的实现方式一致，暂时对纳秒的支持也是不完整的,查看join的源码:
//Thread类
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);
}
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;
}
}
}
※说明:我们主要看一下join(long millis)方法的实现，因为另外两个方法的实现也都是通过这个方法来实现的。可以看出join方法就是通过wait方法来将线程的阻塞，如果join的线程还在执行，则将当前线程阻塞起来，直到join的线程执行完成，当前线程才能执行。这里的join只调用了wait方法，却没有对应的notify方法，原因是join中提供了时间参数，所以当join的线程执行完成以后，会自动唤醒主线程继续往下执行。
