1

Code:

public void doSomethingOrThrowUncheckedException() { Thread worker = new Thread(new Runnable() { public void run() { try { myObject.doSomething() } catch(CheckedException e) { new UncheckedException (); } } }); worker.start(); }

Explanation

I want to perform some work in another thread that can throw a checked exception.

I cannot wait for this work to finish and I want the method caller to know if something went wrong with this work since the new thread is not able to handle the exception properly.

Is there a mechanism I can use?

Improve this question

4 Answers 4

Reset to default
3

Can you create a Observable outside of the thread? If something goes wrong, the thread sets a value to change that Observable. The main code is an Observer and reacts to the change when the property listener is called.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

2

It depends on what you mean by the caller knowing that something went wrong. A couple of options come to mind immediately.

  • The worker thread can set an error flag. The disadvantage is that the calling thread will need to check the flag to know that something went wrong. (There can also be a flag for success; as long as neither is set, the calling thread knows that the worker is still working.

  • The worker thread can call an error method. The disadvantage is that the call will take place in the worker thread. On the other hand, this provides a place to take positive action. The Observer pattern might be useful here (although I think Java's implementation is terrible).

Improve this answer

3 Comments

I'm just curious why Java's imlementation of Observer pattern is terrible?
@gigadot - First, Observable is a class, so if your class needs to subclass something besides Object, you can't also make it an Observable. Second, the Observer interface dates from pre-generic Java, so the call-back data is an Object that must be cast to whatever class you really need, with no compile-time type checking.
Thank you. I didn' know that Observable is part of Java API. I would do it without extending the Observable class. Observer pattern is just a programming design concept so I don't see the reason why this has to be part of the standard API. Now I can totally agree with you.
1

If, when the worker thread completes successfully it communicates the success to Foo, or produces an object that Foo consumes, then expand that mechanism to allow it to pass the checked exception along to Foo, rather than passing the exception to the method calling thread.

public void doSomething() { Thread worker = new Thread(new Runnable() { public void run() { try { result = myObject.doSomething(); foo.processResult(result); } catch(CheckedException e) { foo.processException(e); } } }); worker.start(); } public void doSomething() { Thread worker = new Thread(new Runnable() { public void run() { try { result = myObject.doSomething(); resultQueue.add(result); } catch(CheckedException e) { resultQueue.add(e); } } }); worker.start(); }

If doSomething() doesn't interact with anything when it successfully completes then you'll need to follow one of the other answers.

Improve this answer

1 Comment

Unfortunately it does not interact with anything! But reading your code gave me some good ideas for solutions to other problems, so thanks! (+1)
0

You may also want to have a look at uncaughtExceptionhandler.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.