多线程之常见方法使用
start和run
首先看调用run方法
代码示例:
package com.wxit.test02;
import lombok.extern.slf4j.Slf4j;
/**
* @author wj
* @date 2022.01.02 19:25
*/
@Slf4j(topic = "c.Test")
public class Test {
public static void main(String[] args) {
Thread thread = new Thread("t1") {
@Override
public void run() {
log.debug("开始执行t1线程");
}
};
thread.run();
log.debug("主线程正在执行....");
}
}
**控制台输出 **
19:27:46.721 c.Test [main] - 开始执行t1线程
19:27:46.742 c.Test [main] - 主线程正在执行....
程序仍然在main线程中运行,而且是同步执行的
调用start方法
package com.wxit.test02;
import lombok.extern.slf4j.Slf4j;
/**
* @author wj
* @date 2022.01.02 19:25
*/
@Slf4j(topic = "c.Test")
public class Test {
public static void main(String[] args) {
Thread thread = new Thread("t1") {
@Override
public void run() {
log.debug("开始执行t1线程");
}
};
thread.start();
log.debug("主线程正在执行....");
}
}
控制台输出:
19:32:28.911 c.Test [main] - 主线程正在执行....
19:32:28.911 c.Test [t1] - 开始执行t1线程
可以看出程序在t1线程中运行了
小结
- 直接调用run方法是在主线程中执行了run方法，没有启动新的线程
- 直接使用start是启动新的线程，通过新的线程间接执行run中的代码
sleep与 yield
sleep
- 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
- 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
- 睡眠结束后的线程未必会立刻得到执行
- 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性
yield
- 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
- 具体的实现依赖于操作系统的任务调度器
线程优先级
- 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
- 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用
代码示例：
package com.wxit.test02;
/**
* @author wj
* @date 2022.01.02 19:40
*/
public class Test02 {
public static void main(String[] args) {
Runnable r1 = () -> {
int count = 0;
for (; ; ) {
System.out.println("--------1" + count++);
}
};
Runnable r2 = () -> {
int count = 0;
for (; ; ) {
// Thread.yield();
System.out.println(" --------2" + count++);
}
};
Thread t1 = new Thread(r1, "t1");
Thread t2 = new Thread(r2, "t2");
t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();
}
}
查看源码发现线程优先级有三种
/**
* The minimum priority that a thread can have.
*/
public final static int MIN_PRIORITY = 1;
/**
* The default priority that is assigned to a thread.
*/
public final static int NORM_PRIORITY = 5;(默认优先级)
/**
* The maximum priority that a thread can have.
*/
public final static int MAX_PRIORITY = 10;
join方法
首先引出为什么要使用join
案例说明,执行的结果是？
package com.wxit.test02;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.TimeUnit;
/**
* @author wj
* @date 2022.01.02 20:51
*/
@Slf4j(topic = "c.Test03")
public class Test03 {
static int r = 0;
public static void main(String[] args) {
test01();
}
static private void test01(){
log.debug("开始执行....");
Thread t1 = new Thread(() -> {
log.debug("开始执行线程中run方法....");
sleep(1);
log.debug("睡眠结束....");
r = 10;
});
t1.start();
log.debug("结果为:{}",r);
log.debug("主线程执行结束");
}
public static void sleep(int i) {
try {
TimeUnit.SECONDS.sleep(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
执行结果：
20:58:02.833 c.Test03 [main] - 开始执行....
20:58:02.886 c.Test03 [Thread-0] - 开始执行线程中run方法....
20:58:02.886 c.Test03 [main] - 结果为:0
20:58:02.888 c.Test03 [main] - 主线程执行结束
20:58:03.894 c.Test03 [Thread-0] - 睡眠结束....
Process finished with exit code 0
分析
- 因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10
- 而主线程一开始就要打印 r 的结果，所以只能打印出 r=0
解决方法
- 用 join，加在 t1.start() 之后即可
在t1.start() 之后
调用join方法之后，控制台输出为:
21:01:12.347 c.Test03 [main] - 开始执行....
21:01:12.388 c.Test03 [Thread-0] - 开始执行线程中run方法....
21:01:13.389 c.Test03 [Thread-0] - 睡眠结束....
21:01:13.389 c.Test03 [main] - 结果为:10
21:01:13.389 c.Test03 [main] - 主线程执行结束
应用之同步
以调用方角度来讲，如果
- 需要等待结果返回，才能继续运行就是同步
- 不需要等待结果返回，就能继续运行就是异步
等待多个结果
问，下面代码 花费大约多少秒？
package com.wxit.test02;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.TimeUnit;
/**
* @author wj
* @date 2022.01.02 21:06
*/
@Slf4j(topic = "c.Test04")
public class Test04 {
static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
log.debug("开始。。。");
test01();
}
static private void test01() throws InterruptedException {
Thread t1 = new Thread(() -> {
sleep(1);
r1 = 10;
});
Thread t2 = new Thread(() -> {
sleep(2);
r2 = 20;
}, "t2");
long start = System.currentTimeMillis();
t1.start();
t2.start();
t1.join();
t2.join();
long end = System.currentTimeMillis();
log.debug("r1:{},r2:{},花费时间:{}",r1,r2,end - start);
}
public static void sleep(int i) {
try {
TimeUnit.SECONDS.sleep(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
控制台输出如下：
21:12:08.296 c.Test04 [main] - 开始。。。
21:12:10.352 c.Test04 [main] - r1:10,r2:20,花费时间:2009
