java - 为什么我的 Java 应用程序不在每次循环时播放声音？

Question

我正在尝试制作一个Java应用程序来模拟某人在键盘上打字。击键声音以可变间隔循环播放(Java随机选择击键声音并播放)(以模拟真人打字)。

一开始它工作正常，但在第 95 次迭代之后，它停止播放声音(同时仍在循环)不到 4 秒，然后再次播放声音。在第 160 次迭代之后，它几乎每秒播放一次声音(而不是每隔三到六秒)。
一段时间后，它会停止播放声音很长一段时间，然后永远停止。

这是 AudioPlayer.java 类的源代码:

package entity;

import java.io.File;
import java.io.IOException;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.UnsupportedAudioFileException;

public class AudioPlayer implements Runnable {
    private String audioFilePath;

    public void setAudioFilePath(String audioFilePath) {
         this.audioFilePath = audioFilePath;
    }

    @Override
    public void run() {
        File audioFile = new File(audioFilePath);

        try {
            AudioInputStream audioStream = AudioSystem.getAudioInputStream(audioFile);
            AudioFormat format = audioStream.getFormat();
            DataLine.Info info = new DataLine.Info(Clip.class, format);
            Clip audioClip = (Clip) AudioSystem.getLine(info);
            audioClip.open(audioStream);
            audioClip.start();
            boolean playCompleted = false;
            while (!playCompleted) {
                try {
                    Thread.sleep(500);
                    playCompleted = true;
                }
                catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
            audioClip.close();
        } catch (UnsupportedAudioFileException ex) {
            System.out.println("The specified audio file is not supported.");
            ex.printStackTrace();
        } catch (LineUnavailableException ex) {
            System.out.println("Audio line for playing back is unavailable.");
            ex.printStackTrace();
        } catch (IOException ex) {
            System.out.println("Error playing the audio file.");
            ex.printStackTrace();
        }
    }
}

这是用于测试击键模拟器的 Main.java 类:

package sandbox;

import java.util.Random;

import entity.AudioPlayer;

public class Main {
    public static void main(String[] args) {
        Random rnd = new Random();
        AudioPlayer audio;

        for(int i = 0; i < 10000; i++) {
            int delay = rnd.nextInt(200)+75;
            try {
                Thread.sleep(delay);
            }
            catch (InterruptedException ie) {}
            int index = rnd.nextInt(3)+1;
            audio = new AudioPlayer();
            audio.setAudioFilePath("resources/keystroke-0"+index+".wav");
            Thread thread = new Thread(audio);
            thread.start();
            System.out.println("iteration "+i);
        }
    }
}

我在资源目录中使用了多个不同击键声音的短(小于 200 毫秒)波形文件(总共 3 个)。

编辑

我阅读了您的回答和评论。我想也许我误解了他们，因为建议的解决方案不起作用，或者也许我应该明确自己到底想要什么。另外，我需要注意的是，我不经常使用线程(并且不知道互斥锁是什么)。

所以我首先解释一下我到底想要程序做什么。它应该能够模拟击键，所以我使用了线程，因为它允许两个击键声音重叠，就像真人打字时一样。基本上，我使用的声音剪辑是按键声音，按键声音由两种声音组成:按下按键的声音。松开按键的声音。

如果程序在某个时刻允许两个击键重叠，听起来就好像有人按下一个键，然后按下另一个键，然后释放第一个键。这就是真正的打字听起来的样子!

现在我使用建议的解决方案遇到的问题是:直接调用AudioPlayer的run()方法时，

public static void main(String[] args)
{
    // Definitions here

    while (running) {
        Date previous = new Date();
        Date delay = new Date(previous.getTime()+rnd.nextInt(300)+75);

        // Setting the audio here

        audio.run();
        Date now = new Date();

        if (now.before(delay)) {
            try { 
                Thread.sleep(delay.getTime()-now.getTime());
            } catch (InterruptedException e) {
            }
        }

        System.out.println("iteration: "+(++i));
    }
}

声音按顺序播放(一个接一个)，播放速率取决于 AudioPlayer 的 sleep 持续时间(或者如果 main() 方法中的延迟高于 AudioPlayer 的 sleep 持续时间，则取决于延迟)，这不好，因为它听起来不像普通打字员(更像是刚开始打字并且在打字时仍在寻找每个键的人)。

调用AudioPlayer线程的join()方法时，

public static void main(String[] args)
{
    //Variable definitions here

    while (running) {
        int delay = rnd.nextInt(200)+75;
        try
        {
            Thread.sleep(delay);
        }
        catch (InterruptedException ie)
        {

        }

        //Setting the AudioPlayer and creating its Thread here

        thread.start();
        try
        {
            thread.join();
        }
        catch(InterruptedException ie)
        {

        }
        System.out.println("iteration "+(++i));
    }
}

声音也按顺序播放，播放速率取决于 AudioPlayer 的 sleep 持续时间(或者如果 main() 方法中的延迟高于 AudioPlayer 的 sleep 持续时间，则取决于延迟)，这再次，由于与之前相同的原因而没有好处。

所以，回答一下评论者的问题。是的!还有其他一些之前没有表达过的问题，这些问题首先需要线程。

我找到了一个“解决”我的问题的解决方法(但我不认为这是一个正确的解决方案，因为我在某种程度上作弊):我所做的是将 AudioPlayer 的 sleep 持续时间增加到在程序停止(24 小时)之前不太可能达到，而且据我所知，即使在一个多小时后，它也不会使用太多资源。

您可以查看我想要什么、运行建议的解决方案时得到什么以及使用 this youtube videos 上的解决方法得到什么(不幸的是 StackOverflow 没有视频上传功能。所以我不得不把它放在 YouTube 上)。

编辑音效可下载here .

Answer 1

这个单线程解决方案怎么样，它是您自己的更干净的版本，但重新使用缓冲区中已打开的剪辑？对我来说，即使没有同时播放两种声音，打字听起来也很自然。您可以通过更改 Application 类中相应的静态常量来调整打字速度。

package de.scrum_master.stackoverflow.q61159885;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine.Info;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.UnsupportedAudioFileException;
import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import static javax.sound.sampled.AudioSystem.getAudioInputStream;
import static javax.sound.sampled.AudioSystem.getLine;

public class AudioPlayer implements Closeable {
  private final Map<String, Clip> bufferedClips = new HashMap<>();

  public void play(String audioFilePath) throws IOException, UnsupportedAudioFileException, LineUnavailableException {
    Clip clip = bufferedClips.get(audioFilePath);
    if (clip == null) {
      AudioFormat audioFormat = getAudioInputStream(new File(audioFilePath)).getFormat();
      Info lineInfo = new Info(Clip.class, audioFormat);
      clip = (Clip) getLine(lineInfo);
      bufferedClips.put(audioFilePath, clip);
      clip.open(getAudioInputStream(new File(audioFilePath)));
    }
    clip.setMicrosecondPosition(0);
    clip.start();
  }

  @Override
  public void close() {
    bufferedClips.values().forEach(Clip::close);
  }
}

package de.scrum_master.stackoverflow.q61159885;

import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.UnsupportedAudioFileException;
import java.io.IOException;
import java.util.Random;

public class Application {
  private static final Random RANDOM = new Random();

  private static final int ITERATIONS = 10000;
  private static final int MINIMUM_WAIT = 75;
  private static final int MAX_RANDOM_WAIT = 200;

  public static void main(String[] args) throws UnsupportedAudioFileException, IOException, LineUnavailableException {
    try (AudioPlayer audioPlayer = new AudioPlayer()) {
      for (int i = 0; i < ITERATIONS; i++) {
        sleep(MINIMUM_WAIT + RANDOM.nextInt(MAX_RANDOM_WAIT));
        audioPlayer.play(randomAudioFile());
      }
    }
  }

  private static void sleep(int delay) {
    try {
      Thread.sleep(delay);
    } catch (InterruptedException ignored) {}
  }

  private static String randomAudioFile() {
    return "resources/keystroke-0" + (RANDOM.nextInt(3) + 1) + ".wav";
  }
}

您可能已经注意到，AudioPlayer 是Closeable，即您可以在调用应用程序中使用“尝试使用资源”。这样可以确保在程序结束时所有剪辑都会自动关闭。

重播同一剪辑的关键当然是在开始之前clip.setMicrosecondPosition(0)。

<小时/>

更新:如果你想模拟多人，只需像这样修改主类即可。顺便说一句，我对音频编程一无所知，也不知道是否有办法更好地处理混音器和重叠声音。这只是一个概念证明，以便为您提供一个想法。每人有一个线程，但每个人以串行方式键入，而不是同时键入两个键。但多人可以重叠，因为每个人都有一个 AudioPlayer 并拥有自己的一组缓冲剪辑。

package de.scrum_master.stackoverflow.q61159885;

import java.util.Random;

public class Application {
  private static final Random RANDOM = new Random();

  private static final int PERSONS = 2;
  private static final int ITERATIONS = 10000;
  private static final int MINIMUM_WAIT = 150;
  private static final int MAX_RANDOM_WAIT = 200;

  public static void main(String[] args) {
    for (int p = 0; p < PERSONS; p++)
      new Thread(() -> {
        try (AudioPlayer audioPlayer = new AudioPlayer()) {
          for (int i = 0; i < ITERATIONS; i++) {
            sleep(MINIMUM_WAIT + RANDOM.nextInt(MAX_RANDOM_WAIT));
            audioPlayer.play(randomAudioFile());
          }
        } catch (Exception ignored) {}
      }).start();
  }

  private static void sleep(int delay) {
    try {
      Thread.sleep(delay);
    } catch (InterruptedException ignored) {}
  }

  private static String randomAudioFile() {
    return "resources/keystroke-0" + (RANDOM.nextInt(3) + 1) + ".wav";
  }
}