线程的生命周期

从生命的角度讲,人的生命周期----由受精卵开始到婴儿儿童…这不是重点,你要知道的;

• 线程的生命周期
• • NEW RUNNABLE 与TERMINATED
  • WAITING与TIMED_WAITING
  • • LockSupport.park()后的状态
  • synchronized与Lock锁等待的状态

你觉得线程的生命周期是从哪里开始的?
当然是new一个线程对象了呗!!!

package ThreadStateDemo;

import java.util.concurrent.TimeUnit;
class SleepHelper{
    public static  void sleepHelper( int time){
        try {
            TimeUnit.SECONDS.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("2--"+Thread.currentThread().getState());
            for (int i = 0; i < 3; i++) {
               SleepHelper.sleepHelper(1);
                System.out.print(i+" ");
            }
            System.out.println();
        });
        System.out.println("1--"+thread.getState());//线程启动之前
        thread.start();线程启动
        thread.join();
        System.out.println("3--"+thread.getState());//不加join()那么输出的是main的状态----runnable.不信你就试试看
    }
}

运行一下你会得到什么结果?

 Thread thread= new Thread(()->{
           LockSupport.park();//执行时先阻塞
           System.out.println("Thread---go-go-go");
           SleepHelper.sleepHelper(4);//再睡四秒
       });
       thread.start();

       SleepHelper.sleepHelper(1);//让主线程睡一秒,已确保thread先启动,不能用join(),因为 LockSupport.park();没有可以唤醒它的第三者线程了,就会一直waiting
        System.out.println("4--"+thread.getState());
         //再唤醒线程thread,所以一定要让thread先执行起来;
        LockSupport.unpark(thread);
        SleepHelper.sleepHelper(1);//让主线程睡一秒,已确保thread先启动
        System.out.println("5--"+thread.getState());

 Thread thread = new Thread(() -> {
            LockSupport.park();

        });
        thread.start();
        SleepHelper.sleepHelper(1);
        System.out.println("8--" + thread.getState());

        final Object o = new Object();
        Thread thread = new Thread(() -> {
            synchronized (o) {
                System.out.println("我想要拿到那把锁");
            }
        });
        Thread thread1 = new Thread(() -> {
            synchronized (o) {
                System.out.println("我先拿到那把锁了");
                //拿到锁睡5秒
                SleepHelper.sleepHelper(5);
            }
        });
        thread1.start();
        //主线程睡一秒
        SleepHelper.sleepHelper(1);
        //然后启动thread2
        thread.start();
        SleepHelper.sleepHelper(1);
        System.out.println("6--" + thread.getState());

synchronized同步方法拿不到锁的时候是blocked状态,其他锁的是waiting状态------自旋等待状态

将上面的锁换成Lock

 Lock lock = new ReentrantLock();
        Thread thread = new Thread(() -> {
            lock.lock();//try catch finally 省略了吧
            System.out.println("我想要拿到那把锁");
            lock.unlock();
        });
        Thread thread1 = new Thread(() -> {
            lock.lock();
            System.out.println("我先拿到那把锁了");
            //拿到锁睡5秒
            SleepHelper.sleepHelper(5);
            lock.unlock();
        });
        thread1.start();
        //主线程睡一秒
        SleepHelper.sleepHelper(1);
        //然后启动thread2
        thread.start();
        SleepHelper.sleepHelper(1);
        System.out.println("7--" + thread.getState());

原因是Lock锁是JUC中的锁底层是CAS,会自旋,拿不到锁就在那里转圈圈等待而非阻塞状态;