Detaillierte Erläuterung von Java-Beispielen: Ausnahme für Sub-Thread-Aufgaben, Rollback der Haupt-Thread-Transaktion

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java, in dem hauptsächlich verwandte Probleme zum Zurücksetzen der Haupt-Thread-Transaktion vorgestellt werden, wenn eine Ausnahme in der Unter-Thread-Aufgabe auftritt, einschließlich Ausnahmeerfassung und Transaktions-Rollback usw. Werfen wir einen Blick darauf Ich hoffe, dass der Inhalt unten für alle hilfreich ist.

Empfohlene Studie: „Java-Video-Tutorial“

1. Stellen Sie eine Frage

Wenn während der Ausführung dieser Aufgabe eine Ausnahme auftritt, wie um den Hauptthread zuzulassen Die Ausnahme wird abgefangen und die Transaktion wird zurückgesetzt.

2. Hauptthread und Unterthread

Schauen wir uns zunächst die Grundlagen an. Das Bild unten zeigt das nach dem Hauptthread startet einen Unterthread, den zweiten. Sie agieren unabhängig voneinander, ohne sich gegenseitig zu stören. Von nun an sind Sie und ich nur noch Passanten.

Das Bild rechts zeigt, dass der Hauptthread einen Unterthread startet und dann die Programmlogik des Hauptthreads weiter ausführt und das Ausführungsergebnis des Unterthreads durch Blockieren an einem bestimmten Knoten erhält.

Für das oben angesprochene Problem muss die zweite Methode darin bestehen, das Problem zu lösen, dass der Hauptthread Ausnahmen erfassen kann, die während der Ausführung des Unterthreads auftreten. Ich muss hier eine Interviewfrage stellen, den Unterschied zwischen den beiden Schnittstellen Callable und Runnable, die Threads implementieren:

public interface Callable<v> {
    V call() throws Exception;}</v>

public interface Runnable {
    public abstract void run();}

public class ExpSubThread implements Callable {
    @Override
    public Object call() throws Exception {
        throw new NullPointerException();
    }}

Beim Ausführen einer Aufgabe wird kein neuer Thread erstellt, sondern die vorhandenen Thread-Ressourcen im Thread-Pool verwendet. Wenn die Aufgabenausführung abgeschlossen ist, wird die Thread-Ressource nicht zerstört, sondern an den Thread-Pool zurückgegeben. Daher werden bis zu einem gewissen Grad die durch die Thread-Erstellung und -Zerstörung verbrauchten Ressourcen eingespart und der Zweck der Wiederverwendung von Thread-Ressourcen erreicht.

Da es eine Obergrenze für die Größe des Thread-Pools gibt, besteht eine weitere Funktion des Thread-Pools darin, die unbegrenzte Erstellung von Threads zu verhindern und Systemabstürze zu vermeiden, die durch die unbegrenzte Belegung von Anwendungsressourcen verursacht werden.
• Es gibt zwei häufig verwendete Thread-Pools, einer ist der im JDK enthaltene und der andere ist der Spring-Thread-Pool. Letzterer wird häufig in der Spring-Umgebung verwendet und ist ähnlich. Hier verwenden wir die Spring-API, um einen Thread-Pool zu erstellen.

public ThreadPoolTaskExecutor getThreadPool(){
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setMaxPoolSize(100);  //线程池最大线程数
        executor.setCorePoolSize(50);//线程池核心线程数
        executor.setQueueCapacity(50);//任务队列的大小
        executor.setThreadNamePrefix("test_"); //线程前缀名
        executor.initialize(); //线程初始化
        return executor;}

@Testvoid subThreadExceptionTest() {
        try{
            //新建子线程对象
            ExpSubThread expSubThread = new ExpSubThread();
            //构建线程池
            ThreadPoolTaskExecutor executor = getThreadPool();
            //提交子线程任务，submit方法
            Future future = executor.submit(expSubThread);
            //在这里可以做主线程的业务其他流程操作
            //阻塞等待子线程的执行结果
            Object obj = future.get();  
        }catch (Exception e){
            e.printStackTrace();
            //事务回滚
        }}

Nach dem Login kopieren

Die Ausführungsmethode hat keinen Rückgabewert, sodass nicht beurteilt werden kann, ob die Aufgabe erfolgreich abgeschlossen wurde. Die entsprechende Thread-Klasse implementiert die Runnable-Schnittstelle.

Die Submit-Methode hat einen Rückgabewert, der eine Zukunft zurückgibt, und die entsprechende Thread-Klasse implementiert die Callable-Schnittstelle.

Die Methode Future.get () erreicht den Zweck, den Hauptthread zu blockieren, sodass das Ausführungsergebnis der Unterthread-Aufgabe beurteilt werden kann und die get-Methode eine Ausnahme auslösen kann.

    V get() throws InterruptedException, ExecutionException;

Auf dem Bild sehen Sie zwei Ausnahmeausnahmen, die wir aktiv in der Sub-Thread-Aufgabe auslösen die andere Eine ExecutionException, die von der get-Methode aufgrund eines Nullzeigers ausgelöst wird.

e.printStackTrace();

5. Transaktions-Rollback

thread-Klasse implementiert, um den Zweck zu erreichen, den Thread-Rückgabewert abzurufen oder eine Ausnahme auszulösen.

submit kann Thread-Aufgaben an den Thread-Pool senden und den Rückgabewert Future des Sub-Thread-Ausführungsergebnisses erhalten.
• Die get()-Methode von Future kann Informationen zur Sub-Thread-Ausführung abrufen, einschließlich ausgelöster Ausnahmen.
• Da wir nun die Ausnahmeinformationen des Sub-Threads im Haupt-Thread erkennen oder abfangen können, ist es dann zu einfach, die Transaktion des Haupt-Threads im nächsten Schritt zurückzusetzen?
• jdbc implementiert das Transaktions-Rollback über conn.rollback() conn.rollback()实现事务的回滚
• spring环境下使用@Transactional
Verwenden Sie einfach die Annotation @Transactional in der Spring-Umgebung.

Empfohlenes Lernen: „Java-Video-Tutorial

“🎜

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung von Java-Beispielen: Ausnahme für Sub-Thread-Aufgaben, Rollback der Haupt-Thread-Transaktion. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!