Thread.interrupt（）被忽略

Question

I am trying to write an algorithm which calculates the volume of a soundcard input. While this is (more or less) not the problem, I run into trouble while multitasking. The interrupts I call from another Thread seem to be ignored.

I developed multithreaded environments before and I think I know the pitfalls of Thread.isInterrupted() vs. Thread.interrupted() and the InterruptedException - that's why I use Thread.isInterrupted() exclusively. Edit : Also I think nothing I use here throws InterruptedException .

So I wrote this class:

import javax.sound.sampled.*;

public class SoundListener extends Thread {

    /**
     * RMS refresh rate in Hz (1000ms / RESPONSE_TIME)
     */
    private static final int REFRESH_RATE = 40;

    private final SoundMeter SOUNDMETER;
    private final AudioFormat AUDIO_FORMAT;
    private final int BUFFER_SIZE;
    private final boolean IS_24_BITS;
    private final TargetDataLine TARGET_DATA_LINE;

    SoundListener(SoundMeter soundMeter, Mixer mixer, AudioFormat audioFormat) throws LineUnavailableException {
        SOUNDMETER = soundMeter;
        AUDIO_FORMAT = audioFormat;
        BUFFER_SIZE = (int) ((AUDIO_FORMAT.getSampleRate() * AUDIO_FORMAT.getSampleSizeInBits()) / REFRESH_RATE);
        IS_24_BITS = AUDIO_FORMAT.getSampleSizeInBits() == 24;
        TARGET_DATA_LINE = AudioSystem.getTargetDataLine(AUDIO_FORMAT, mixer.getMixerInfo());
        TARGET_DATA_LINE.open(AUDIO_FORMAT);
        TARGET_DATA_LINE.start();

        setName("SoundListener");
        setDaemon(true);
        start();
    }

    @Override
    public void run() {

        System.out.println("Thread " + getName() + " started!");

        while (!isInterrupted()) {

            byte[] buffer = new byte[BUFFER_SIZE];
            int bytesRead = TARGET_DATA_LINE.read(buffer, 0, BUFFER_SIZE);

            if (bytesRead >= 0) {

                int max = 0;
                for (int i = 0; i < bytesRead; ) {

                    byte[] subBuffer = new byte[3];
                    subBuffer[0] = buffer[i++];
                    subBuffer[1] = buffer[i++];

                    if (IS_24_BITS) {
                        subBuffer[2] = buffer[i++];
                    }

                    int currentValue = 0;
                    if (AUDIO_FORMAT.isBigEndian()) {
                        if (IS_24_BITS) {
                            currentValue += subBuffer[0] << 16;
                            currentValue += subBuffer[1] << 8;
                            currentValue += subBuffer[2];
                        } else {
                            currentValue += subBuffer[0] << 8;
                            currentValue += subBuffer[1];
                        }
                    } else {
                        if (IS_24_BITS) {
                            currentValue += subBuffer[2] << 16;
                        }
                        currentValue += subBuffer[0];
                        currentValue += subBuffer[1] << 8;
                    }

                    if (currentValue > max) {
                        max = currentValue;
                    }
                }
                SOUNDMETER.setVolume(max);
            }
        }
        TARGET_DATA_LINE.close();

        System.out.println("Thread " + getName() + " stopped!");
    }
}

It starts the input interface on initialization and then right away starts itself.

The class SoundMeter is the external class which manages the Mixer to use and initializes the Thread as well as invoking the interrupt on the Thread object ( Edit : This class also receives calculated volume values).

I think the problem is the blocking TargetDataLine.read() method but I am not sure how to solve this.

Answer 1

Instead of using the interrupt API, I'd just use a boolean flag isRunning in this case, and set it to false when the thread should stop.

The flag set by interrupt() may not be observable to us, particularly when the thread is blocking:

If this thread is blocked in an invocation of the wait() , wait(long) , or wait(long, int) methods of the Object class, or of the join() , join(long) , join(long, int) , sleep(long) , or sleep(long, int) , methods of this class, then its interrupt status will be cleared and it will receive an InterruptedException .

Since TargetDataLine.read says it may block, there's no reason to expect that isInterrupted() will work here.

It would be nice if TargetDataLine would interrupt itself again to set the flag for us when it receives an InterruptedException , but there's nothing saying it has to.

Answer 2

Thread.interrupt() in common way just set the flag and that's all

If none of the previous conditions hold then this thread's interrupt status will be set.

So you thread will be ended during the first check while (!isInterrupted()) after your call Thread.interrupt()