不可靠取消操作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(); }
}