如何处理线程中的异常？

Question

I'm working on an Android App. I have a thread with this structure:

code...
try
    code...
catch
    printexception
code...
try
    code...
catch
    printexception
code..

When I encounter one of these exceptions, I know that the remainder of my code will not work and should not be executed. How I can stop the thread when I encounter an exception? Do I have to create a "big try" with all of the code inside? I've been working on code like this for some time, but I have never had to care about exceptions before. What is a good, clean way to accomplish this?

Answer 1

this is very simple, try this :

public static void main(String[] args) {
    Thread thread = new Thread(new RunnableTest());
    thread.start();
}

static class RunnableTest implements Runnable {

    @Override
    public void run() {
        int i;
        try {
            i = 1 / 0;
        } catch (Throwable t) {
            t.printStackTrace();
            return;
        }
        System.out.println(i);
    }

}

for better control over the threads you may use Executors and ThreadPoolExecutors from java.util.Concurreent package!

Answer 2

Generally, whenever you are trying to code, you should keep them in try and then under catch get the result.

its like:

try
{
int x = 5/0;
}
catch(Exception e)
{
e.printStackTrace();
}

By mentioning printStackTrace you are able to get the line number and what description of exception. I hope i made my point clear.

Answer 3

If the code you posted lives within your run() method, you can simply return early whenever an exception occurs, causing the thread to complete and avoiding execution any code that follows.

code...
try {
    code...
} catch (Exception e) {
    e.printStackTrace();
    return;
}
code...

You could also set a flag whenever an exception occurs, and periodically check that flag to determine if your thread should continue running.

bool isCanceled = false;

void run() {
    while (!isCanceled) {
        doSomeWork();
    }
}

void doSomeWork() {
    try {
        code...
    } catch (Exception e) {
        e.printStackTrace();
        isCanceled = true;
        return;
    }
}

Of course you can also structure your code so that any statements that rely on the statements above it are also within the try block. If an exception occurs, flow of control will transfer to the catch block, and any statements within the try block that follow the offending line won't be executed. I assume this is what you mean by a "big try" with all the code inside.

code...
try
    code...
    try          // this try won't be executed if the line above it throws an exception
        code...
    catch {
        printexception
        return
    }
    code..
catch {
    printexception
    return            // return early
}
code....