Java多线程线程的启动和停止

线程的启动：

参考官网文档

调用线程的start办法，告诉jvm虚拟机去调用该线程的run办法，后果是两个线程并发的执行，一个是以后线程（调用start办法的线程），一个执行run办法的线程

如示例：

public class ThreadTest {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName());
        });
        thread.start();
        System.out.println(Thread.currentThread().getName());
    }
}

打印出两个线程名称为：

main 执行start办法d main线程
Thread-0  新建的执行run办法的线程0

留神的点：

1.多个线程start办法的程序并不能决定线程真正执行的程序。

须要期待CPU的资源，是异步随机执行的，如下示例：

public class ThreadTest {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + ": run");
            }
        };
        Thread thread1 = new Thread(r);
        Thread thread2 = new Thread(r);
        Thread thread3 = new Thread(r);
        Thread thread4 = new Thread(r);
        Thread thread5 = new Thread(r);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
}

打印后果是随机的：

Thread-0: run
Thread-2: run
Thread-1: run
Thread-3: run
Thread-4: run

2.start办法不能反复调用，哪怕线程曾经执行结束也不能再次执行，否则将抛出线程状态异样，前面说线程的状态能够理解。

3.和run办法的区别：为什么不必run办法启动线程

如文档解释，start办法是以后线程执行start办法，通知jvm虚拟机用新建的线程是执行run办法。而run办法就是以后线程之间执行了run办法，并没有应用新建的线程。

进行线程：

应用interrupt()办法中断线程，须要留神的是，该办法是一个线程去告诉另一个线程去中断，被中断的线程本身决定是否进行，非强行进行；

思考如下：

被进行线程更分明该如何进行，比方某个线程a正在执行run办法，如果其它线程b调用了a的interrupt()办法告诉其进行，a应该本身决定如何响应，是继续执行，还是纪录一些日志，解决完一个阶段的业务再进行，如果a被b强制进行，则a执行的业务将产生脏数据，安全性较差。所以进行线程的最佳办法就是告诉该线程去进行，该线程能够自行判断本身是否已被中断（

isInterrupted()办法判断），而后正当响应；stop()办法，强制进行，已过期；

示例：

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("我始终在执行");
                    if (Thread.currentThread().isInterrupted()) {
                        System.out.println("好的，我进行了");
                        break;
                    }
                }
            }
        };
        Thread thread = new Thread(r);
        thread.start();
        Thread.sleep(10);
        thread.interrupt();
    }
}

打印后果：

...
我始终在执行
我始终在执行
我始终在执行
我始终在执行
我始终在执行
好的，我进行了

如代码示例，被告诉中断的线程配合做了解决（if判断）自主决定中断还是继续执行；

进一步思考，如果线程没有在执行，而是在阻塞状态，如下run示例：

public void run() {
                while (true) {
                    System.out.println("我始终在执行");
                    Thread.sleep(10000);
                    if (Thread.currentThread().isInterrupted()) {
                        System.out.println("好的，我进行了");
                        break;
                    }
                }
            }

线程阻塞在sleep办法时，这时候内部线程告诉中断，但这里曾经阻塞无奈进到if判断，该如何响应，sleep办法曾经思考到了，这个办法强制要求咱们解决InterruptedException异样，即中断异样，来响应内部的中断告诉。

如示例：

public void run() {
                while (true) {
                    System.out.println("我始终在执行");
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        System.out.println("好的我晓得了");
                    }
                    if (Thread.currentThread().isInterrupted()) {
                        System.out.println("好的，我进行了");
                        break;
                    }
                }
            }

另外批改后的办法理论执行的话，while循环并没有进行，线程并没有完结，这是为什么呢？这是因为抛出异样的同时会将该线程的isInterrupted重置为false；能够查看InterruptedException的正文：

抛出InterruptedException的时候，会革除是否中断的标记位！

其它：

如果run办法执行结束或抛出异样，该线程也会进行；

— END —

马上关注    /    码上杂谈