How to create a new thread when an existing one crashes in java

I have to maintain a series of java thread classes in legacy code.
The threads are created through spring initialization at startup of a web server.

Their run method have an infinite loop and work done in the loop
can throw a few exceptions (sql connection exceptions for example because the db is unreachable say)

Something like this

  public class MyThread extends Thread implements InitializingBean {
    ...
    @Override
    public void run() {
        try {
           while(true) {
              // do work
           }
        }
        catch (final SQLException se) {
    			// do some error handling
    		}
        finally {
           // clean up resources
        }
    }
}

The problem with the above code is that if there is an exception the thread ends. I would like the thread to either stay alive or create a new thread and try again.

What is the best practice here?
To create a new Thread?
How would I do that?

No, just wrap a while (true) {} around it. If you really do need abilities to programmatically end this thread permanently, you'd use while (!Thread.interrupted()) {} instead and ensure you return (i.e. end the thread) in the catch (InterruptedException e) {} block. Then, simply call .interrupt() on your thread to eventually kill it (an interruption results in either that Thread.interrupted() returning true exactly once, or an InterruptedException. Hence, ensure you break off your thread either way.

You could try the single thread pool and submit a runnable task to the pool. If an exception occurs the current thread gets terminated and a new one is created.

ExecutorService executorService = Executors.newSingleThreadExecutor();

>I would like the thread to either stay alive or create a new thread and try again.

(A) To stay alive, add an outer while loop as discussed in Answer by rzwitserloot.

(B) To get the effect of starting again, an alternative to starting a new thread is to rewrite your code to use the Executors framework added to Java 5. In modern Java, we rarely address the Thread class directly.

Write your task as a class implementing Runnable. Add a constructor that takes an ExecutorService object as an argument.

class DatabaseReporter implements Runnable 
{
    private final ExecutorService executerService ;

    DatabaseReporter ( final ExecutorService es ) {
        this.executerService = es ;
    }
    
    @Override
    public void run() {
        try {
           while(true) {
              // do work
           }
        }
        catch (final SQLException se) {
                // do some error handling
            }
        finally {
           // clean up resources
           // clean up any ThreadLocal uses. 
           this.executorService.submit( new DatabaseReporter( this.executorService ) ) ;
        }
    }
}

Obtain a single-threaded executor service by calling Executors.newSingleThreadExecutor().

Keep a reference to your executor service. You must perform a graceful shutdown of your executor service before your app ends. Otherwise your backing thread pool may continue indefinitely like a zombie 🧟‍♂️. Or, if in a Jakarta EE environment, use a managed executor service.

Beware of any use you may have made of ThreadLocal. Since an executor service recycles threads, any previously set ThreadLocal values remain.

In the future, when Project Loom succeeds, Java will gain virtual threads. When using virtual threads, the issue of leftover ThreadLocal goes away.