Bagaimana Shutdown Hooks Memastikan Penamatan Program Anggun di Java?

Menggunakan Cangkuk Penutupan untuk Penamatan Program Anggun di Java

Kait penutup menyediakan mekanisme untuk memastikan aplikasi Java melaksanakan tugas pembersihan yang diperlukan sebelum keluar dengan anggun. Dalam artikel ini, kami akan menyelidiki aplikasi praktikal cangkuk penutupan, meneroka senario di mana kami ingin memastikan data dibuang ke fail sebelum penamatan program.

Pertimbangkan aplikasi Java berikut:

<code class="java">package com.example.test.concurrency;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;

public class GracefulShutdownTest1 {
    final private int N;
    final private File f;

    public GracefulShutdownTest1(File f, int N) { this.f=f; this.N = N; }

    public void run()
    {
        PrintWriter pw = null;
        try {
            FileOutputStream fos = new FileOutputStream(this.f);
            pw = new PrintWriter(fos);
            for (int i = 0; i < N; ++i)
                writeBatch(pw, i);
        }
        catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        finally
        {
            pw.close();
        }       
    }

    // Write a batch of numbers to the file
    private void writeBatch(PrintWriter pw, int i) {
        for (int j = 0; j < 100; ++j)
        {
            int k = i*100+j;
            pw.write(Integer.toString(k));
            if ((j+1)%10 == 0)
                pw.write('\n');
            else
                pw.write(' ');
        }
    }

    public static void main(String[] args)
    {
        if (args.length < 2)
        {
            System.out.println("args = [file] [N] "
                    +"where file = output filename, N=batch count");
        }
        else
        {
            new GracefulShutdownTest1(
                    new File(args[0]), 
                    Integer.parseInt(args[1])
            ).run();
        }
    }
}</code>

Dalam aplikasi ini, kami menulis kumpulan nombor pada fail. Untuk memastikan bahawa satu kelompok selesai sebelum atur cara diganggu, kami akan menggunakan cangkuk penutupan.

Menyepadukan Cangkuk Penutupan

Untuk menyepadukan cangkuk penutupan, ikut langkah berikut:

1. Daftar cangkuk penutupan: Gunakan kaedah Runtime.getRuntime().addShutdownHook() untuk mendaftarkan cangkuk penutupan dengan JVM.
2. Laksanakan penutupan cangkuk: Takrifkan utas (subkelas Benang) yang mentakrifkan tindakan yang akan dilakukan apabila cangkuk dipanggil.
3. Dalam cangkuk tutup: Tetapkan bendera atau pembolehubah atom kepada palsu untuk memberi isyarat kepada utas utama supaya berhenti menulis pada fail.
4. Dalam utas utama: Semak bendera atau pembolehubah atom di dalam gelung tulis. Apabila ia menjadi palsu, hentikan menulis dan selesaikan sebarang operasi yang belum selesai.
5. Sertai utas: Setelah penulisan selesai, sertai utas utama (atau mana-mana utas yang berfungsi) untuk memastikan semua utas mempunyai selesai melaksanakan.

Berikut ialah contoh:

Tambah pembolehubah keepRunning:

<code class="java">final static volatile boolean keepRunning = true;</code>

Ubah suai run() kaedah:

<code class="java">//...
for (int i = 0; i < N && keepRunning; ++i)
    writeBatch(pw, i);
//...</code>

Tambah cangkuk tutup dalam main():

<code class="java">//...
Runtime.getRuntime().addShutdownHook(new Thread() {
    public void run() {
        keepRunning = false;
        mainThread.join();
    }
});
//...</code>

Apabila JVM menerima isyarat tutup (cth., Ctrl C ), cangkuk penutupan akan menetapkan keepRunning kepada false. Kaedah run() kemudiannya akan meneruskan penulisan data sehingga keepRunning adalah palsu, memastikan kumpulan semasa selesai sebelum program keluar.

Atas ialah kandungan terperinci Bagaimana Shutdown Hooks Memastikan Penamatan Program Anggun di Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!