Java并发编程（三） 常见方法

start 与 run

public static void main(String[] args) {
 Thread t1 = new Thread("t1") {
 @Override
 public void run() {
 log.debug(Thread.currentThread().getName());
 FileReader.read(Constants.MP4_FULL_PATH);
 }
 };
 t1.run();
 log.debug("do other things ...");
 t1.start();
}

程序仍在 main 线程运行，FileReader.read() 方法调用还是同步的

 

程序在 t1 线程运行，FileReader.read() 方法调用是异步调用

 

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

 

sleep 与 yield

sleep

1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）

2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出

InterruptedException

3. 睡眠结束后的线程未必会立刻得到执行

4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield

1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程

2. 具体的实现依赖赖于操作系统的任务调度器

 

线程优先级

线程优先级会提示（ hint ）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它

如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但cpu 闲时，优先级几乎没作用

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.setPriority(Thread.MIN_PRIORITY);
// t2.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();

 

join 方法详解

static int r = 0;
public static void main(String[] args) throws InterruptedException {
 test1();
}
private static void test1() throws InterruptedException {
 log.debug("开始");
 Thread t1 = new Thread(() -> {
 log.debug("开始");
 sleep(1);
 log.debug("结束");
 r = 10;
 });
 t1.start();
//t1.join();
 log.debug("结果为:{}", r);
 log.debug("结束");
}

因为主线程和线程 t1 是并行执行的， t1 线程需要 1 秒之后才能算出

r=10

而主线程一开始就要打印 r 的结果，所以只能打印出 r=0

解决方法

用 sleep 行不行？为什么？

用 join ，加在 t1.start() 之后即可

 

 

有时效的 join

等够时间

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
 test3();
}
public static void test3() throws InterruptedException {
 Thread t1 = new Thread(() -> {
 sleep(1);
 r1 = 10;
 });
 long start = System.currentTimeMillis();
 t1.start();
 // 线程执行结束会导致 join 结束
 t1.join(1500);
 long end = System.currentTimeMillis();
 log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

//20:52:15.623 [main] c.TestJoin - r1: 10 r2: 0 cost: 1002

没等够时间

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
 test3();
}
public static void test3() throws InterruptedException {
 Thread t1 = new Thread(() -> {
 sleep(2);
 r1 = 10;
 });
 long start = System.currentTimeMillis();
 t1.start();
 // 线程执行结束会导致 join 结束
 t1.join(1500);
 long end = System.currentTimeMillis();
 log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

//20:52:15.623 [main] c.TestJoin - r1: 0 r2: 0 cost: 1502

 

interrupt 方法详解

打断 sleep ， wait ， join 的线程这几个方法都会让线程进入阻塞状态，打断 sleep 的线程 , 会清空打断状态，以 sleep 为例

private static void test1() throws InterruptedException {
 Thread t1 = new Thread(()->{
 sleep(1);
 }, "t1");
 t1.start();
 sleep(0.5);
 t1.interrupt();
 log.debug(" 打断状态: {}", t1.isInterrupted());
}

java.lang.InterruptedException: sleep interrupted

at java.lang.Thread.sleep(Native Method)

at java.lang.Thread.sleep(Thread.java:340)

at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)

at cn.itcast.n2.util.Sleeper.sleep(Sleeper.java:8)

at cn.itcast.n4.TestInterrupt.lambda$test1$3(TestInterrupt.java:59)

at java.lang.Thread.run(Thread.java:745)

21:18:10.374 [main] c.TestInterrupt - 打断状态 : false

 

打断正常运行的线程

打断正常运行的线程 , 不会清空打断状态

private static void test2() throws InterruptedException {
 Thread t2 = new Thread(()->{
 while(true) {
 Thread current = Thread.currentThread();
 boolean interrupted = current.isInterrupted();
 if(interrupted) {
 log.debug(" 打断状态: {}", interrupted);
 break;
 }
 }
 }, "t2");
 t2.start();
 sleep(0.5);
 t2.interrupt();
}

20:57:37.964 [t2] c.TestInterrupt - 打断状态 : true

 

 

打断 park 线程

打断 park 线程, 不会清空打断状态

private static void test3() throws InterruptedException {
 Thread t1 = new Thread(() -> {
 log.debug("park...");
 LockSupport.park();
 log.debug("unpark...");
 log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
 }, "t1");
 t1.start();
 sleep(0.5);
 t1.interrupt();
}


21:11:52.795 [t1] c.TestInterrupt - park... 
21:11:53.295 [t1] c.TestInterrupt - unpark... 
21:11:53.295 [t1] c.TestInterrupt - 打断状态：true

如果打断标记已经是 true, 则 park 会失效

private static void test4() {
 Thread t1 = new Thread(() -> {
 for (int i = 0; i < 5; i++) {
 log.debug("park...");
 LockSupport.park();
 log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
 }
 });
 t1.start();
 sleep(1);
 t1.interrupt();
}

21:13:48.783 [Thread-0] c.TestInterrupt - park...

21:13:49.809 [Thread-0] c.TestInterrupt - 打断状态： true

21:13:49.812 [Thread-0] c.TestInterrupt - park...

21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态： true

21:13:49.813 [Thread-0] c.TestInterrupt - park...

21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态： true

21:13:49.813 [Thread-0] c.TestInterrupt - park...

21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态： true

21:13:49.813 [Thread-0] c.TestInterrupt - park...

21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态： true

 

可以使用 Thread.interrupted() 清除打断状态

 

 

不推荐的方法

还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁