不可靠取消操作JAVA

public class BrokenPrimeProducer extends Thread{
    
    
  private final BlockingQueue<BigInteger> queue;
  private volatile boolean cancelled = false;

  BrokenPrimeProducer(BlockingQueue<BigInteger> queue){
    
    
    this.queue = queue;
  }

  public void run(){
    
    
    try{
    
    
      BigInteger p = BigInteger.ONE;
      while(!cancelled){
    
    
        queue.put(p=p.nextProbablePrime());
      }
    }catch(InterruptedException consumed){
    
    
    }
  }

  public void cancel( cancelled = true; )
}

void consumePrimes() throws InterruptedException{
    
    
  BlockingQueue<BigInteger> primes = ...;
  BrokenPrimeProducer producer = new BrokenPrimeProducer(primes);
  producer.start();
  try{
    
    
    while(needMorePrimes())
      consumer(primes.take());
  }finally{
    
    
    producer.cancel();
  }
}

用阻塞队列存放数据，如果生产的速度大于消费的速度，队列将会塞满，在进行put操作将会阻塞，永远无法检查到cancelled标志，无法从阻塞的put方法中恢复过来

通常中断是最合理的取消线程的方式

class PrimeProducer extends Thread{
    
    
  private final BlockingQueue<BigInteger> queue;

  PrimeProducer(BlockingQueue<BigInteger> queue){
    
    
    this.queue=queue;
  }

  public void run(){
    
    
    try{
    
     
      BigInteger p = BigInteger.ONE;
      while(!Thread.currentThread().isInterrupted()){
    
    
        queue.put(p=p.nextProbablePrimes());
      }
    }catch(InterruptedException consumed){
    
    
    /* 允许线程退出 */
    }
  }
  
  public void cancel(){
    
     interrupt(); }
}