如何強制停止線程並使用新變量啓動相同的線程？

Question

我想在點擊按鈕上執行一些長時間運行的任務，如果用戶再次點擊該按鈕，當前任務強制停止並將執行下一個任務？

Answer 1

我發佈了一個純粹的基於Java的代碼，它也可以在android中工作。在使用android時只需要注意不要從程序的一部分更新GUI，而這部分程序會在主GUI線程以外的線程中執行。如果您希望從另一個線程編輯GUI，那麼您可以使用在主GUI線程中實例化的Handler。

定義基本接口，這樣的模型

/** 
* 
* @author nits.kk 
* 
* This defines the methods for the model. 
* 
*/ 
public interface IResumable { 
    /** 
    * starts the model 
    */ 
    public void requestStart(); 
    /** 
    * requests the model to pause 
    */ 
    public void requestPause(); 
    /** 
    * requests the model to resume with new parameter 
    * @param newParam 
    */ 
    public void resumeWithNewParam(int newParam); 
/** 
    * terminate the model 
    */ 
    public void requestStop(); 
} 

現在的具體實施

public class ResumableModel implements IResumable { 
    private Thread worker; 
    private WorkerRunnable work; 

    public ResumableModel(int initialValue) { 
     work = new WorkerRunnable(initialValue); 
     worker = new Thread(work); 
    } 

    @Override 
    public void requestStart() { 
     worker.start(); 
    } 

    @Override 
    public void requestPause() { 
     work.setPauseRequested(true); 
    } 

    @Override 
    public void resumeWithNewParam(int newParam) { 
     work.setNewParam(newParam); 
    } 

    @Override 
    public void requestStop() { 
     worker.interrupt(); 
    } 

    private static class WorkerRunnable implements Runnable { 
     private int param; // we can have the variable of the type depending upon the requirement. 
     private final Object lock = new Object(); 
     private volatile boolean isPauseRequested = false; 

     public void run() { 
       synchronized (lock) { 
        try { 
          while (!Thread.currentThread().isInterrupted()) { 
           while (isPauseRequested) { 
             lock.wait(); 
           } 
           System.out.println("value of param is" + param); 
          } 
        } catch (InterruptedException e) { 
          e.printStackTrace(); 
        } 
       } 
     } 

     public WorkerRunnable(int param) { 
       this.param = param; 
     } 

     private void setPauseRequested(boolean isPauseRequested) { 
       this.isPauseRequested = isPauseRequested; 
     } 

     private void setNewParam(int param) { 
       // double locking to prevent the calling thread from being locked 
       // (if in running state without pause requested then calling thread 
       // will be in indefinite wait state for acquiring the lock. 
       if (isPauseRequested) { 
        synchronized (lock) { 
          if (isPauseRequested) { 
           this.param = param; 
           this.isPauseRequested = false; 
           lock.notifyAll(); 
          } else { 
           // logger will be used in real application 
           System.out.println("Need to pause first before setting a new param"); 
          } 
        } 
       } else { 
        // logger will be used in real application 
        System.out.println("Need to pause first before setting a new param"); 
       } 
     } 
    } 
} 

現在，當你想開始你可以做以下

IResumable resumable = new ResumableModel(10); 
resumable.requestStart(); 

當線程你想暫停線程，你可以簡單地調用requestPause()方法

resumable.requestPause(); 

現在，當您需要使用新的變量值恢復線程時，您可以調用resumeWithNewParam。

resumable.resumeWithNewParam(20); 

現在，當你覺得你不需要的線程和模式應該終止，那麼你可以調用resumable.requestStop();

Answer 2

您可以創建這樣

public class AsyncThread extends Thread{ 
     @Override 
     public void run() { 
      super.run(); 
      //do your task 
     } 
    } 

線程類，並檢查線程仍然活着

AsyncThread thread = new AsyncThread(); 
     if(thread.isAlive()){ 
      thread.interrupt(); 
      //do other stuff 
     }else{ 
      thread.start(); 
     } 

Answer 3

您不能重新啓動一個線程，一旦它停止。

我建議使用Looper/Handler API將任務放入隊列中並讓處理程序在單獨的線程上執行它們。

我有圈套/處理程序here與explanation的演示項目。看看你是否想這樣實現它。

另一個選項（如@Guna所提到的）是，您可以創建緩存的線程池並讓執行程序在線程上運行任務。

Answer 4

你必須在你的運行方法中檢查一個標誌。當您希望線程取消時，此標誌可以設置爲false。 下一次你的run方法檢查這個標誌，因爲它的false因此它退出線程。 可能你想使用ThreadPoolExecutor？