停止多线程错误方法2

迷南。 2022-12-26 09:22 145阅读 0赞

使用标记位(volatile)，进行停止多线程，这种方法不是不可取，是在一定情况下，可取。所以一般也不建议使用

如何正确使用volatile进行线程的中断，如果无法中断，用什么来弥补volatile 阻塞后无法唤醒的缺陷

有几个例子：

1.volatile设置boolean看起来可行

cancled是volatile修饰的boolean类型的值(默认为true)，在线程运行一定时间后，将值设为false；程序停止运行，这样看起来是可行的
    
    int num = 0;
    try {
        while (num<10000 && !canceled){
            if(num%100 == 0){
                System.out.println(num+"：是100的倍数");
            }
            num ++;
            Thread.sleep(1);
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

2.生产者消费者模式(陷入阻塞时，volatile是无法停止线程的)

生产者生产速度远远超过消费者的消费速度，当队列满了之后，就会出现阻塞，进而要等待消费者进行消费

public class WrongWayVolatileCantStop {
        public static void main(String[] args) throws InterruptedException {
            ArrayBlockingQueue storage = new ArrayBlockingQueue(10);
            Producer producer = new Producer(storage);
            Thread producerThread = new Thread(producer);
            producerThread.start();
            Thread.sleep(1000);
    
            Consumer consumer = new Consumer(storage);
            //消费者消费是有一定几率的
            while (consumer.needMoreNums()){
                System.out.println(consumer.storage.take()+"：被消费了");
                Thread.sleep(1000);
            }
            System.out.println("消费者不需要更多数据了。");
            //一旦消费不需要更多数据了，我们应该让生产者停下来，但是实际情况 并没有
            producer.canceled = true;
            System.out.println(producer.canceled);
        }
    }
    //生产者
    class Producer implements Runnable{
        public volatile boolean canceled = false;
    
        BlockingQueue storage;
    
        public Producer(BlockingQueue storage) {
            this.storage = storage;
        }
    
        @Override
        public void run() {
            int num = 0;
            try {
                while (num<10000 && !canceled){
                    if(num%100 == 0){
                        storage.put(num);
                        System.out.println(num+"：是100的倍数");
                    }
                    num ++;
                    Thread.sleep(1);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                System.out.println("生产者停止运行");
            }
        }
    }
    //消费者
    class Consumer{
        BlockingQueue storage;
    
        public Consumer(BlockingQueue storage) {
            this.storage = storage;
        }
        public boolean needMoreNums(){
            if (Math.random() > 0.95){
                return false;
            }
            return true;
        }
    }

那么这种情况 就会导致线程阻塞，程序停不下来

运行结果，最后一行

5700：是100的倍数  
4800：被消费了  
5800：是100的倍数  
4900：被消费了  
5900：是100的倍数  
5000：被消费了  
6000：是100的倍数  
消费者不需要更多数据了。  
true

### 改进：用中断来修复，弥补volatile 阻塞后无法唤醒的缺陷 ###

public void run() {
        int num = 0;
        try {
            while (num<10000 && !Thread.currentThread().isInterrupted()){
                if(num%100 == 0){
                    storage.put(num);
                    System.out.println(num+"：是100的倍数");
                }
                num ++;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            System.out.println("生产者停止运行");
        }
    }

结果：

2100：是100的倍数  
1100：被消费了  
1200：被消费了  
2200：是100的倍数  
消费者不需要更多数据了。  
java.lang.InterruptedException  
    at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.reportInterruptAfterWait(AbstractQueuedSynchronizer.java:2014)  
    at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2048)  
    at java.util.concurrent.ArrayBlockingQueue.put(ArrayBlockingQueue.java:353)  
    at threadcoreknowledge.stopthreads.volatiledemo.WrongWayVolatileFixed$Producer.run(WrongWayVolatileFixed.java:41)  
    at java.lang.Thread.run(Thread.java:745)  
生产者停止运行