1、线程状态图：

1598519678(1).jpg 线程状态.PNG
图片.png 图片.png

2、线程常用方法sleep(),wait(),join(),yield()：

图片.png

线程停止：

java终止线程的三种方式
提倡使用标志位的方式

package com.company.runable;

public class MyRunable implements Runnable{

    private boolean flag = true;

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i==12){
                stop();
            }
            if (flag) {
                System.out.println(Thread.currentThread().getName() + "____" + i);
            }
        }
    }
    public void stop(){
        this.flag = false;
    }


    public static void main(String[] args) {
        Thread th = new Thread(new MyRunable());
        th.start();
    }
}

sleep()：线程休眠

• sleep（时间）指定当前线程阻塞的毫秒数
• sleep存在异常InterruptedException，需要抛出
• sleep时间到后线程进入就绪状态
• sleep可以模拟网络延时，倒计时等
• 每一个对象都有锁，sleep不会释放锁

yield():线程礼让

• 让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让cpu重新调度，礼让不一定成功

package com.company.runable;
//测试线程礼让
public class TestYeild {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }


}
class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//线程礼让
        System.out.println(Thread.currentThread().getName()+"线程执行结束");
    }
}

结果1：(礼让成功)

a线程开始执行
b线程开始执行
b线程执行结束
a线程执行结束

结果2：（礼让不成功）

a线程开始执行
a线程执行结束
b线程开始执行
b线程执行结束

Join

• join()合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
• 可以理解为插队

package com.company.runable;

public class TestJoin {

    public static void main(String[] args) {
        
        Myjoin myjoin = new Myjoin();
        Thread thread = new Thread(myjoin);
        thread.start();
        
        //主线程
        for (int i = 0; i < 20; i++) {
            if (i==10) {
                try {
                    thread.join();//thread线程插队
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("主线程"+i);
        }
    }

}
class Myjoin implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("vip线程来了"+i);
        }
    }
}

结果：

主线程0
主线程1
主线程2
主线程3
主线程4
主线程5
主线程6
主线程7
主线程8
主线程9
vip线程来了0
vip线程来了1
vip线程来了2
vip线程来了3
vip线程来了4
vip线程来了5
vip线程来了6
vip线程来了7
vip线程来了8
vip线程来了9
主线程10
主线程11
主线程12
主线程13
主线程14
主线程15
主线程16
主线程17
主线程18
主线程19

3、观测线程状态：

线程的状态：

• NEW
  尚未启动的线程处于此状态。
• RUNNABLE
  在Java虚拟机中执行的线程处于此状态。
• BLOCKED
  被阻塞等待监视器锁定的线程处于此状态
• WAITING
  正在等待另一个线程执行特定动作的线程处于此状态
• TIMED_WAITING
  正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
• TERMINATED
  已退出的线程处于此状态

package com.company.runable;

public class TestState {

    public static void main(String[] args) {

        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("结束*****");
        });

        //观察线程状态
        Thread.State state = thread.getState();
        System.out.println(state);

        //观察线程启动后的状态
        thread.start();
        state = thread.getState();
        System.out.println(state);

        //循环打印线程状态
        while (state != Thread.State.TERMINATED){ //只要线程不终止，就一直输出状态
            try {
                thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();
            System.out.println(state);
        }
    }
}

结果：

NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
结束*****
TERMINATED