Is DocumentBuilder thread safe?

See the comments section for other questions about the same matter. Short answer for your question: no, it's not ok to put these classes in a singleton. Neither DocumentBuilderFactory nor DocumentBuilder are guaranteed to be thread safe. If you have several threads parsing XML, make sure each thread has its own version of DoumentBuilder. You only need one of them per thread since you can reuse a DocumentBuilder after you reset it.

EDIT A small snippet to show that using same DocumentBuilder is bad. With java 1.6_u32 and 1.7_u05 this code fails with org.xml.sax.SAXException: FWK005 parse may not be called while parsing. Uncomment synchronization on builder, and it works fine:

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();        final DocumentBuilder builder = factory.newDocumentBuilder();        ExecutorService exec = Executors.newFixedThreadPool(10);        for (int i = 0; i < 10; i++) {            exec.submit(new Runnable() {                public void run() {                    try {//                        synchronized (builder) {                            InputSource is = new InputSource(new StringReader("<?xml version=\"1.0\" encoding=\"UTF-8\" ?><俄语>данные</俄语>"));                            builder.parse(is);                            builder.reset();//                        }                    } catch (Exception e) {                        e.printStackTrace();                    }                }            });        }        exec.shutdown();

So here's your answer - do not call DocumentBuilder.parse() from multiple threads. Yes, this behavior might be JRE specific, if you're using IBM java or JRockit or give it a different DocumentBuilderImpl, it might work fine, but for default xerces implementation - it does not.

The JAXP Specification (V 1.4) says:

It is expected that the newSAXParser method of a SAXParserFactory implementation, the newDocumentBuilder method of a DocumentBuilderFactory and the newTransformer method of a TransformerFactory will be thread safe without side effects. This means that an application programmer should expect to be able to create transformer instances in multiple threads at once from a shared factory without side effects or problems.

https://jaxp.java.net/docs/spec/html/#plugabililty-thread-safety

So, for example, you should be able to create a single DocumentBuilderFactory instance via DocumentBuilderFactory.newInstance and then use that single factory to create a DocumentBuilder per thread via DocumentBuilderFactory.newDocumentBuilder. You could also create a pool of DocumentBuilders.

I can't find anywhere that says that, for example, the static method DocumentBuilderFactory.newInstance is thread-safe. The implementation appears thread-safe in that there is some method synchronization being done, but the spec specifically says that DocumentBuilderFactory.newDocumentBuilder is thread safe.

You need to know three things:

1. What is the cost of creating the factory? If the cost is low, your performance gain might be close to zero.
2. What is the cost of creating the builder? If the cost is low, your performance gain might be close to zero.
3. Is the factory and/or builder thread safe? If not, you need to make sure the method accessing them is made thread safe using the synchronized keyword.

I'm not familiar with the DocumentBuilder classes you are using, but all this information should be available in its javadoc or other documentation. If the creation of certain objects is costly, they usually throw this information at you.