多线程基础技术

1.1 进程与多线程

1、进程

程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等）

2、那什么是线程呢?

线程可以理解成是在进程中独立运行的子任务。比如，QQ.exe 运行时就有很多的子任务在同时运行。再如，好友视频线程、下载文件线程、传输数据线程、发送表情线程等，这些不同的任务或者说功能都可以同时运行，其中每一项任务完全可以理解成是“线程”在工作，传文件、听音乐、发送图片表情等功能都有对应的线程在后台默默地运行。这样做有什么优点呢?更具体来讲，使用多线程有什么优点呢?其实如果读者有使用“多任务操作系统”的经验，比如 Windows 系列，那么它的方便性大家应该都有体会:使用多任务操作系统 Windows后，可以最大限度地利用CPU的空闲时间来处理其他的任务，比如一边让操作系统处理正在由打印机打印的数据，一边使用 Word 编辑文档。而CPU在这些任务之间不停地切换，由于切换的速度非常快，给使用者的感受就是这些任务似乎在同时运行。所以使用多线程技术后，可以在同一时间内运行更多不同种类的任务

3、多线程优点(为什么使用多线程):

普及概念:

以调用方角度来讲，如果需要等待结果返回，才能继续运行就是同步

不需要等待结果返回，就能继续运行就是异步

在图中可以发现，CPU 完全可以在任务1和任务2之间来切换，使任务2不必等到10秒再运行，系统的运行效率大大得到提升。这就是要使用多线程技术、要学习多线程的原因。这是多线程技术的优点，使用多线程也就是在使用异步。

1.2、多线程的使用

1.2.1继承Thread类

1	`public class Thread implements Runnable`

从上面的源代码中可以发现，Thread类实现了 Runnable 接口，它们之间具有多态关系其实，使用继承Thread类的方式创建新线程时，最大的局限就是不支持多继承，因为Java语言的特点就是单根继承，所以为了支持多继承，完全可以实现 Runnable 接口的方式边实现一边继承。但用这两种方式创建的线程在工作时的性质是一样的，没有本质的区别

public class MyThread extends Thread{
    @Override
    public void run() {
        //代码就是线程在开启之后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("线程开启了" + i);
        }
    }
    public static void main(String[] args) {
        //创建一个线程对象
        MyThread t1 = new MyThread();
        //创建一个线程对象
        MyThread t2 = new MyThread();

        //t1.run();//表示的仅仅是创建对象,用对象去调用方法,并没有开启线程.
        //t2.run();
        //开启一条线程
        t1.start();
        //开启第二条线程
        t2.start();
    }
}

从图的运行结果来看，MyThread.java类中的run 方法执行的时间比较晚，这也说明在使用多线程技术时，代码的运行结果与代码执行顺序或调用顺序是无关的。

线程是一个子任务，CPU 以不确定的方式，或者说是以随机的时间来调用线程中的run方法，所以就会出现先打印“运行结束!”后输出“MyThread”这样的结果了。

两个小问题:

为什么要重写run()方法？

因为run()是用来封装被线程执行的代码
run()方法和start()方法的区别？

run()：封装线程执行的代码，直接调用，相当于普通方法的调用

start()：启动线程；然后由JVM调用此线程的run()方法

1.2.2 实现Runnable 接口

如果欲创建的线程类已经有一个父类了，这时就不能再继承自Thread类了，因为Java不支持多继承，所以就需要实现 Runnable 接口来应对这样的情况。

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程启动后执行的代码
        for (int i = 0; i < 100; i++) {

            System.out.println(Thread.currentThread().getName() + "第二种方式实现多线程" + i);
        }
    }

    public static void main(String[] args) {
        //创建了一个参数的对象
        MyRunnable mr = new MyRunnable();
        //创建了一个线程对象,并把参数传递给这个线程.
        //在线程启动之后,执行的就是参数里面的run方法
        Thread t1 = new Thread(mr);
        //开启线程
        t1.start();


        MyRunnable mr2 = new MyRunnable();
        Thread t2 = new Thread(mr2);
        t2.start();

    }
}

使用继承 Thread类的方式来开发多线程应用程序在设计上是有局限性的，因为 Java 是单根继承，不支持多继承，所以为了改变这种限制，可以使用实现 Runnable 接口的方式来实现多线程技术。 Thread(Runnable target)不光可以传人 Runnable接口的对象，还可以传人一个Thread类的对象，这样做完全可以将一个Thread 对象中的run0方法交由其他的线程进行调用。

实现Runnable接口 VS 继承 Thread

实现接口会更好一些，因为:

Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
类可能只要求可执行就行，继承整个 Thread 类开销过大。

1.2.3实现多线程方式三: 实现Callable接口

实现步骤

定义一个类MyCallable实现Callable接口
在MyCallable类中重写call()方法
创建MyCallable类的对象
创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
创建Thread类的对象，把FutureTask对象作为构造方法的参数
启动线程
再调用get方法，就可以获取线程结束之后的结果。

代码：

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();

        //Thread t1 = new Thread(mc);

        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);

        //创建线程对象
        Thread t1 = new Thread(ft);

        String s = ft.get();
        //开启线程
        t1.start();

        //String s = ft.get();
        System.out.println(s);
    }
}

三种实现方式的对比

实现Runnable、Callable接口
- 好处: 扩展性强，实现该接口的同时还可以继承其他的类
- 缺点: 编程相对复杂，不能直接使用Thread类中的方法
继承Thread类
- 好处: 编程比较简单，可以直接使用Thread类中的方法
- 缺点: 可以扩展性较差，不能再继承其他的类

1.2.4实例变量与线程安全

自定义线程类中的实例变量针对其他线程可以有共享与不共享之分，这在多个线程之间进行交互时是很重要的一个技术点。

(1)不共享数据模型



public class MyThread extends Thread {
    private int count = 5;
    public MyThread(String name) {
        super();
       
        this.setName(name);//设置线程名称
    }
    @Override
    public void run() {
        super.run();
        while (count>0){
            count--;
            System.out.println("由" + this.currentThread().getName() + "计算，count=" + count);
        }
    }
    public static void main(String[] args) {
        MyThread a = new MyThread("A");
        MyThread b = new MyThread("A");
        MyThread c = new MyThread("A");
        a.start();
        b.start();
        c.start();
    }
}

不共享数据运行结果如图所示

由图可以看到，一共创建了3个线程，每个线程都有各自的count 变量，自己减少自己的count变量的值。这样的情况就是变量不共享，此示例并不存在多个线程访问同一个实例变量的情况。
如果想实现3个线程共同对一个count 变量进行减法操作的目的，该如何设计代码呢?

(2)共享数据的情况

共享数据的情况就是多个线程可以访问同一个变量，比如在实现投票功能的软件时，多个线程可以同时处理同一个人的票数
下面通过一个示例来看下数据共享情况。

测试案例:

public class MyThread extends Thread {
    private int count = 5;
    @Override
    public void run() {
        super.run();
        count--;
        System.out.println("由" + this.currentThread().getName() + "计算，count=" + count);
    }
    public static void main(String[] args) {
        MyThread mythread = new MyThread();
        Thread a = new Thread(mythread,"A");
        Thread b = new Thread(mythread,"B");
        Thread c = new Thread(mythread,"C");
        Thread d = new Thread(mythread,"D");
        Thread e = new Thread(mythread,"E");
        a.start();
        b.start();
        c.start();
        d.start();
    }
}

从结果可以看到，线程A和B打印出的count值都是3，说明A和B同时对count 进行处理，产生了“非线程安全”问题。而我们想要得到的打印结果却不是重复的，而是依次递减的在某些JVM 中，i–的操作要分成如下3步

1)取得原有i值
2)计算 i-1。

3)对进行赋值

在这3个步骤中，如果有多个线程同时访问，那么一定会出现非线程安全问题

1.3 currentThread()方法

方法介绍

方法名	说明
void setName(String name)	将此线程的名称更改为等于参数name
String getName()	返回此线程的名称
Thread currentThread()	返回对当前正在执行的线程对象的引用

currentThread0方法可返回代码段正在被哪个线程调用的信息。下面通过一个示例进行说明。
创建项目，创建代码如下:

public class t6 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
    }
}

代码演示

public class MyThread extends Thread {
    public MyThread() {}
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

        //void setName(String name)：将此线程的名称更改为等于参数 name
        my1.setName("高铁");
        my2.setName("飞机");

        //Thread(String name)
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");

        my1.start();
        my2.start();

        //static Thread currentThread() 返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

1.4 isAlive()方法

方法isAlive0)的功能是判断当前的线程是否处于活动状态新建项目t7，类文件代码如下

public class t7 extends MyThread{
    @Override
    public void run() {
        System.out.println("run"+this.isAlive());
    }

    public static void main(String[] args) {
        t7 myThread = new t7();
        System.out.println("begin=="+myThread.isAlive());
        myThread.start();
        System.out.println("end=="+ myThread.isAlive());
    }
}

1.5 线程休眠

static void sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数

代码演示

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) throws InterruptedException {
        /*System.out.println("睡觉前");
        Thread.sleep(3000);
        System.out.println("睡醒了");*/

        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

        t1.start();
        t2.start();
    }
}

1.6 getId()方法

getId0方法的作用是取得线程的唯一标识。创建测试用的项目runThread，创建Test,java类，代码

public static void main(String[] args) {
       Thread run=Thread.currentThread();
       Thread runThread = Thread.currentThread();System.out.println(runThread.getName() +"     "+runThread.getId());
   }

1.7 线程停止

大多数停止个线程的操作使用Thread.interrupt0方法，尽管方法的名称是“停止，中止”的意思，但这个方法不会终止一个正在运行的线程，还需要加人一个判断才可以完成线程的停止。关于此知识点在后面有专门的章节进行介绍。
在Java中有以下3种方法可以终止正在运行的线:
1)使用退出标志，使线程正常退出，也就是当run 方法完成后线程终止。

2)使用stop 方法强行终止线程，但是不推荐使用这个方法，因为stop 和suspend 及resume一样，都是作废过期的方法，使用它们可能产生不可预料的结果。

3)使用interrupt 方法中断线程。

本示例将调用interrupt0方法来停止线程，但interrupt0)方法的使用效果并不像for+break 语句那样，马上就停止循环。调用interrupt0方法仅仅是在当前线程中打了一个停止的标记，并不是真的停止线程。

1.7.1 interrupt()–停止标记

本示例将调用interrupt0方法来停止线程，但interrupt0方法的使用效果并不像for+break语句那样，马上就停止循环。调用interrupt0)方法仅仅是在当前线程中打了一个停止的标记，并不是真的停止线程。


public class t11 extends Thread{
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 50000; i++) {
            System.out.println("i="+(i+1));
        }
    }
    public static void main(String[] args) {
        try {
            t11 thread=new t11();
            thread.start();
            Thread.sleep(2000);
            thread.interrupt();
        } catch (InterruptedException e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
    }
}

从运行的结果来看，调用interrupt 方法并没有停止线程。如何停止线程呢?

Java的SDK中，Threadjava类里提供了两种方法
1)this.interrupted():测试当前线程是否已经中断。
2)this.isInterrupted():测试线程是否已经中断。

下面通过代码比较两个方法

1)interrupted()


public class t11 extends Thread{
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 50000; i++) {
            System.out.println("i="+(i+1));
        }
    }
    public static void main(String[] args) {
        try {
            t11 thread=new t11();
            thread.start();
            Thread.sleep(1000);
            thread.interrupt();
            System.out.println("是否停止1？="+thread.interrupted());
            System.out.println("是否停止1？="+thread.interrupted());
        } catch (InterruptedException e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end！");
    }
}

来判断 thread 对象所代表的线程是否停止，但从控制台打印的结果来看，线程并未停止，这也就证明了interrupted0 方法的解释:测试当前线程是否已经中断。这个“当前线程是main，它从未中断过，所以打印的结果是两个 false。

如何在main线程中产生效果？

修改代码:

   public static void main(String[] args) {
        try {
            t11 thread=new t11();
            thread.start();
            Thread.sleep(1000);
            thread.interrupt();
            Thread.currentThread().interrupt();
            System.out.println("是否停止1？="+thread.interrupted());
            System.out.println("是否停止1？="+thread.interrupted());
            System.out.println("end！");
        } catch (InterruptedException e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
    }
}

为什么第2个布尔值是false呢?查看一下官方帮助文档中对interrupted 方法的解释

测试当前线程是否已经中断。线程的中断状态由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false (在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外)。
文档已经解释得很详细interrupted0方法具有清除状态的功能，所以第2次调用interrupted0方法返回的值是false。

2)isInterrupted():

   public static void main(String[] args) {
        try {
            t11 thread=new t11();
            thread.start();
            Thread.sleep(1000);
            thread.interrupt();
            //Thread.currentThread().interrupt();
            System.out.println("是否停止1？="+thread.isInterrupted());
            System.out.println("是否停止1？="+thread.isInterrupted());

        } catch (InterruptedException e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end！");
    }
}

从结果中可以看到，方法isInterrupted0并未清除状态标志，所以打印了两个 true。
最后，再来看一下这两个方法的解释

1)this.interrupted():测试当前线程是否已经是中断状态执行后具有将状态标志置清除为 false 的功能。
2)this.isInterrupted():测试线程Thread 对象是否已经是中断状态，但不清除状态标志。

1.7.2 异常法停止线程

在线程中用for语句来判断一下线程是否是停止状态，但如果 for 语句下面还有语句，还是会继续运行的。

所以

package com.text;
public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            for (int i = 0; i < 500000; i++) {
                if (this.interrupted()){
                    System.out.println("已经是停止状态！臣退了！");
                    throw new InterruptedException();
                }
                System.out.println("i="+(i+1));
            }
            System.out.println("我在for下方！");
        } catch (InterruptedException e) {
            System.out.println("进入run方法的catch中了！");
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        try {
            MyThread thread = new MyThread();
            thread.start();
            Thread.sleep(200);
            thread.interrupt();

        } catch (InterruptedException e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end!!");
    }
}

1.7.3在线程sleep()中停止

如果线程在sleep0状态下停止线程，会是什么效果呢?

public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            System.out.println("run begin...");
            Thread.sleep(200000);
            System.out.println("run sleep...");
        } catch (InterruptedException e) {
            System.out.println("sleep中的线程被停止！进入catch"+this.isInterrupted());
           e.printStackTrace();
        }
    }

从打印的结果来看，如果在 sleep 状态下停止某一线程，会进人 cath 语句，并且清除停止状态值，使之变成 false。前一个实验是先sleep 然后再用interrupt0停止，与之相反的操作在学习线程时也要注意。

1.7.4 stop()—暴力停止

使用stop0方法停止线程则是非常暴力的

public class MyThread extends Thread {
    private int i = 0;
    @Override
    public void run() {
        super.run();
        try {
          while (true) {
              i++;
              System.out.println("i="+i);
                Thread.sleep(1000);
          }
        } catch (InterruptedException e) {
           e.printStackTrace();
        }
    }
      public static void main(String[] args) {
        try {
            MyThread thread = new MyThread();
            thread.start();
            Thread.sleep(8000);
            thread.stop();
        } catch (InterruptedException e) {
           
            e.printStackTrace();
        }
      }

线程被暴力停止(stop)运行后图标呈灰色

1.8暂停线程

1.8.1suspend与resume方法的使用

暂停线程意味着此线程还可以恢复运行。在Java 多线程中，可以使用suspend()方法暂停线程，使用resume()方法恢复线程的执行。

package com.text;
import java.sql.SQLOutput;
public class MyThread extends Thread {
    private long i = 0;

    public long getI() {
        return i;
    }

    public void setI(long i) {
        this.i = i;
    }
    @Override
    public void run() {
        while (true) {
            i++;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        try {
            MyThread thread = new MyThread();
            thread.start();
            Thread.sleep(5000);
            //A段
            thread.suspend();
            System.out.println("A="+System.currentTimeMillis()+"i =" + thread.getI());
            Thread.sleep(5000);
            System.out.println("A="+System.currentTimeMillis()+"i =" + thread.getI());
            //B段
            thread.resume();
            Thread.sleep(5000);
            //C段
            thread.suspend();
            System.out.println("B ="+System.currentTimeMillis()+"  i=" + thread.getI());
            Thread.sleep(5000);
            System.out.println("B ="+System.currentTimeMillis()+"  i=" + thread.getI());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}

从控制台打印的时间上来看，线程的确被暂停了，而且还可以恢复成运行的状态。

1.8.2 suspend 与resume 方法的缺点-独占(死锁)

在使用suspend与resume 方法时，如果使用不当，极易造成公共的同步对象的独占(死锁)，使得其他线程无法访问公共同步对象。


public class SynchronizedObject {
        synchronized public void printString() {
            System.out.println("begin..");
            if (Thread.currentThread().getName().equals("a")) {
                System.out.println("a线程永远的suspend了！！ ");
                Thread.currentThread().suspend();
            }
            System.out.println("end");
        }
    }

package com.text;
import com.text.SynchronizedObject;
public class Run {
    public static void main(String[] args) {
        try {
            final SynchronizedObject object = new SynchronizedObject();
            Thread thread1 = new Thread() {
                @Override
                public void run() {
                    object.printString();
                }
            };
            thread1.setName("a");
            thread1.start();
            Thread.sleep(1000);
            Thread thread2 = new Thread() {
                @Override
                public void run() {
                    System.out.println("thread2启动了，但无法进入pringString()方法！" +
                            "只打印一个begin");
                    System.out.println("printString方法被a线程锁定所以永久" +
                            "supend 暂停了");
                    object.printString();
                }
            };
            thread2.start();
        } catch (InterruptedException e) {
           e.printStackTrace();
        }
    }
}

独占锁死了 printString方法

1.8.3 suspend与resume 方法的缺点一不同步

在使用suspend与resume方法时也容易出现因为线程的暂停而导致数据不同步的情况

public class MyObject {
    private String username="1";
    private String password = "11";
    public void setValue(String u,String p){
        this.username=u;
        if (Thread.currentThread().getName().equals("a")){
            System.out.println("a停止线程");
            Thread.currentThread().suspend();
        }
        this.password = p;
    }
    public void print(){
        System.out.println(username+" "+password);
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final MyObject myobject = new MyObject();
        Thread thread1 = new Thread() {
            public void run() {
                myobject.setValue("a", "aa");
            };
        };
        thread1.setName("a");
        thread1.start();
        Thread.sleep(500);
        Thread thread2 = new Thread() {
            public void run() {
                myobject.print();

            };
        };
                thread2.start();
        }
    }

程序运行的结果出现值不同步的情况，所以在程序中使用 suspend()方法要格外注意关于如何解决这些问题，请看后面的章节。

1.9线程优先级【应用】

线程调度
- 两种调度方式
  - 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
  - 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
- Java使用的是抢占式调度模型
- 随机性
  
  假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

优先级相关方法

方法名	说明
final int getPriority()	返回此线程的优先级
final void setPriority(int newPriority)	更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

代码演示

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}
public class Demo {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();

        FutureTask<String> ft = new FutureTask<>(mc);

        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());//5
        t1.start();

        MyCallable mc2 = new MyCallable();

        FutureTask<String> ft2 = new FutureTask<>(mc2);

        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());//5
        t2.start();
    }
}

可见没有先后顺序，所以优先级在操作系统前并不好使！

1.7.6守护线程【应用】

相关方法

方法名说明

void setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

方法名	说明
void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

代码演示!

public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.setName("女神");
        t2.setName("备胎");

        //把第二个线程设置为守护线程
        //当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
        t2.setDaemon(true);

        t1.start();
        t2.start();
    }
}

可见守护线程要等普通线程运行完再运行或者停止！

多线程🤷‍♂️

#多线程

多线程基础技术

https://1902756969.github.io/Hexo/2022/11/30/多线程/java多线程基础技术/

作者

星

发布于

2022年11月30日

许可协议

多线程基础技术② 上一篇

百度云不限速下一篇