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

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"){@Overridepublic void run() {log.debug(Thread.currentThread().getName());}};t1.start();t1.sleep(100);t1.run();}}复制代码结果：

18:27:56.487 c.Test [t1] - t118: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();}

}复制代码结果：

---->1 16193---->1 16194---->1 16195---->1 16196---->1 16197---->1 16198---->1 16199---->1 16200---->1 16201---->1 16202---->1 16203---->1 16204---->1 16205---->1 16206---->1 16207---->1 16208---->1 16209---->1 16210---->1 16211---->2 4458---->2 4459---->2 4460---->2 4461---->2 4462---->2 4463---->2 4464---->2 4465---->2 4466---->2 4467 可以看出 yield 让步大概率是 让步到其它线程，但并不代表此线程就一定会让步。

再补充线程优先级会提示调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用。可以说它和 yield 一样 都是不确定是否一定会改变当前线程。

可以看出虽然 t2 的优先级为 MAX_PRIORITY(优先级为 10) t1 的优先级为 MIN_PRIORITY(优先级为 1)，但是仍然会出现 t1 不断输出的情况，说明了 优先级只是作为参考 真正决定执行什么线程的是 cpu。