线程状态切换

线程状态切换

※说明:

1. 新创建一个新的线程对象后， 再调用它的start() 方法， 系统会为此线程分配
   CPU资源， 使其处于Runnable(可运行) 状态， 这是一个准备运行的阶段。如果
   线程抢占到CPU资源， 此线程就处于Running(运行) 状态
2. Runnable状态和Running状态可相互切换， 因为有可能线程运行一段时间后，
   有其他高优先级的线程抢占了CPU资源， 这时此线程就从Running状态变成
   Runnable状态。
   线程进入Runnable状态大体分为如下5种情况：

• 调用sleep() 方法后经过的时间超过了指定的休眠时间
• 线程调用的阻塞IO已经返回，阻塞方法执行完毕
• 线程成功地获得了试图同步的监视器
• 线程正在等待某个通知，其他线程发出了通知
• 处于挂起状态的线程调用了resume恢复方法

3. Blocked是阻塞的意思， 例如遇到了一个IO操作， 此时CPU处于空闲状态， 可
   能会转而把CPU时间片分配给其他线程， 这时也可以称为“暂停”状态。Blocked
   状态结束后， 进入Runnable状态， 等待系统重新分配资源
   出现阻塞的情况大体分为如下5种:

• 线程调用sleep方法， 主动放弃占用的处理器资源。
• 线程调用了阻塞式IO方法，在该方法返回前，该线程被阻塞。
• 线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有。
• 线程等待某个通知。
• 程序调用了suspend方法将该线程挂起。此方法容易导致死锁， 尽量避免使用该方
  法。

4. 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 最经典的案例就是"生产者/消费者"模式

生产者-消费者实现方式有

1. synchronized结合wait+notify实现
2. 用Lock类实现
3. 使用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类中。

1. sleep
   sleep方法的作用是让当前线程暂停指定的时间（毫秒）。

Thread.sleep(1000);//线程暂停1秒

sleep与wait方法的区别:

• wait方法依赖于同步，而sleep方法可以直接调用
• sleep方法只是暂时让出CPU的执行权，并不释放锁。而wait方法则需要释放锁。

2. 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的线程执行完成以后，会自动唤醒主线程继续往下执行。