0

我正在尝试编写一个简单的视频操纵器，所以每秒几次我需要启动一个新线程（当前正在实现 Runnable）来处理当前帧，但我不能保证每个线程需要多长时间才能完成，因此我想要将一次可以运行的线程数限制为计算机上的处理器数： 

Runtime runtime = Runtime.getRuntime();
int nP = runtime.availableProcessors();

但我需要保证创建的所有线程都按顺序运行，因此不会丢帧。

我还想根据用户取消作业时剩余运行的线程数向用户展示完成处理需要多长时间，这样他们就不会得到没有预告片的视频文件。

使用 futureTask、Execector 或 ExecutorService 的任意组合是否可以实现这一点？

谢谢。

编辑：

大家好，对不起，那是相当糟糕的措辞。所以我实际上想要做的是获取帧，执行一些图像处理，然后将编辑后的素材保存回一个新文件。目前我正在播放期间执行此操作，因此当计时器调用每个帧时都会对其进行操作，然后计时器会启动一个线程以尽快处理图像，但取决于这次操作的数量会有所不同。

然后我想确保如果处理时间长于仅使用最大有效线程数进行处理的时间间隔，并且在达到此限制后创建的任何线程仍然得到处理并且不会被丢弃或垃圾收集.

阅读了前 3 条评论后，我可以看到这可能是一种效率较低的方法，我想只有一个线程来保持 UI 响应会起作用，但我不确定如何继续将图像添加到线程中它可以在不使用大量列表的情况下进行处理。我假设它会是这样的：

在主课中：

Timer actionPerformed {
    List.add(decodedImage);
}

在可运行类中：

run() {
   while( timer.isRunning() ) {
     if( runCount >= list.size()-1 ) {
        try {
          Thread.sleep(500);
        } catch() {
             /* Catchy stuff */
        }
     } else {
        BufferedImage toProcess = list.get(runCount);
        /* Do Processing here */
        writeImageToStream();
        list.remove(runCount);
        runCount++;
     }
   }
}

这个对吗？

编辑2：

所以这就是我到目前为止所拥有的：

public class timerEncode {

     private long startTime;

     ActionListener goAction = new ActionListener() {
         public void actionPerformed( ActionEvent evt ) {
             BufferedImage decoded = getNextImage();
             long write_time = System.nanoTime();
             new doImages(decoded, write_time).run();
         }        
     };
     Timer goTimer = new Timer(40,goAction);

     private BufferedImage getNextImage() {
        /* Does inconsequential stuff to retrieve image from the stream*/
     }

     private void recBtnActionPerformed(java.awt.event.ActionEvent evt) {                                       
        startTime = System.nanoTime();
        goTimer.start();
     }

     private class doImages implements Runnable {
        final BufferedImage image;
        final long write_time;

        public doImages(BufferedImage image, long write_time) {
           this.image = image;
           this.write_time = write_time;
        }

        public void run() {
            BufferedImage out = toXuggleType(image, BufferedImage.TYPE_3BYTE_BGR);
            /* Other time consuming processy stuff goes here */
            /* Encode the frame to a video stream */
            writer.encodeVideo(0,out,write_time-startTime, TimeUnit.NANOSECONDS);
        }

        private BufferedImage toType(BufferedImage source, int type) {
            if( source.getType() != type ) {
                BufferedImage temp = new BufferedImage(source.getWidth(),source.getHeight(),type);
                temp.getGraphics().drawImage(source, 0, 0, null);
                source = temp;
            }
            return source;
        }
    }

}

当图像处理很简单时，这很好用，但是你很快就会遇到数十个并发线程试图做他们的事情，因为它变得有点复杂，因此我问如何限制并发线程数而不丢弃任何线程。我不确定在这种情况下顺序特别重要，因为我认为乱序写入帧会将它们放在正确的位置，因为每个帧都指定了写入时间，但这需要测试。

4

3 回答 3

4

但我需要保证创建的所有线程都按顺序运行，因此不会丢帧。

你的意思是像你在这里所说的那样吗？如果是这样，那么您根本无法真正实现多线程，因为我知道在第 1 帧完成之前您无法开始处理第 2 帧。此时，您不妨按顺序处理帧并忽略线程。

或者，如果您的意思是其他内容，例如可以独立处理帧但需要按顺序整理，那么这可能是可行的。

无论如何 - 很少需要或有益于使用“原始”线程。正如其他人所指出的，使用更高级别的并发实用程序（在这种情况下，ThreadPoolExecutor 将是完美的）来监督这一点。

听起来 aRunnable也不是正确的选择，因为这意味着您通过改变一些全局变量来返回处理的“结果”。相反，最好将此处理转换为 aCallable并返回结果。这可能会消除线程安全问题，可能允许一次处理不同的帧而问题更少，并且允许您将每个结果的整理推迟到您认为合适的任何点。

如果您想这样做，可以执行以下操作：

// Create a thread pool with the given concurrency level
ExecutorService executor = Executors.newFixedThreadPool(Runtime.availableProcessors);

// Submit all tasks to the pool, storing the futures for further reference
// The ? here should be the class of object returned by your Callables
List<Future<?>> futures = new ArrayList<Future<?>>(NUM_FRAMES);
for (int i = 0; i < NUM_FRAMES; i++)
{
    futures.add(executor.submit(createCallableForFrame(i)));
}

// Combine results using future.get()
// e.g. do something with frames 2 and 3:
mergeFrames(futures.get(2).get(), futures.get(3).get());

// In practice you'd probably iterate through the Futures but it's your call!
于 2010-08-09T16:33:40.663 回答
1

连续启动线程是个坏主意——它对性能有很大影响。你想要的是一个线程池和一堆工作（Runnables）。如果您创建一个大小 = 处理器数量的线程池，并且只是继续将帧（作为作业）添加到作业队列中，那么您的线程将能够有效地按顺序通过队列处理它们的方式。

于 2010-08-09T15:57:37.263 回答
0

[查看历史以了解以前的回复]

我明白现在发生了什么。我不完全确定如何Timer或ActionListeners工作（关于如果前一个调用在另一个调用到达时尚未完成会发生什么），但似乎您实际上可能没有同时运行您的doImages对象 - 同时运行一个Runnable对象您需要做Thread t = new Thread(runnableObject); t.start();如果您只是调用该run()方法，它将按顺序完成（就像任何其他方法调用一样），因此您的actionPerformed()方法在调用之前run()不会完成。我不确定这是否会阻止（或延迟）其他ActionEvents处理。

正如其他人所建议的那样，要限制线程数，您应该使用一个ThreadPoolExcecutor对象。这将使您的actionPerformed()方法快速返回，同时运行doImages对象并确保您不会通过队列使用太多线程。您需要做的就是替换new doImages(decoded, write_time).run();为threadPool.execute(new doImages(decoded, write_time)).

至于如何监控进程，可以使用 的getQueue()方法ThreadPoolExcecutor来检索和检查队列的大小，看看有多少帧在等待处理。

于 2010-08-09T16:06:08.130 回答