Java 当工作线程在其中一个线程中完成时，如何停止工作线程？_Java_Multithreading

Java 当工作线程在其中一个线程中完成时，如何停止工作线程？

java multithreading

Java 当工作线程在其中一个线程中完成时，如何停止工作线程？,java,multithreading,Java,Multithreading,我正在进行一个简单的模拟，就像破解一个散列，现在我希望所有其他工作人员在其中一人找到结果时停止？除了停止，还有其他方法吗？因为这是不推荐的 import java.util.Random; class Worker extends Thread{ int target,start,current,end; public Worker(int target, int start, int end) { super(); this.target = target; thi

我正在进行一个简单的模拟，就像破解一个散列，现在我希望所有其他工作人员在其中一人找到结果时停止？除了停止，还有其他方法吗？因为这是不推荐的

import java.util.Random;

class Worker extends Thread{
int target,start,current,end;

public Worker(int target, int start, int end) {
    super();
    this.target = target;
    this.start = start;
    this.end = end;
}

@Override
public void run() {
    current=start;
    while(target!=current){
        System.out.println("Not found  target at "+current);
        current++;
        if(current==end){
            break;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    if(target==current){
        System.out.println(target+" found");
    }
}

}
public class RandomBreak {

public static void main(String[] args) {
    Random r=new Random(100);
    int target=r.nextInt(100);
    System.out.println("trying to search "+target);

    Worker w1=new Worker(target,1,30);
    Worker w2=new Worker(target,30,60);
    Worker w3=new Worker(target,60,90);
    Worker w4=new Worker(target,90,100);
    w1.start();
    w2.start();
    w3.start();
    w4.start();
}

}

创建一个循环，启动线程并将其添加到列表中，找到答案后，您可以遍历列表，停止其他线程。如果使用线程池，则可以使用ThreadPoolExecutor.shutdownNow（）

停止池中所有剩余的线程。

要停止池中所有剩余的线程。

当一个线程找到答案时，在其他线程上调用thread.interrupt（）。捕获InterruptedException时，退出工作线程

如果您的“真实”代码没有thread.sleep（），则只需偶尔检查线程中断标志，如：

if( Thread.interrupted() ) {
   throw new InterruptedException();
}

当一个线程找到答案时，在其他线程上调用thread.interrupt（）。捕获InterruptedException时，退出工作线程

如果您的“真实”代码没有thread.sleep（），则只需偶尔检查线程中断标志，如：

if( Thread.interrupted() ) {
   throw new InterruptedException();
}

使用公共数据结构存储标志，并将数据结构的相同实例传递给每个工作线程。找到目标的工作人员将在退出前设置标志。与目标一起检查while循环中的标志。代码段：

public WorkStatus {
    private volatile boolean completed;

    public boolean isCompleted() {
        return completed;
    }

    public synchronized void markCompleted(boolean completed) {
        this.completed = completed;
    }
}

public Worker implements Runnable {

    .
    .
    private WorkStatus workStatus;

    public Worker(int target, int start, int end, WorkStatus workStatus) {
       .
       .
       this.workStatus = workStatus;
    }

    @Override
    public void run() {
       .
       while(!workStatus.isCompleted() && target!=current) {
           .

       }

       if(target==current) {
           workStatus.markCompleted(true);
           .
       }
    }
}

确保将相同的WorkStatus实例传递给所有工作线程。

使用公共数据结构存储标志，并将相同的数据结构实例传递给每个工作线程。找到目标的工作人员将在退出前设置标志。与目标一起检查while循环中的标志。代码段：

public WorkStatus {
    private volatile boolean completed;

    public boolean isCompleted() {
        return completed;
    }

    public synchronized void markCompleted(boolean completed) {
        this.completed = completed;
    }
}

public Worker implements Runnable {

    .
    .
    private WorkStatus workStatus;

    public Worker(int target, int start, int end, WorkStatus workStatus) {
       .
       .
       this.workStatus = workStatus;
    }

    @Override
    public void run() {
       .
       while(!workStatus.isCompleted() && target!=current) {
           .

       }

       if(target==current) {
           workStatus.markCompleted(true);
           .
       }
    }
}

确保将相同的WorkStatus实例传递给所有工作实例。

停止线程执行的最可靠方法是使用中断并自行实现中断处理。您可以使用

Thread.interrupt（）

更改线程的中断状态，并使用

Thread.currentThread（）.isInterrupted（）

检查线程是否中断。
在您的情况下，代码可能如下所示：

import java.util.Random;

class Worker extends Thread {
    int target, start, current, end;

public Worker(final int target, final int start, final int end) {
    super();
    this.target = target;
    this.start = start;
    this.end = end;
}

@Override
public void run() {
    current = start;
    while (target != current && !Thread.currentThread().isInterrupted()) {
        System.out.println("Not found  target at " + current);
        current++;
        if (current == end) {
            break;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            break;
        }
    }
    if (target == current) {
        Thread.currentThread().interrupt();
        System.out.println(target + " found");
    }
  }
}

public static void main(final String[] args) {
    Random r = new Random(100);
    int target = r.nextInt(100);
    System.out.println("trying to search " + target);

    Worker w1 = new Worker(target, 1, 30);
    Worker w2 = new Worker(target, 30, 60);
    Worker w3 = new Worker(target, 60, 90);
    Worker w4 = new Worker(target, 90, 100);
    w1.start();
    w2.start();
    w3.start();
    w4.start();

    while (true) {
        if (w1.isInterrupted() || w2.isInterrupted() || w3.isInterrupted() || w4.isInterrupted()) {
            w1.interrupt();
            w2.interrupt();
            w3.interrupt();
            w4.interrupt();
            break;
        } else if (!w1.isAlive() && !w2.isAlive() && !w3.isAlive() && !w4.isAlive()) {
            System.out.println("Invalid search number.");
            break;
        }
    }
}

工作线程将搜索给定的编号，并反复检查线程是否中断。如果线程被中断，则表示另一个线程已找到该编号。如果线程找到了它要查找的编号，那么它将调用

thread.currentThread（）.interrupt（）

，向主方法发出找到该编号的信号，并终止其他工作线程。
主要方法如下所示：

import java.util.Random;

class Worker extends Thread {
    int target, start, current, end;

public Worker(final int target, final int start, final int end) {
    super();
    this.target = target;
    this.start = start;
    this.end = end;
}

@Override
public void run() {
    current = start;
    while (target != current && !Thread.currentThread().isInterrupted()) {
        System.out.println("Not found  target at " + current);
        current++;
        if (current == end) {
            break;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            break;
        }
    }
    if (target == current) {
        Thread.currentThread().interrupt();
        System.out.println(target + " found");
    }
  }
}

public static void main(final String[] args) {
    Random r = new Random(100);
    int target = r.nextInt(100);
    System.out.println("trying to search " + target);

    Worker w1 = new Worker(target, 1, 30);
    Worker w2 = new Worker(target, 30, 60);
    Worker w3 = new Worker(target, 60, 90);
    Worker w4 = new Worker(target, 90, 100);
    w1.start();
    w2.start();
    w3.start();
    w4.start();

    while (true) {
        if (w1.isInterrupted() || w2.isInterrupted() || w3.isInterrupted() || w4.isInterrupted()) {
            w1.interrupt();
            w2.interrupt();
            w3.interrupt();
            w4.interrupt();
            break;
        } else if (!w1.isAlive() && !w2.isAlive() && !w3.isAlive() && !w4.isAlive()) {
            System.out.println("Invalid search number.");
            break;
        }
    }
}

在main方法中，我们反复检查其中一个线程是否中断。如果是，则中断其他线程并结束执行。if子句

if（！w1.isAlive（）&&&！w2.isAlive（）&&&！w3.isAlive（）&&&！w4.isAlive（））

的另一部分是一个安全检查，检查用户是否给出了线程不寻找的数字。如果所有线程都已完成执行，但未找到编号，则结束程序