文章目录
- 线程创建
- 线程中断
- 线程等待
- 线程休眠
线程创建
方法一：用一个类 继承Thread 重写run方法
//创建一个类 继承Thread
class MyThread extends Thread {
//run方法是线程的入口
@Override
public void run() {
while (true){
System.out.println("hello Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
这样一个线程就创建好了，然后可以创建MyThread实例。
public class demo1 {
public static void main(String[] args) throws InterruptedException {
Thread thread = new MyThread();//向上转型 也可以写成MyThread myThread = new MyThread();
//运行线程
thread.start();
while (true){
System.out.println("hello main");
//每1000毫秒打印一次 也就是休眠一秒
Thread.sleep(1000);
}
}
}
方法二：实现 Runnable 接口 重写run方法
class MyRunnable implements Runnable {
@Override
public void run() {
while (true){
System.out.println("hello Runnable");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
我们可以通过实现Runnable接口来实现创建线程
public class demo2 {
public static void main(String[] args) throws InterruptedException {
//runnable表示的是一个可运行的任务 这个任务是交给线程来负责执行的
Runnable runnable = new MyRunnable();
Thread t = new Thread(runnable);
t.start();
while (true){
System.out.println("jello main");
Thread.sleep(1000);
}
}
}
方法三：使用匿名内部类，继承Thread 重写run方法
public class demo3 {
public static void main(String[] args) throws InterruptedException {
//使用匿名类创建 Thread 子类对象
Thread t = new Thread(){
@Override
public void run() {
while (true){
System.out.println("thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
};
t.start();
while (true){
System.out.println("main");
Thread.sleep(1000);
}
}
}
方法四：使用匿名内部类，实现Runnable 重写run方法
public class demo4 {
public static void main(String[] args) {
//使用匿名内部类创建 Runnable 子类对象
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true){
System.out.println("thread");
}
}
});
t.start();
while (true){
System.out.println("main");
}
}
}
方法五：使用 lambda 表达式创建 Runnable 子类对象
public class demo5 {
public static void main(String[] args) {
//lambda 表达式创建 Runnable 子类对象
//lambda 表达式本质上是一个匿名函数
Thread t = new Thread(()->{
while (true){
System.out.println("thread");
}
});
t.setDaemon(true);
t.start();
}
}
Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。
创建好线程之后我们可以运行程序观察线程，多线程运行的时候我们可以使用jdk的bin目录下的 jconsole.exe 来观察该进程里多线程的情况。如果运行 jconsole.exe 什么都不显示，就需要以管理员的方式运行。
Thread类的常见构造方法
| 方法 | 说明 |
|---|---|
| Thread() | 创建线程对象 |
| Thread(Runnable target) | 使用 Runnable 对象创建线程对象 |
| Thread(String name) | 创建线程对象，并命名 |
| Thread(Runnable target, String name) | 使用 Runnable 对象创建线程对象，并命名 |
**Thread 的几个常见属性 **
| 属性 | 获取方法 |
|---|---|
| ID | getId() |
| 名称 | getName() |
| 状态 | getState() |
| 优先级 | getPriority() |
| 是否为后台线程 | isDaemon() |
| 是否存活 | isAlive() |
| 是否被中断 | isInterrupted() |
- ID 是线程的唯一标识，不同线程不会重复
- 状态就是表示线程当前所处的一个情况
- 优先级高的线程理论上来说更容易被调度到
- 关于后台线程也可以叫守护线程，后台线程不结束也不会影响整个线程的结束，但是如果一个前台线程没有执行结束，那么整个进程也一定不会结束（JVM会在一个进程的所有非后台线程结束后，才会结束运行）
- 是否存活，就是 run 方法是否运行结束
线程中断
在Java里面中断/销毁一个线程其实就是让run尽快执行结束，我们可以在代码中手动创建标志位来作为run的结束条件。
public class demo6 {
private static boolean isQuit = false;//设置标志位
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
System.out.println("线程正在工作");
while (!isQuit){
System.out.println("thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("线程工作结束");
});
t.start();
Thread.sleep(5000);
isQuit=true;
System.out.println("hello");
}
}
运行结果
上述方法手动创建标志位，当线程内部sleep的时候，，主线程修改变量，新线程不能及时响应，我们就可以使用Thread.currentThread().isInterrupted() 来代替自定义标志位。Thread 内部包含了一个 boolean 类型的变量作为线程是否被中断的标记 。
| 方法 | 说明 |
|---|---|
| public void interrupt() | 中断对象关联的线程，如果线程正在阻塞，则以异常方式通知， 否则设置标志位 |
| public static boolean interrupted() | 判断当前线程的中断标志位是否设置，调用后清除标志位 |
| public boolean isInterrupted() | 判断对象关联的线程的标志位是否设置，调用后不清除标志位 |
public class demo7 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
//Thread类内部 有一个标志位 可以用来判断当前的循环是否要结束
//Thread.currentThread()就是获取当前线程
while (!Thread.currentThread().isInterrupted()){
System.out.println("线程正在工作");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
//break; //加了break后会立即中断
//我们可以加一些其他的代码 然后再break 这样我们可以有更多的操作空间
}
}
});
t.start();
Thread.sleep(5000);
System.out.println("通过标志位使t线程终止");
//interrupt可以使sleep内部出现一个异常 从而使线程被提前唤醒 手动创建出的标志位无法达到这个效果
t.interrupt();//把上述标志位设置为true 即使线程内部出现阻塞 也可以被唤醒
}
}
我们观察上面代码的运行结果
虽然异常出现了，sleep被唤醒但是循环没有终止，t 线程任然在继续工作，并没有停止。Java这样设定是因为，当java收到要中断信息的时候，我们希望它可以自由决定接下来怎么处理。
线程等待
等待一个线程我们使用 join()
public class demo8 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("线程开始工作");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
System.out.println("线程开始等待");
t.join();//主线程等待 t 线程结束 谁调用join谁是被等的
System.out.println("等待结束");
}
}
一旦调用 join 主线程就会发生阻塞，这样 t 线程就可以完成后面的工作，主线程要一直阻塞到 t 线程执行结束才会解除阻塞。
| 方法 | 说明 |
|---|---|
| public void join() | 等待线程结束 |
| public void join(long millis) | 等待线程结束，最多等 millis 毫秒 |
| public void join(long millis, int nanos) | 等待线程结束，但可以更高精度 最多等 nanos 纳秒 |
线程休眠
| 方法 | 说明 |
|---|---|
| public static void sleep(long millis) throws InterruptedException | 休眠当前线程 millis 毫秒 |
| public static void sleep(long millis, int nanos) throws InterruptedException | 休眠当前线程 nanos 纳秒 |
public class demo11 {
public static void main(String[] args) throws InterruptedException {
System.out.println(System.currentTimeMillis());
Thread.sleep(3 * 1000);//休眠三秒
System.out.println(System.currentTimeMillis());
}
}
