当前位置：首页 > news >正文

【Java深入学习】并发常见方法的注意事项

news 来源：原创 2024/4/28 1:50:55

start 与 run

我们知道 start方法是运行Thread里的run方法，那么我们之间调用run方法，这两者之前的区别是什么

代码示例

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test")
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                log.debug(Thread.currentThread().getName());
            }
        };
        t1.start();
        t1.sleep(100);
        t1.run();
    }
}
复制代码

结果：

18:27:56.487 c.Test [t1] - t1
18:27:56.487 c.Test [main] - main

可以看出直接调用 run 是在主线程中执行了 run，没有启动新的线程使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

sleep 与 yield

两者的区别

sleep

调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
睡眠结束后的线程未必会立刻得到执行
建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield

调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
具体的实现依赖于操作系统的任务调度器

sleep状态

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test6")
public class Test6 {

    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        t1.start();
        log.debug("t1 state: {}", t1.getState());

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state: {}", t1.getState());
    }
}
复制代码

结果：

18:53:22.128 c.Test6 [main] - t1 state: RUNNABLE

18:53:22.633 c.Test6 [main] - t1 state: TIMED_WAITING

刚开始调用的时候t1状态为运行态，之后当t1线程调用sleep时主线程查看t1的状态为TIMED_WAITING(阻塞)

yield状态

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.TestYield")
public class TestYield {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            System.out.println("---->1 ");
        };
        Runnable task2 = () -> {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Thread.yield();
            System.out.println("              ---->2 ");

        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        t1.start();
        log.debug("t2 state: {}", t2.getState());
        t2.start();
        log.debug("t2 state: {}", t2.getState());

    }

}
复制代码

结果：

---->1

00:28:50.450 c.TestYield [main] - t2 state: NEW

00:28:50.454 c.TestYield [main] - t2 state: RUNNABLE

---->2

可以看出t2线程yield让步后就变为了RUNNABLE就绪态

补充

yield并不是一定会让步，它的原理是把自己让出然后变成就绪态然后和其它线程再争抢cpu，所以有可能yield后还是此线程。

代码示例

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test9")
public class Test9 {

    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (;;) {
                Thread.yield();
                System.out.println("              ---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");

        t1.start();
        t2.start();
    }
}
复制代码

结果：