这个话题完全是由于 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<Student> data = DataFactory.getRandomDummyData(10000000);
Stack<Student> data = DataFactory.getDummyData(20);
ExecutorService executor = Executors.newFixedThreadPool(2);
Flag flag = new Flag();
String result = "NONE";
/** 错误的方式
Future<String> f1 = executor.submit(new Worker(data, done));
Future<String> f2 = executor.submit(new Worker(data, done));
Future<String> f3 = executor.submit(new Worker(data, done));
Future<String> f4 = executor.submit(new Worker(data, done));
**/
Future<String> f1 = executor.submit(new Worker(data, flag));
Future<String> f2 = executor.submit(new Worker(data, flag));
Future<String> f3 = executor.submit(new Worker(data, flag));
Future<String> 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<Student> getRandomDummyData(int count){
List<Integer> list = Stream.generate(Math::random).distinct().filter(i -> i < 1).limit(count).map(i -> i * 100000)
.map(Double::intValue).collect(Collectors.toList());
List<Student> students = new ArrayList<Student>();
for(Integer i:list){
Student stu = new Student("name"+i,i);
students.add(stu);
}
return students;
}
public static Stack<Student> getDummyData(int count){
Stack<Student> students = new Stack<Student>();
for(int i=0;i<count;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<String>{
private Stack<Student> students;
volatile private boolean done= false; //错误的方式
private Flag flag;
public Worker(Stack<Student> students, boolean done) {
this.students = students;
this.done = done;
}
public Worker(Stack<Student> 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;
}