Singleton with timeout

Question

Hi!
I have to implement Singleton pattern, but I have the following restriction: The getInstance() method should not stop the entire application.
I wrote the following code, to achieve my objective:
public class ServiceProvider {
    private static Service service;
    private static final PrivateClass singletonProvider = new PrivateClass();
    private ServiceProvider() {}
    public static synchronized Service getInstance() throws MyException {
        if (service == null) {
            Thread thread = new Thread(singletonProvider);
            thread.start();
            try {
                // Ten seconds for the construction of the service field.
                Thread.sleep(10000);
            } catch (InterruptedException ex) {
                throw new MyException("InterruptedException!!!", ex);
            // Is the verification based on Thread.isAlive() safe?
            // I am not sure. Please, tell me.
            if (!thread.isAlive()) {
                if (service == null) {
                    throw new MyException("Service is still not available");
                } else {
                    return service;
            } else {
                throw new MyException("Service is still not available");
        } else {
            return service;
    // Using a private class I do not need to expose the public run() method.
    private static class PrivateClass implements Runnable {
        private PrivateClass() {}
        private synchronized Service defineInstance() throws MyException {
            if (service == null) {
                service = new Service();
            return service;
        public synchronized void run() {
            try {
                singletonProvider.defineInstance();
            } catch (Exception e) {
                e.printStackTrace();
public class Service {
    public Service() throws MyException {
        try {
            // Simulating a problem: the constructor is taking 20 seconds to be finished.
            Thread.sleep(20000);
        } catch (InterruptedException ex) {
            throw new MyException("InterruptedException in the Service constructor", ex);
    public void method() {
}I am just not sure if the verification based on Thread.isAlive() is safe.
Thanks!!!

Answer 1

malcolmmc wrote:
This sounds all very familiar. This is an occasion to use wait and notify to synchronize with your background thread. For one thing, the way you've written it, the caller to getInstance() will wait 10 seconds even if the service instance is loaded much faster than that.Yes... I tried what you are suggesting, but the problem is that using wait and notify I have to lock the PrivateClass field of the ServiceProvider class. So, since the fields should be locked, the call to the Service constructor will also be locked, and then I always have to wait the constructor finishes, no matter how I implement the logic of wait and notify.
So instead of sleep(10000L) use wait(10000L). Then when your loader sets the instance variable it calls notify on the same monitor. This will wake the main thread up if it's waiting.
You also need to deal with the case where getInstance is called a second time either when the first call to getInstance() is waiting, or after the first call has given up.I did the following solution instead. It works fine:
public class ServiceProvider {
    private static Service service;
    private static final PrivateClass privateClass = new PrivateClass();
    private ServiceProvider() {}
    public static synchronized Service getInstance() throws MyException {
        if (service == null) {
            ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
            AnotherPrivateClass anotherPrivateClass = new AnotherPrivateClass();
            Future future = executor.submit(anotherPrivateClass);
            try {
                // Ten seconds for the construction of the service field.
                future.get(10000,TimeUnit.MILLISECONDS);
            } catch (TimeoutException ex) {
                throw new MyException("Service is still not available");
            } catch (ExecutionException ex) {
                throw new MyException("Service is still not available");
            } catch (InterruptedException ex) {
                throw new MyException("Service is still not available");
            } finally {
                executor.shutdown();
            // Is the verification based on Thread.isAlive() safe?
            // I am not sure. Please, tell me.
            if (!anotherPrivateClass.thread.isAlive()) {
                if (service == null) {
                    throw new MyException("Service is still not available");
                } else {
                    return service;
            } else {
                throw new MyException("Service is still not available");
        } else {
            return service;
    private static class AnotherPrivateClass implements Runnable {
        private Thread thread;
        private AnotherPrivateClass() {
            this.thread = new Thread(privateClass);
        public synchronized void run() {
            thread.start();
            try {
                synchronized (privateClass) {
                    while (!privateClass.done) {
                        privateClass.wait();
                    if (service == null) {
                        privateClass.done = false;
            } catch (InterruptedException ex) {
                ex.printStackTrace();
    // Using a private class I do not need to expose the public run() method.
    private static class PrivateClass implements Runnable {
        boolean done = false;
        private PrivateClass() {}
        private synchronized void defineInstance() throws MyException {
            if (service == null) {
                service = new Service();
        public synchronized void run() {
            try {
                privateClass.defineInstance();
            } catch (Exception e) {
                e.printStackTrace();
            done = true;
            this.notify();
}