Deadlock occurring when using java.nio.file.Paths & jsfml loadFromFile

Question

I've been trying to debug a problem I've had with loading a font from file (a .ttf file) with the java.nio.file.Paths import, using a combination of Paths.get() and loadFromFile(), but can't seem to find a solution.

Here's the problem code:

import java.io.IOException;
import java.nio.file.Paths;

    public final Font FONT_UI_BAR = new Font();
    public final Font FONT_FREESANS = new Font();

    try {
                System.out.println("We get here, before loading");
                FONT_UI_BAR.loadFromFile(Paths.get("Game/resources/UI/Font.ttf"));
                System.out.println("I've loaded the first font");
                FONT_FREESANS.loadFromFile(Paths.get("Game/resources/fonts/freesans/freesans.ttf"));
            } catch (IOException e2) {
                System.out.println("[ERROR] Could not load font");
                e.printStackTrace();
            }

The program gets to the first print statement but never reaches the second.

I did a thread dump and found there seems to be a deadlock within the code itself that occurs:

"main@1" prio=5 tid=0x1 nid=NA waiting
  java.lang.Thread.State: WAITING
      at jdk.internal.misc.Unsafe.park(Unsafe.java:-1)
      at java.util.concurrent.locks.LockSupport.park(LockSupport.java:194)
      at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:885)
      at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1039)
      at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1345)
      at java.util.concurrent.Semaphore.acquire(Semaphore.java:318)
      at org.jsfml.internal.SFMLErrorCapture.start(Unknown Source:-1)
      at org.jsfml.graphics.Font.loadFromFile(Unknown Source:-1)
      at assets.FontCatalogue.<init>(FontCatalogue.java:32)
      at assets.FontCatalogue.get(FontCatalogue.java:15)
      at screens.HomeScreen.<init>(HomeScreen.java:51)
      at controllers.Game.<init>(Game.java:74)
      at Main.main(Main.java:16)

I'm not exactly sure how to proceed from here. My program won't function how I want it to without loading these fonts. I've tried loading other kinds of fonts and the problem persists.

Weirdly enough the problem didn't occur with loading other files in the past, such as this code:

TEMP_BG_01.loadFromFile(Paths.get("Game/resources/placeholder/full-moon_bg.png"));

It only started once I started trying to load these fonts.

Ideally I'd like to find a solution that still allows me to use this package because otherwise I have a fair amount of code to rewrite. Not the biggest deal but suggesting simply using another package should be a last resort.

Any ideas appreciated.

EDIT: Interesting to note this issue DOES NOT occur on a Windows machine, only my ubuntu-linux one. The rest of my team on Windows have no issues. Obviously one solution is to go and use Windows instead, but who wants to do that :p

EDIT #2: Turns out I'm now getting this error even with loading from the Texture class in JSFML. I have a feeling I updated my JVM when I updated my ubuntu sometime recently and that's suddenly introduced problems. I can't say for sure because I don't recall updating very recently, but it seems as of 21/02/2021 loading from file with JSFML causes a deadlock :/

Answer 1

The first thing you need to do if you want to continue using JSFML is to determine the initial failure that leaves you in a deadlock state.

The code in the SFMLErrorCapture class is not robust. Should SFMLErrorCapture.start() fail in any way, it will leave the semaphore locked. I suspect this is the initial failure that breaks your application and leaves it deadlocked.

I'd recommend adding logging to the class, such as:

public static void start() {
    try {
        semaphore.acquire();
        capturing = true;

        nativeStart();
    } catch (InterruptedException ex) {
        ex.printStackTrace();
    } catch (Throwable t) {
        t.printStackTrace();

        // lots of other logging, probably to a file in /tmp

        // rethrow so original program flow isn't changed
        throw t;
    }
}

You might also want to add more logging to see if you get any InterruptedExceptions. That's another way the semaphore will never get released, but I don't think a simple upgrade is likely to trigger that kind of behavior change.

And, since it's also possible for finish() to fail in the same manner (such as if nativeFinish() returns null, which I'd think is also a likely failure mode...):

public static String finish() {
    try {
        final String str;
        if (capturing) {
            str = nativeFinish().trim();

            capturing = false;
            semaphore.release();
        } else {
            str = null;
        }

        return str;
    } catch (Throwable t) {
        t.printStackTrace();
        // lots of logging
        throw t;
    }
}

You might need to add throws Throwable to both methods.

This might also help:

public static String finish() {
    try {
        final String str;
        if (capturing) {
            // chaining calls is BAD CODE!!!!
            // Say hello to NPE if you insist cramming
            // multiple calls in one line!!
            str = nativeFinish();
            if ( str != null ) {
                str = str.trim();
            }

            capturing = false;
            semaphore.release();
        } else {
            str = null;
        }

        return str;
    }
}

Limiting asynchronous actions like this to one at a time is fundamentally broken. If only one action can happen at once, the code complexity added to do actions asynchronously is worse than wasted because such complex code is much more bug-prone and when bugs do happen that complexity makes unrecoverable failures much more likely.

If you can only do one at a time, just do the actions serially with one static synchronized method or in one synchronized block on a static final object.