多线程深入话题

优雅的停止线程

在多线操作之中如果要启动多线程使用的是Thread类中的start()方法，而如果对于多线程需要进行停止处理，Thread类原本提供了stop()方法，但是对于这些方法从JDK1.2版本就已经废除了，而且一直到现在也不再建议使用，而除了stop()之外还有几个方法也被禁用了：

停止多线程：public final void stop()；
销毁多线程：public void destroy()；
挂起线程：public final void suspend()、暂停执行；
恢复挂起的线程执行：public final void resume()；
之所以废除掉这些方法，主要原因是因为这些方法可能导致线程死锁，所以从JDK1.2后开始都不再建议使用了。所以，如果要想实现线程的停止需要通过一种柔和的方式来进行。
范例：实现线程柔和的停止

public class ThreadDemo {
    public static boolean flag = true;
    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            long num = 0;
            while (flag) {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在运行、num = " + num++);
            }
        }, "执行线程").start();
        Thread.sleep(200);//运行200毫秒
        flag = false;//停止线程
    }
}

万一现在有其他线程去控制这个flag的内容，那么这个时候对于线程的停止也不是说停就立刻停止的，而是会在执行中判断flag的内容来完成。

守护线程

现在假设有一个保镖，那么这个保镖一定是在雇主活着时候进行守护，雇主死了，保镖就没用了。所以在多线程中可进行守护线程的定义，也就是说如果现在主线程的程序或者其他线程还在执行的时候，那么守护线程将一直存在，并且运行在后台状态。
在Thread类中提供有如下的守护线程的操作方法：

设置为守护线程：public final void setDaemon(boolean on)；
判断是否为守护线程：public final boolean isDaemon()；
范例：使用守护线程

public class ThreadDemo {
    public static void main(String[] args) throws Exception {
        Thread userThread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在运行、x = " + i);
            }
        }, "用户线程");//完成核心业务
        Thread deamonThread = new Thread(() -> {
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在运行、x = " + i);
            }
        }, "守护线程");//完成核心业务
        userThread.start();
        deamonThread.setDaemon(true);//设置为守护线程
        deamonThread.start();
    }
}

可以发现所有的守护线程都是围绕在用户线程的周围，如果程序执行完毕了，守护线程也就消失了，在整个JVM中最大的守护线程就是GC线程。
程序执行中GC线程会一直存在，如果程序执行完毕，GC线程也将消失。

volatile关键字

在多线程定义中，volatile关键字主要是在属性上使用的，表示此属性为直接数据操作，而不进行副本的拷贝处理。在一些书上就错误的理解为同步属性了。
在正常进行变量处理的时候往往会经历如下的几个步骤：

获取变量的数据内容；
为变量进行数学计算；
将计算后的变量，保存到原始空间之中；
而如果一个属性上追加了volatile关键字，表示的就是不使用副本，而是直接操作原始变量，相当于节约了拷贝副本、重新保存的步骤。

volatile

class MyThread implements Runnable {
    private volatile int ticket = 5;//直接内存操作
    @Override
    public void run() {
        synchronized (this){
            while (this.ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖票，ticket = " + this.ticket--);
            }
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) throws Exception {
        MyThread mt = new MyThread();
        new Thread(mt, "票贩子A").start();
        new Thread(mt, "票贩子B").start();
        new Thread(mt, "票贩子C").start();
    }
}

最后编辑于：2019.07.22 20:09:36