Thread类的基本用法：线程创建、中断、等待、获取实例

最新推荐文章于 2024-04-09 04:18:18 发布

我叫小泥

最新推荐文章于 2024-04-09 04:18:18 发布

阅读量483

点赞数 1

文章标签： java 开发语言 java-ee

本文链接：https://blog.csdn.net/weixin_62490144/article/details/128011879

版权

首先我们再来回顾一下线程相较于进程，有哪些优点：

1.创建线程比创建进程更快.

2.销毁线程比销毁进程更快.

3.调度线程比调度进程更快.

在初期学习的时候，Thread用法尤其重要，今天我们来看看Thread的基本用法。

一、线程的创建：

在我之前的博客末尾，已经为大家详细讲解了线程创建的方法：

(9条消息) javaee进程与线程_我叫小泥的博客-CSDN博客https://blog.csdn.net/weixin_62490144/article/details/127974918?spm=1001.2014.3001.5501今天我再带大家回顾一下lambda方法创建线程：

lambda创建线程是我们建议的线程创建方法。

package thread;

public class thread {
    public static void main(String[] args) throws InterruptedException {
       Thread t = new Thread(()->{
           System.out.println("创建的新线程应该做的任务内容");
       });
       t.start();//真正创建了这个新线程。
    }
}

二、线程的中断

关于线程的终止（中断）：这里终止（中断）的意思，不是让线程立马就停止，而仅仅是通知线程，你要停止了，但是能不能真的停止，是取决于线程具体的代码写法。

举个实际例子：

你正在打游戏，你妈妈让你下楼买两个馒头，你有如下选择：

立马关掉游戏去买馒头；打完游戏再去买；假装没听见，不去买。

1.使用共享的标志位来控制线程是否要终止：

注意此处的sleep用法：如果没有sleep线程很快就会执行完毕，所以设置sleep方便大家观察，哪个线程调用Thread.sleep(),谁就会进入sleep状态，括号里是休息的毫秒数，1000毫秒对应一秒。

我们这里通过t.start调用了新线程之后，main就会sleep两秒后再执行。而新线程t调用的话，就是打印完内容后，sleep一秒后再执行。

package thread;

public class thread {
    public static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
       Thread t = new Thread(()->{
           while(flag){
               System.out.println("创建的新线程应该做的任务内容");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
       });
       t.start();//真正创建了这个新线程。
        Thread.sleep(2000);
        flag = false;
    }
}

说明：自定义的方式，是不能及时响应的，尤其是在sleep时间比较长的时候。这里的代码之所以能够起到修改flag就可以将线程停止，是完全取决于t线程内部的代码的，因为t的内部是通过flag来控制循环运行的。因此，和我们之前举例情况一样，flag只是告诉线程要终止，但是线程终止与否，完全由线程内部的代码决定。

2.使用 Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替自定义标志位.

调用t.interrupt();我们就可以终止线程，这里的interrupt()会做两件事情：

1.首先会把标志位由false改为true;

2.其次，如果线程在运行sleep，那么sleep就会被打断，提前返回。（相当于我们假期在睡觉的过程中，突然被老妈破门打断。）

我们首先来看第一段代码：大家注意我这里的while循环逻辑：前面加了一个！（非），就是线程不中断的时候，是true，会继续执行循环；中断的时候，会变为false，就停止执行程序了。大家要拐过这个弯来~

package thread;

public class thread {
    public static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
       Thread t = new Thread(()->{
           while(!Thread.currentThread().isInterrupted()){
               System.out.println("创建的新线程应该做的任务内容");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                 throw new RuntimeException(e);
               }
           }
       });
       t.start();

Thread.sleep(3000);

        t.interrupt();
    }
}

此处的throw new RuntimeException(e);是指，当捕获到sleep异常，抛出异常后，代码就会终止！

我们可以看到，此处捕获到sleep的异常后，程序终止执行。但是，我们对异常的处理稍作改动，我们不再抛出异常后停止，仅仅只让异常抛出，运行结果会是如何呢？请看我调整后的代码：

package thread;

public class thread {
    public static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
       Thread t = new Thread(()->{
           while(!Thread.currentThread().isInterrupted()){
               System.out.println("创建的新线程应该做的任务内容");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                 e.printStackTrace();
               }
           }
       });
       t.start();//真正创建了这个新线程。

Thread.sleep(3000);

        t.interrupt();
    }
}

运行结果如下：

我们可以看到，抛出了异常之后，线程仍在执行！！这是为什么呢？答案就藏在sleep当中。

我们前面知道，interrupt会打断sleep让其提前返回并且将标志位由false改为true，理应不该继续执行了。但是这里的sleep又搞了个小动作，就是将标志位，由true又改回false了（注意我们前面加了！，所以改回false后循环才继续执行）。因此，线程就会继续循环，打印内容了。

所以此处，我们再引出一个知识点：如果线程因为调用 wait/join/sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通知，清除中断标志。

因此，我们在捕获异常了之后，就会进入catch执行，在此我们可以人为的选择中断还是不中断。相当于编译器把中断的选择权留给了程序员自己。像上面的就是程序忽视了中断的指令。接下来，我们看看如何手动终止。

package thread;

public class thread {
    public static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
       Thread t = new Thread(()->{
           while(!Thread.currentThread().isInterrupted()){
               System.out.println("创建的新线程应该做的任务内容");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                 e.printStackTrace();
                 break;
               }
           }
       });
       t.start();//真正创建了这个新线程。

Thread.sleep(3000);

        t.interrupt();
    }
}

结果：我们可以看到，线程没有继续循环,线程终止了。

此外我们还可以搭配sleep，使得线程稍后终止：

代码：

package thread;

public class thread {
    public static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("创建的新线程应该做的任务内容");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ex) {
                        e.printStackTrace();
                        break;
                    }
                }
            }
        });
        t.start();

        Thread.sleep(3000);

        t.interrupt();
    }
}

由于执行结果和上面是一样的，大家自己运行一下可以看到，这个会慢一些打印结果。

三、线程的等待

有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。例如，张三只有等李四转账成功，才决定是否存钱，这时我们需要一个方法明确等待线程的结束。

方法：

方法	说明
public void join()	等待线程结束
public void join(long millis)	等待线程结束，最多等 millis 毫秒
public void join(long millis, int nanos)	同理，但可以更高精度

我们先来看第一段代码：

package thread;

public class thread {
    public static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
       Thread t = new Thread(()->{
               System.out.println("创建的新线程应该做的任务内容");
           }
       );
       t.start();//真正创建了这个新线程。
        System.out.println("join执行前");
        System.out.println("join执行后");
    }
}

大家可以看到，这里代码的运行结果是不一样的。还记得吗，我们之前就说过，线程之间，对资源是抢占式的，到底谁先打印是完全随机的，无法预测的。大家注意，我们main只是创建了一个新的线程，新线程和main这个线程是完全抢占式执行的，谁先强上资源谁就先执行。千万不要认为此处是先执行某个线程的。

我们加入join之后来看看：

代码：

package thread;

public class thread {
    public static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
       Thread t = new Thread(()->{
               System.out.println("创建的新线程应该做的任务内容");
           }
       );
       t.start();
        t.join();
        System.out.println("join执行后");
    }
}

这里，我们最后一行打印，必须是等待t这个线程打印完才可以打印。

执行结果：

但是也要注意，如果线程已经执行完了，我们再等待就没有意义了，我们来看看下面的代码。

package thread;

public class thread {
    public static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            for (int i = 0; i < 3; i++) {
                System.out.println("创建的新线程应该做的任务内容");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ex) {
                        e.printStackTrace();
                        break;
                    }
                }
            }
        });
        t.start();
        Thread.sleep(5000);
        System.out.println("join之前");
        t.join();
        System.out.println("join之后");
    }
}

结果：

四、获取线程的实例：

代码：我们之前说过了，哪里调用Thead.currentThread();就返回哪里的线程对象引用。

我们可以看到打印的结果是main,就是指当前引用的线程是main线程。

package thread;

public class thread {
    public static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.currentThread();
        System.out.println(t.getName());
    }
}

结果：