Java线程(Thread)四种停止方式代码实例

在Java语言中，线程是非常常见的概念。在多线程编程过程中，需要经常使用到线程的停止操作。Java线程的停止方法有四种，分别是：

1. 调用stop方法停止线程
2. 使用interrupt方法打断线程
3. 使用volatile布尔变量作为停止标志
4. 使用线程阻塞等待退出

下面详细介绍这四种方式的代码实例。

1. 调用stop方法停止线程

调用stop方法可以立即终止一个线程，但是该方法已经被标记为过时方法，不建议使用。

public class StopThreadTest extends Thread {
    @Override
    public void run() {
        System.out.println("线程开始执行...");
        // 模拟线程执行耗时操作
        for (int i = 0; i < 1000000; i++) {
            // 模拟线程耗时操作
            Math.random();
        }
        System.out.println("线程执行完毕...");
    }

    public static void main(String[] args) throws InterruptedException {
        StopThreadTest thread = new StopThreadTest();
        thread.start();
        thread.stop(); // 停止线程
        thread.join(); // 等待线程执行完毕
        System.out.println("主线程执行完毕...");
    }
}

在上面的代码中，我们调用stop方法停止了一个执行了一段时间的线程，但是这样的停止方式并不安全，因为调用stop方法会立即终止线程，并且会释放锁，可能会导致数据不一致等问题。

2. 使用interrupt方法打断线程

使用interrupt方法可以打断线程的执行，但是线程并不会立即停止，需要在线程中判断是否被打断并做出相应的处理。

public class InterruptThreadTest extends Thread {
    @Override
    public void run() {
        System.out.println("线程开始执行...");
        try {
            // 模拟线程耗时操作
            for (int i = 0; i < 1000000; i++) {
                if (Thread.interrupted()) {
                    System.out.println("线程被打断，停止执行...");
                    return;
                }
                // 模拟线程耗时操作
                Math.random();
            }
            System.out.println("线程执行完毕...");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        InterruptThreadTest thread = new InterruptThreadTest();
        thread.start();
        Thread.sleep(1000); // 等待线程执行一会儿
        thread.interrupt(); // 打断线程
        thread.join(); // 等待线程执行完毕
        System.out.println("主线程执行完毕...");
    }
}

在上面的代码中，我们在线程中判断是否被打断，如果被打断则停止线程的执行。在主线程中运行了一段时间后，我们使用interrupt方法打断了线程的执行，然后使用join方法等待线程执行完毕。

3. 使用volatile布尔变量作为停止标志

使用volatile关键字修饰的布尔变量可以用作线程的停止标志。在线程中判断该标志并作出相应的处理。

public class VolatileThreadTest extends Thread {
    private volatile boolean stopFlag = false;

    public void setStopFlag(boolean stopFlag) {
        this.stopFlag = stopFlag;
    }

    @Override
    public void run() {
        System.out.println("线程开始执行...");
        // 模拟线程耗时操作
        for (int i = 0; i < 1000000; i++) {
            if (stopFlag) {
                System.out.println("线程停止执行...");
                return;
            }
            // 模拟线程耗时操作
            Math.random();
        }
        System.out.println("线程执行完毕...");
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileThreadTest thread = new VolatileThreadTest();
        thread.start();
        Thread.sleep(1000); // 等待线程执行一会儿
        thread.setStopFlag(true); // 停止线程
        thread.join(); // 等待线程执行完毕
        System.out.println("主线程执行完毕...");
    }
}

在上面的代码中，我们使用一个volatile修饰的布尔变量stopFlag作为线程的停止标志。在线程中判断该标志是否为true，如果为true则停止执行。在主线程中运行了一段时间后，我们将stopFlag修改为true，停止线程的执行，然后使用join方法等待线程执行完毕。

4. 使用线程阻塞等待退出

使用Wait和Notify方法可以让线程阻塞并等待通知，从而安全地停止线程。

public class BlockedThreadTest extends Thread {
    private boolean stopFlag = false;

    public synchronized void stopThread() {
        stopFlag = true;
        notify(); // 通知等待的线程
    }

    @Override
    public synchronized void run() {
        System.out.println("线程开始执行...");
        try {
            while (!stopFlag) {
                // 模拟线程耗时操作
                Math.random();
                wait(); // 线程进入等待状态
            }
            System.out.println("线程执行完毕...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        BlockedThreadTest thread = new BlockedThreadTest();
        thread.start();

        Thread.sleep(1000); // 等待线程执行一会儿
        thread.stopThread(); // 停止线程
        thread.join(); // 等待线程执行完毕

        System.out.println("主线程执行完毕...");
    }
}

在上面的代码中，我们使用Wait和Notify方法，让线程阻塞并等待通知。当stopFlag为true时，线程停止等待，退出执行。在主线程中运行了一段时间后，我们调用stopThread方法通知等待的线程停止执行，然后使用join方法等待线程执行完毕。

以上是四种Java线程停止方式的实例代码，每一种方式都有自己的优点和缺点，需要根据实际情况选择合适的停止方式。