执行程序暂停并且不处理挂起的队列

Question

我有一个长时间运行的任务，创建一个位图保存它，并重新创建更多的位图我是在一个单一的背景线程

ExecutorService executor = Executors.newSingleThreadExecutor();
Handler handler = new Handler(Looper.getMainLooper());
executor.execute(() -> {...bitmap work ...}

但是处理所有的位图需要很长时间，所以我创建了一个线程池来使用多线程来加速任务。

private final int cores = Runtime.getRuntime().availableProcessors();
private final ExecutorService executor = Executors.newFixedThreadPool(cores + 1);
for (int i = 0; i < totalPage; i++) {    
Runnable runnable = () -> {...bitmap work ...}
executor.submit(runnable);
}

但是每当我使用超过1个线程时，它就会在一些任务上随机卡住(说127个中的7个)，没有错误或任何东西，它只是不处理任何更多的任务。我可以在执行队列中查看挂起的任务。但是，如果我将线程池更改为使用1个线程，它就可以正常工作并处理所有任务。

下面是完整的实际代码

ExecutorService executor = Executors.newFixedThreadPool(cores + 1);
List<Future<?>> futureList = new ArrayList<>();
boolean allDone = false;
try {
//Convert pdf to Bitmap
ParcelFileDescriptor parcelFileDescriptor = ParcelFileDescriptor.open(new File(pdfFileName), ParcelFileDescriptor.MODE_READ_ONLY);
PdfRenderer pdfRenderer = new PdfRenderer(parcelFileDescriptor);
int totalPage = pdfRenderer.getPageCount();
final int[] counter = {1};
for (int i = 0; i < totalPage; i++) {
int finalI = i;
String finalOriginalPdfName = originalPdfName;
String finalGeneratedPdfName = generatedPdfName;
Runnable runnable = () -> {
//pd.setMessage("Processing page " + (finalI + 1) + " of " + totalPage);
PdfRenderer.Page page = pdfRenderer.openPage(finalI);
Bitmap pageBitmap = Bitmap.createBitmap((300 * page.getWidth()) / 72, (300 * page.getHeight()) / 72, Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(pageBitmap);
canvas.drawColor(Color.WHITE);
canvas.drawBitmap(pageBitmap, 0, 0, null);
page.render(pageBitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_PRINT);
page.close();

//Crop bitmaps and temporarily store on app data directory
for (int k = 0; k < SlipBoundingBox.Y.length; k++) {
for (int j = 0; j < SlipBoundingBox.X.length; j++) {
Bitmap slipBitmap = Bitmap.createBitmap(pageBitmap, SlipBoundingBox.X[j], SlipBoundingBox.Y[k], SlipBoundingBox.WIDTH, SlipBoundingBox.HEIGHT);
//Filename formation originalPdfName_generatePdfName_pdfPageIndex_x_y.extension
File slip = new File(
getExternalFilesDir("slips")
+ "/"
+ finalOriginalPdfName
+ "_"
+ finalGeneratedPdfName
+ "_"
+ finalI +
"_"
+ SlipBoundingBox.X[j]
+ "_"
+ SlipBoundingBox.Y[k]
+ "_.jpg");
try (FileOutputStream out1 = new FileOutputStream(slip)) {
slipBitmap.compress(Bitmap.CompressFormat.JPEG, 100, out1);
} catch (IOException e) {
e.printStackTrace();
}
slipBitmap.recycle();
}
}
pageBitmap.recycle();
pd.setMessage("Processed " + counter[0] + " of " + totalPage + " pages");
counter[0]++;
};
Future<?> future = executor.submit(runnable);
Log.d(TAG, "processPdf: " + future.isDone());
futureList.add(future);
}
//Todo close pdfrender on all page processed
//pdfRenderer.close();
} catch (Exception e) {
e.printStackTrace();
}

Answer 1

我真的很抱歉我不能直接帮助你。我不知道PdfRenderer的内部工作原理。我认为有三种情况可能会导致这个问题:

1. PdfRenderer在它的库中有一个死锁。不可能。

2. 你的文件I/O太复杂了，并行写多个文件只需要100倍的时间。还记得旧的CD吗?当你全速读取一个源时，一旦2+进程读取，它就会变得指数级慢(不是一半快，而是2个进程慢20倍)。我认为这是最有可能的原因。

3. 在PdfRenderer的某个深处发生了I/O错误。也许它打开了太多的文件句柄或其他什么，导致意外的崩溃，只是暂停执行。

所以我唯一能给你的是:分析是否有任何进程工作(至少缓慢)。可能有一些框架，但我不知道。还有很多工具可以在运行时分析jvm。这里有一个更简单的解决方案:

检查每个线程的状态，以及它们是否改变了方法。这是纯粹的视觉效果:

• 查看/使用下面的代码。按原样运行
• 您将看到每个线程不时地更改任务/状态
如果你喜欢，把我的文件添加到你的项目中。
• 调整你的代码(参见我的main()方法)
• 减少/限制池大小为3或4
• 控制台输出将直观地显示任何线程中是否有任何更改。
• 如果没有任何更改，则pdf库被卡住
• 如果有重复的变化，但没有长期进展，lib将陷入死亡循环

代码:

package stackoverflow;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class SimpleThreadpoolAnalysis {
static private final long sStartMS = System.currentTimeMillis();
static public long now() {
return System.currentTimeMillis() - sStartMS;
}
static public void sleep(final long pMS) {
try {
Thread.sleep(pMS);
} catch (final InterruptedException e) { /* */ }
}

private final Set<Thread> mWorkingThreads = Collections.synchronizedSet(new HashSet<>());
private int mPrintStackDepth = 5;
public void setPrintStackDepth(final int pPrintStackDepth) {
mPrintStackDepth = pPrintStackDepth;
}
public void runChecked(final Runnable pLambda) {
if (pLambda == null) return;
final Thread currentThread = Thread.currentThread();
try {
System.out.println("SimpleThreadpoolAnalysis.runChecked() adding thread " + currentThread.getName());
mWorkingThreads.add(currentThread);
pLambda.run();
} finally {
System.out.println("SimpleThreadpoolAnalysis.runChecked() removing thread " + currentThread.getName());
mWorkingThreads.remove(currentThread);
}
}
public void printMiniStackTraces() {
System.out.println("Working Threads at " + now());
for (final Thread t : mWorkingThreads) {
System.out.println("tThread " + t.getId() + ": " + t.getName());
final StackTraceElement[] st = t.getStackTrace();
for (int i = 0; i < Math.min(st.length, mPrintStackDepth); i++) {
System.out.println("tt" + st[i]);
}
}
}
public Thread runSupervisorThread(final int pUpdateEveryXMs, final long pDurationMS) {
System.out.println("Supervisor Thread starting...");
final Thread t = new Thread(() -> runSupervisorThread_(pUpdateEveryXMs, pDurationMS), "Pool Supervisor Thread");
t.setDaemon(true);
t.start();
return t;
}
private void runSupervisorThread_(final int pUpdateEveryXMs, final long pDurationMS) {
System.out.println("Supervisor Thread starting...");
final int NUMBER_OF_RUNS = (int) (pDurationMS / pUpdateEveryXMs);
for (int i = 0; i < NUMBER_OF_RUNS; i++) {
System.out.flush();
sleep(pUpdateEveryXMs);
printMiniStackTraces();
}
System.out.println("Supervisor Thread ending...");
}

// this is my dummy class. you can remove this once you use it on your code
static public class TestWorker implements Runnable {
@Override public void run() {
while (true) {
//              final int no =
subDelegator();
//              System.out.println("Got  " + no);
}
}
private int subDelegator() {
SimpleThreadpoolAnalysis.sleep((long) (Math.random() * 1000));
final int randomIndex = (int) (Math.random() * 10);
switch (randomIndex) {
case 0:
return run_0();
case 1:
return run_1();
case 2:
return run_2();
case 3:
return run_3();
case 4:
return run_4();
case 5:
return run_5();
default:
return -1;
}
}
private int run_0() {
SimpleThreadpoolAnalysis.sleep(500);
return 0;
}
private int run_1() {
SimpleThreadpoolAnalysis.sleep(1000);
return 1;
}
private int run_2() {
SimpleThreadpoolAnalysis.sleep(2000);
return 2;
}
private int run_3() {
SimpleThreadpoolAnalysis.sleep(3000);
return 3;
}
private int run_4() {
SimpleThreadpoolAnalysis.sleep(4000);
return 4;
}
private int run_5() {
SimpleThreadpoolAnalysis.sleep(5000);
return 5;
}
}

public static void main(final String[] args) {
final SimpleThreadpoolAnalysis sta = new SimpleThreadpoolAnalysis();
sta.runSupervisorThread(100, 60000); // will run for a minute, updating every 100ms
// this will run a in background thread, so if other threads are done, this will end automatically, too
final int cores = Runtime.getRuntime().availableProcessors();
final ExecutorService executor = Executors.newFixedThreadPool(cores + 1);
final int totalPages = 10;
for (int i = 0; i < totalPages; i++) {
// my code:
//          final Runnable runnable = new TestWorker(); // this would be the normal call
final Runnable runnable = new TestWorker(); // this is the checked version
// your code: enable this, comment out my line above
//final Runnable runnable = () -> { /* your bitmap work */ }; // use this, just like in your code
final Runnable checkedRunnable = () -> sta.runChecked(runnable); // this is the checked version
final Future<?> future = executor.submit(checkedRunnable);
// ... some more of your code ...
}
}

}

我希望这对你有所帮助。

Answer 2

原来问题是我在回收位图之前关闭了pdf页面。

page.close();
.....
pageBitmap.recycle();

我在回收位图后移动了page.close()，线程不再挂起

pageBitmap.recycle();
page.close();