Java线程stop，sleep，yield，join

ゝ一纸荒年。 2023-09-29 17:35 13阅读 0赞

#### 文章目录 ####

*  一、Java多线程操作
 *  二、总结

## 一、Java多线程操作 ##

*  1、不建议使用stop，destroy方法来停止线程
 *  2、建议使用标志位flag来让线程自己停止

> run方法中：当flag为true时，线程一直执行  
> 公共停止方法中：设置flag为false。这样线程调用停止方法时，就会停止。

**TestStop.java**  
让线程停止

package com.peng.thread;
    
    // 不建议使用 stop，destroy等方法来停止线程
    // 建议使用flag标志位，让线程自己停止
    public class TestStop implements Runnable{
        
        private boolean flag = true;
        @Override
        public void run() {
        
            int i = 0;
            // 当flag为true时，线程一直执行
            while (flag){
        
                System.out.println("Thread is runing " + i++);
            }
        }
    
        // 一个公共stop方法，用来改变标志位为false
        public void stop(){
        
            this.flag = false;
        }
    
        public static void main(String[] args) {
        
            TestStop tt = new TestStop();
            new Thread(tt).start();
            for(int i=0; i < 1000; i++){
        
                System.out.println("Main Thread is running " + i);
                if (i == 900){
        
                	// 切换标志位，线程停止
                    tt.stop();
                    System.out.println("Thread is stoped");
                }
            }
        }
    }

**TestSleep.java**  
线程休眠  
利用Thread.sleep(1000），每隔1秒输出一次时间。

package com.peng.thread;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    // 打印时间
    public class TestSleep {
        
        public static void main(String[] args) throws InterruptedException {
        
            while (true){
        
                Date curtime = new Date(System.currentTimeMillis());
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(curtime));
                Thread.sleep(1000);
            }
        }
    }

**TestYield.java**  
线程礼让

package com.peng.thread;
    
    // 线程礼让，给调度器一个提示，让线程从执行状态变为就绪态，然后处理器执行其他线程。但是调度器可以忽略它。
    // 也就是说yield不一定成功
    public class TestYield {
        
        public static void main(String[] args) {
        
            MyYield yield = new MyYield();
            new Thread(yield, "a").start();
            new Thread(yield, "b").start();
        }
    }
    
    class MyYield implements Runnable{
        
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName() + " starting");
            Thread.yield();
            System.out.println(Thread.currentThread().getName() + " ending");
        }
    }

**TestJoin**  
线程插队

package com.peng.thread;
    
    // join()  被插队线程暂时阻塞，等插队线程执行完之后，被阻塞线程继续执行
    public class TestJoin implements Runnable{
        
        @Override
        public void run() {
        
            for (int i = 0; i < 300; i++){
        
                System.out.println(Thread.currentThread().getName() + "线程执行 " + i);
            }
        }
        public static void main(String[] args) throws InterruptedException {
        
            // 启动线程
            TestJoin tt = new TestJoin();
            Thread th1 = new Thread(tt, "aa");
            th1.start();
            Thread th2 = new Thread(tt, "bb");
            th2.start();
            // 主线程
            for (int i = 0; i < 200; i++){
        
                System.out.println("主线程执行 " + i);
                if (i == 100){
        
                    th1.join();
                }
            }
        }
    }

Thread.State的几种状态：  
`NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED`  
![0c6ab21072fe43a3a847da7fd6b54110.png][]  
**TestState.java**

package com.peng.thread;
    
    public class TestState{
        
        public static void main(String[] args) throws InterruptedException {
        
            // 使用lambda表达式
            Thread thread = new Thread(()->{
        
                try {
        
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
        
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("#####################");
            });
            // 此时线程thread的状态时NEW
            Thread.State state = thread.getState();
            System.out.println(state);
    
            // 此时线程thread状态是RUNNABLE
            thread.start();
            System.out.println(thread.getState());
    
            // 每隔200ms输出一次线程状态
            while (state != Thread.State.TERMINATED){
        
                Thread.sleep(200);
                state = thread.getState();
                System.out.println(state);
            }
        }
    }

## 二、总结 ##

**Thread.sleep(1000)，  
让当前线程休眠1000毫秒**  
  
**Thread.yield()，给调度器提示将执行态变为就绪态，暂时让出处理器给其他线程使用。但调度器可以忽略这个提示，也就是礼让不一定成功。**  
  
**Thread.stop()，不建议使用，而是要通过设置标志位的方式来结束线程。**  
  
**Thread.join()，插队，被插队线程暂时阻塞，等待插队线程执行完之后才能继续执行。**

[0c6ab21072fe43a3a847da7fd6b54110.png]: https://img-blog.csdnimg.cn/0c6ab21072fe43a3a847da7fd6b54110.png