java interruput_如何正确停止线程

这个话题完全是由于 http://lizhe.name.csdn.net/node/102 带出来的

在谈论这个话题之前,首先我要申明一个概念, java本身不推荐你杀死任何线程而是推荐你要"让它自己运行完毕",然后我们来看下面几个概念

1. stop是不安全的, stop会释放持有的全部锁然后直接杀死线程,可能会造成数据不一致,而且已经过期,会立即杀死线程

2. interruput 不会立即杀死线程

当线程处于运行状态时,interrupt不会终止线程,只是设置了一个表示位

当线程处于阻塞状态(如调用sleep、wait、join等地方) 会抛出一个异常InterruptedException，并且中断状态也将被清除，这样线程就得以退出阻塞的状态

3. ExecutorService shutdown方法会让线程池停止接受新任务,但是不会终止或暂停任何当前持有的任务

4. ExecutorService shutdownNow方法会让线程池停止接受新任务,然后调用对所有任务调用interruput方法(具体做了什么参考第二条), 所以也不会立即终止持有的线程

5. 如果需要使用interruput方法来终止线程

方案1 : 使用interruput自带的标志位

public class Test {

public static void main(String args[]) throws InterruptedException{

Thread t = new Thread(new Runnable(){

@Override

public void run() {

while(!Thread.currentThread().isInterrupted()){

System.out.println("running...");

}

}

});

t.start();

Thread.sleep(1000);

t.interrupt();

}

}

方案2: 使用volatile关键字的表示位

public class Test {

volatile static boolean stop = false;

public static void main(String args[]) throws InterruptedException{

Thread t = new Thread(new Runnable(){

@Override

public void run() {

while(!stop){

System.out.println("running...");

}

}

});

t.start();

Thread.sleep(1000);

stop=true;

}

}

方案3: 使用中断让线程抛出InterruptedException

public class Test {

public static void main(String args[]) throws Exception{

Thread t = new Thread(new Runnable(){

@Override

public void run() {

while(true){

try {

Thread.currentThread().sleep(1);

} catch (InterruptedException e) {

e.printStackTrace();

break;

}

System.out.println("running...");

}

}

});

t.start();

Thread.sleep(1000);

t.interrupt();

}

}

也就是说在http://lizhe.name.csdn.net/node/102中我尝试通过shutdownNow方法来停止所有线程的方法是完全错误的

实际上这个例子更好的实现方式应该是使用序列+消费者模型

将所有students压入一个栈, 注意栈的pop方法是线程安全的(synchronized),如果你要自己实现队列需要注意这一点

然后通过4个线程轮询去消费栈中的内容,一旦某个线程找到了我们需要的对象,就修改volatile关键字标示的一个flag标志位,然后终止其它线程

不过这里还是有一个坑, 你不能直接使用一个简单的布尔值来作为表示位 比如 volatile static boolean done = false;

这个对象在传入线程对象的时候 比如 new Worker(data, done) 实际上会传递一个值拷贝(而不是引用拷贝),所以无论你在子线程中如何修改这个表示位,都不会影响原值(被拷贝的值)

你需要使用数组或者是一个类的对象引用来持有这个表示位,这样传递的是类的引用拷贝, 和经典的swap函数是一个道理

具体代码如下

package com.lz.exe;

import java.util.List;

import java.util.Stack;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import java.util.concurrent.FutureTask;

import java.util.stream.Collectors;

import com.lz.bean.Flag;

import com.lz.bean.Student;

import com.lz.tool.DataFactory;

import com.lz.tool.Worker;

public class Executor {

volatile static boolean done = false; //错误的方式

public static void main(String args[]) {

// List data = DataFactory.getRandomDummyData(10000000);

Stack data = DataFactory.getDummyData(20);

ExecutorService executor = Executors.newFixedThreadPool(2);

Flag flag = new Flag();

String result = "NONE";

/** 错误的方式

Future f1 = executor.submit(new Worker(data, done));

Future f2 = executor.submit(new Worker(data, done));

Future f3 = executor.submit(new Worker(data, done));

Future f4 = executor.submit(new Worker(data, done));

**/

Future f1 = executor.submit(new Worker(data, flag));

Future f2 = executor.submit(new Worker(data, flag));

Future f3 = executor.submit(new Worker(data, flag));

Future f4 = executor.submit(new Worker(data, flag));

Long start = System.currentTimeMillis();

System.out.println("started");

try {

if (f1.get() != "") {

result = f1.get();

System.out.println(1);

}

if (f2.get() != "") {

result = f2.get();

System.out.println(2);

}

if (f3.get() != "") {

result = f3.get();

System.out.println(3);

}

if (f4.get() != "") {

result = f4.get();

System.out.println(4);

}

} catch (Exception e) {

e.printStackTrace();

} finally {

executor.shutdownNow();

}

Long end = System.currentTimeMillis();

executor.shutdown();

System.out.println(result);

System.out.println(end - start);

}

}package com.lz.tool;

import java.util.ArrayList;

import java.util.List;

import java.util.Stack;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import com.lz.bean.Student;

public class DataFactory {

public static List getRandomDummyData(int count){

List list = Stream.generate(Math::random).distinct().filter(i -> i < 1).limit(count).map(i -> i * 100000)

.map(Double::intValue).collect(Collectors.toList());

List students = new ArrayList();

for(Integer i:list){

Student stu = new Student("name"+i,i);

students.add(stu);

}

return students;

}

public static Stack getDummyData(int count){

Stack students = new Stack();

for(int i=0;i

Student stu = new Student("name"+i,i);

students.add(stu);

}

return students;

}

}package com.lz.tool;

import java.util.Stack;

import java.util.concurrent.Callable;

import com.lz.bean.Flag;

import com.lz.bean.Student;

public class Worker implements Callable{

private Stack students;

volatile private boolean done= false; //错误的方式

private Flag flag;

public Worker(Stack students, boolean done) {

this.students = students;

this.done = done;

}

public Worker(Stack students, Flag flag) {

this.students = students;

this.flag = flag;

}

@Override

public String call() throws Exception {

String result = "";

while(!flag.done){

if(!students.isEmpty()){

Student stu = students.pop();

System.out.println("doing "+stu.getAge()+" "+Thread.currentThread() + " " + flag.done);

if(stu.getAge()==10){

result = stu.getName();

flag.done = true;

break;

}

}

}

return result;

}

}package com.lz.bean;

public class Student {

private String name = "";

private int age;

public Student(String name, int age){

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

//        System.out.println("call get age for"+age+" "+Thread.currentThread());

return age;

}

public void setAge(int age) {

this.age = age;

}

}package com.lz.bean;

public class Flag {

public volatile boolean done = false;

}