Is the following program thread safe ?. Please help...

[Steven Rodeo]

I've been trying to analyze the following class and see that there is always a dead lock in the following call to hello.

Yep this is a multithreaded application.

public final class ABCD {
 
    /** A HashMap to store the mappings between file and its extensions. **/
    private static final Map < String, String >
                 MIMETABLE = new HashMap < String, String >(50);
 
    /** A HashMap to store the mappings between file and its extensions. **/
    private static final Map < String, String >
                 EXTENSION = new HashMap < String, String >(30);
 
    /** This map is created statically.
     */
    static {
        EXTENSION.put(
                "vsd", "visio"
        );
        EXTENSION.put(
                "html", "HTML"
        );
        EXTENSION.put(
                "htm", "HTM"
                );
        EXTENSION.put(
                "txt", "TEXT"
                );
        EXTENSION.put(
                "doc", "MSWORD"
                );
        EXTENSION.put(
                "pdf", "PDF"
                );
    }
 
    static {
        MIMETABLE.put(
                "APPLICATION/VND.VISIO", "A visio File"
                );
        MIMETABLE.put(
                "APPLICATION/VND.SUN.XML.WRITER.TEMPLATE", "A ODF File"
                );
        MIMETABLE.put(
                "APPLICATION/VND.SUN.XML.CALC.TEMPLATE", "A ODF File"
                );
        MIMETABLE.put(
                "APPLICATION/VND.SUN.XML.IMPRESS.TEMPLATE", "A ODF File");
        MIMETABLE.put(
                "APPLICATION/VND.OASIS.OPENDOCUMENT.GRAPHICS-TEMPLATE",
                "A ODF File"
                );
    }
 
    /** Constructor. **/
    private ABCD() {
    }
 
    public static SomeConcreteMethod InstanceFromMimeType(
              final String mimetype, final String fileName,
              final InputStream isr
        ) throws IssException {
 
        String className = MIMETABLE.get(mimetype);
        if (null == className) {
            if(mimetype.equals("APPLICATION/OCTET-STREAM")
                    && (null != fileName)) {
                String filextension = getFileExtension(fileName);
                if (null != filextension) {
                    className = EXTENSION.get(filextension);
                } else {
                    className
                            = MIMETABLE.get(hello(isr));
                }
                if(null == className) {
                    return null;
                }
            } else {
                return null;
            }
        }
 
        Class c = null;
        SomeConcreteMethod cb = null;
        try {
                  c = Class.forName(PACKAGENAME+"."+className);
                  cb = (SomeConcreteMethod)c.newInstance();
        } catch (ClassNotFoundException cie) {
                  cb = null;
        } catch  (InstantiationException cie) {
                  cb = null;
        } catch  (IllegalAccessException cie) {
                  cb = null;
        }
        return cb;
    }
 
    /**
     * get mime type based on input file stream.
     **/
    private static String hello(final InputStream isr) {
 
        String mimeType = null;
        // Enough to determine the Magic Number
        byte[] bs = new byte[4096];
        int bytesRead = 0;
 
        try {
            while (bytesRead < bs.length) {
                bytesRead += isr.read(bs, bytesRead, bs.length - bytesRead);
            }
            MagicMatch match = null;
            synchronized (Magic.class) {
                match = Magic.getMagicMatch(bs);
            }
            // if a match was found we can return the new mimeType
            if (null != match) {
                mimeType = match.getMimeType();
                return mimeType.toUpperCase();
            }
        } catch (Exception ex) {
        }
        return null;
    }
}

[Sagar Rohankar]

Have you thought about synchronizing the "hello" method ??

[Ray Hsieh]

Well, to be sure, create a thread dump. If it's on Windows you press Ctrl + Break. For example, if we have an obvious deadlock like this:

public class Deadlock {
private static final Object l1 = new Object();
private static final Object l2 = new Object();
public static void main(String[] args) {
new Thread(new Runnable() {
@Override public void run() {
synchronized (l1) {
Thread.yield();
try { Thread.sleep(1000); } catch (InterruptedException e) {}
synchronized (l2) {}
}
}
}).start();
new Thread(new Runnable() {
@Override public void run() {
synchronized (l2) {
Thread.yield();
try { Thread.sleep(1000); } catch (InterruptedException e) {}
synchronized (l1) {}
}
}
}).start();
}
}

Then pressing Ctrl + Break on Windows gives you a bunch of text that highlights the deadlock like this:

... a lot of text ...

Found one Java-level deadlock:
=============================
"Thread-1":
waiting to lock monitor 0x02a807cc (object 0x2405edb0, a java.lang.Object),
which is held by "Thread-0"
"Thread-0":
waiting to lock monitor 0x02a82094 (object 0x2405edb8, a java.lang.Object),
which is held by "Thread-1"

... a lot more text ...

If you name your threads properly, you can see that this info can be very useful.