จะหยุดการเธรดใน Java อย่างถูกต้องได้อย่างไร?

ฉันต้องการวิธีแก้ปัญหาเพื่อหยุดเธรดใน Java อย่างถูกต้อง

ฉันมีIndexProcessorคลาสที่ใช้ส่วนต่อประสาน Runnable:

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);

    @Override
    public void run() {
        boolean run = true;
        while (run) {
            try {
                LOGGER.debug("Sleeping...");
                Thread.sleep((long) 15000);

                LOGGER.debug("Processing");
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
                run = false;
            }
        }

    }
}

และฉันมีServletContextListenerชั้นเรียนที่เริ่มต้นและหยุดเธรด:

public class SearchEngineContextListener implements ServletContextListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(SearchEngineContextListener.class);

    private Thread thread = null;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        thread = new Thread(new IndexProcessor());
        LOGGER.debug("Starting thread: " + thread);
        thread.start();
        LOGGER.debug("Background process successfully started.");
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        LOGGER.debug("Stopping thread: " + thread);
        if (thread != null) {
            thread.interrupt();
            LOGGER.debug("Thread successfully stopped.");
        }
    }
}

แต่เมื่อฉันปิด Tomcat ฉันได้รับข้อยกเว้นในคลาส IndexProcessor ของฉัน:

2012-06-09 17:04:50,671 [Thread-3] ERROR  IndexProcessor Exception
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at lt.ccl.searchengine.processor.IndexProcessor.run(IndexProcessor.java:22)
    at java.lang.Thread.run(Unknown Source)

ฉันใช้ JDK 1.6 ดังนั้นคำถามคือ:

ฉันจะหยุดเธรดและไม่โยนข้อยกเว้นใด ๆ ได้อย่างไร

PSฉันไม่ต้องการใช้.stop();วิธีการเพราะเลิกใช้แล้ว

ในIndexProcessorชั้นเรียนคุณต้องมีวิธีการตั้งค่าสถานะซึ่งแจ้งเธรดที่จะต้องยกเลิกคล้ายกับตัวแปรrunที่คุณใช้ในขอบเขตของคลาส

เมื่อคุณต้องการหยุดเธรดคุณตั้งค่าสถานะนี้และเรียกใช้join()บนเธรดและรอให้เสร็จสิ้น

ตรวจสอบให้แน่ใจว่าการตั้งค่าสถานะเป็นเธรดที่ปลอดภัยโดยใช้ตัวแปร volatile หรือโดยใช้วิธี getter และ setter ซึ่งซิงโครไนส์กับตัวแปรที่ใช้เป็นค่าสถานะ

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);
    private volatile boolean running = true;

    public void terminate() {
        running = false;
    }

    @Override
    public void run() {
        while (running) {
            try {
                LOGGER.debug("Sleeping...");
                Thread.sleep((long) 15000);

                LOGGER.debug("Processing");
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
                running = false;
            }
        }

    }
}

จากนั้นในSearchEngineContextListener:

public class SearchEngineContextListener implements ServletContextListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(SearchEngineContextListener.class);

    private Thread thread = null;
    private IndexProcessor runnable = null;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        runnable = new IndexProcessor();
        thread = new Thread(runnable);
        LOGGER.debug("Starting thread: " + thread);
        thread.start();
        LOGGER.debug("Background process successfully started.");
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        LOGGER.debug("Stopping thread: " + thread);
        if (thread != null) {
            runnable.terminate();
            thread.join();
            LOGGER.debug("Thread successfully stopped.");
        }
    }
}

การใช้Thread.interrupt()เป็นวิธีที่ยอมรับได้อย่างสมบูรณ์แบบในการทำเช่นนี้ ในความเป็นจริงมันอาจจะดีกว่าการตั้งค่าสถานะตามที่แนะนำข้างต้น เหตุผลที่ว่าถ้าคุณอยู่ในการโทรที่บล็อกไม่ได้ (เช่นThread.sleepหรือใช้การดำเนินการช่อง java.nio) คุณจะสามารถแยกสิ่งเหล่านั้นออกได้ทันที

หากคุณใช้การตั้งค่าสถานะคุณต้องรอให้การดำเนินการบล็อกเสร็จสิ้นจากนั้นคุณสามารถตรวจสอบการตั้งค่าสถานะของคุณ ในบางกรณีคุณต้องทำเช่นนี้เช่นการใช้มาตรฐานInputStream/ OutputStreamซึ่งไม่สามารถขัดจังหวะได้

ในกรณีนั้นเมื่อเธรดถูกขัดจังหวะเธรดจะไม่ขัดจังหวะ IO อย่างไรก็ตามคุณสามารถทำสิ่งนี้ได้เป็นประจำในรหัสของคุณ (และคุณควรทำเช่นนี้ที่จุดยุทธศาสตร์ที่คุณสามารถหยุดและล้างได้อย่างปลอดภัย)

if (Thread.currentThread().isInterrupted()) {
  // cleanup and stop execution
  // for example a break in a loop
}

ดังที่ฉันได้กล่าวไปข้อได้เปรียบหลักThread.interrupt()คือคุณสามารถแยกการโทรออกที่ขัดจังหวะได้ทันทีซึ่งคุณไม่สามารถทำได้ด้วยวิธีการตั้งค่าสถานะ

คำตอบง่ายๆ: คุณสามารถหยุดเธรดภายในได้ด้วยวิธีใดวิธีหนึ่งจากสองวิธี:

• เมธอด run ส่งผลให้รูทีนย่อย return
• วิธีการเรียกใช้เสร็จสิ้นและส่งกลับโดยปริยาย

นอกจากนี้คุณยังสามารถหยุดกระทู้ภายนอก:

• โทร system.exit (นี้จะฆ่ากระบวนการทั้งหมดของคุณ)
• เรียกวัตถุของเธรด interrupt()วิธีการ *
• ดูว่าเธรดมีวิธีการใช้งานที่ฟังดูเหมือนจะใช้งานได้ไหม (เช่นkill()หรือstop())

*: ความคาดหวังคือสิ่งนี้ควรหยุดเธรด อย่างไรก็ตามสิ่งที่เธรดทำจริงเมื่อเกิดเหตุการณ์นี้ขึ้นอยู่กับสิ่งที่นักพัฒนาเขียนเมื่อสร้างการใช้เธรด

รูปแบบทั่วไปที่คุณเห็นกับการใช้งานวิธีการทำงานเป็นwhile(boolean){}ที่บูลโดยทั่วไปจะมีบางสิ่งบางอย่างที่มีชื่อisRunningก็เป็นตัวแปรสมาชิกของชั้นด้ายของมันก็มีความผันผวนและมักจะสามารถเข้าถึงได้โดยหัวข้ออื่น ๆ kill() { isRunnable=false; }โดยวิธีการตั้งค่าของทุกประเภทเช่น รูทีนย่อยเหล่านี้ดีเพราะอนุญาตให้เธรดปล่อยรีซอร์สใด ๆ ที่เก็บไว้ก่อนที่จะยกเลิก

คุณควรสิ้นสุดเธรดเสมอโดยตรวจสอบการตั้งค่าสถานะในการrun()วนรอบ (ถ้ามี)

หัวข้อของคุณควรมีลักษณะเช่นนี้:

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);
    private volatile boolean execute;

    @Override
    public void run() {
        this.execute = true;
        while (this.execute) {
            try {
                LOGGER.debug("Sleeping...");
                Thread.sleep((long) 15000);

                LOGGER.debug("Processing");
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
                this.execute = false;
            }
        }
    }

    public void stopExecuting() {
        this.execute = false;
    }
}

thread.stopExecuting()จากนั้นคุณสามารถจบด้ายโดยการเรียก วิธีนี้จะทำให้เธรดสะอาด แต่ใช้เวลาสูงสุด 15 วินาที (เนื่องจากคุณนอนหลับ) คุณยังสามารถเรียกใช้เธรดขัดจังหวะ () หากเป็นเรื่องเร่งด่วน แต่วิธีที่ต้องการควรตรวจสอบการตั้งค่าสถานะเสมอ

เพื่อหลีกเลี่ยงการรอเป็นเวลา 15 วินาทีคุณสามารถแบ่งการนอนหลับดังนี้:

        ...
        try {
            LOGGER.debug("Sleeping...");
            for (int i = 0; (i < 150) && this.execute; i++) {
                Thread.sleep((long) 100);
            }

            LOGGER.debug("Processing");
        } catch (InterruptedException e) {
        ...

โดยทั่วไปเธรดจะถูกยกเลิกเมื่อถูกขัดจังหวะ ดังนั้นทำไมไม่ใช้บูลีนดั้งเดิม ลองใช้ isInterrupted ():

Thread t = new Thread(new Runnable(){
        @Override
        public void run() {
            while(!Thread.currentThread().isInterrupted()){
                // do stuff         
            }   
        }});
    t.start();

    // Sleep a second, and then interrupt
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {}
    t.interrupt();

ref- ฉันจะฆ่าเธรดได้อย่างไร โดยไม่ใช้ stop ();

สำหรับการซิงโครไนซ์เธรดฉันต้องการใช้CountDownLatchซึ่งจะช่วยให้เธรดรอจนกว่ากระบวนการที่กำลังดำเนินการเสร็จสมบูรณ์ ในกรณีนี้คลาสคนงานถูกตั้งค่าด้วยCountDownLatchอินสแตนซ์ที่มีการนับที่กำหนด การเรียกawaitใช้เมธอดจะบล็อกจนกว่าจำนวนปัจจุบันจะถึงศูนย์เนื่องจากการเรียกใช้countDownเมธอดหรือถึงการหมดเวลาที่ตั้งไว้ วิธีการนี้อนุญาตให้ขัดจังหวะเธรดได้ทันทีโดยไม่ต้องรอเวลารอที่ระบุเพื่อผ่านไป:

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);

    private final CountDownLatch countdownlatch;
    public IndexProcessor(CountDownLatch countdownlatch) {
        this.countdownlatch = countdownlatch;
    }


    public void run() {
        try {
            while (!countdownlatch.await(15000, TimeUnit.MILLISECONDS)) {
                LOGGER.debug("Processing...");
            }
        } catch (InterruptedException e) {
            LOGGER.error("Exception", e);
            run = false;
        }

    }
}

เมื่อคุณต้องการดำเนินการของเธรดอื่นให้ดำเนินการ countDown บนCountDownLatchและjoinเธรดไปยังเธรดหลัก:

public class SearchEngineContextListener implements ServletContextListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(SearchEngineContextListener.class);

    private Thread thread = null;
    private IndexProcessor runnable = null;
    private CountDownLatch countdownLatch = null;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        countdownLatch = new CountDownLatch(1);
        Thread thread = new Thread(new IndexProcessor(countdownLatch));
        LOGGER.debug("Starting thread: " + thread);
        thread.start();
        LOGGER.debug("Background process successfully started.");
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        LOGGER.debug("Stopping thread: " + thread);
        if (countdownLatch != null) 
        {
            countdownLatch.countDown();
        } 
        if (thread != null) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
            }
            LOGGER.debug("Thread successfully stopped.");
        } 
    }
}

ข้อมูลเสริมบางอย่าง แนะนำให้ตั้งค่าสถานะและอินเตอร์รัปต์ใน Java doc

https://docs.oracle.com/javase/8/docs/technotes/guides/concurrency/threadPrimitiveDeprecation.html

private volatile Thread blinker;

public void stop() {
    blinker = null;
}

public void run() {
    Thread thisThread = Thread.currentThread();
    while (blinker == thisThread) {
        try {
            Thread.sleep(interval);
        } catch (InterruptedException e){
        }
        repaint();
    }
}

สำหรับเธรดที่รอเป็นเวลานาน (เช่นสำหรับอินพุต) ให้ใช้ Thread.interrupt

public void stop() {
     Thread moribund = waiter;
      waiter = null;
      moribund.interrupt();
 }

ฉันไม่ได้ขัดจังหวะการทำงานใน Android ดังนั้นฉันจึงใช้วิธีนี้ทำงานได้อย่างสมบูรณ์แบบ:

boolean shouldCheckUpdates = true;

private void startupCheckForUpdatesEveryFewSeconds() {
    threadCheckChat = new Thread(new CheckUpdates());
    threadCheckChat.start();
}

private class CheckUpdates implements Runnable{
    public void run() {
        while (shouldCheckUpdates){
            System.out.println("Do your thing here");
        }
    }
}

 public void stop(){
        shouldCheckUpdates = false;
 }

บางครั้งฉันจะลอง 1,000 ครั้งใน onDestroy () / contextDestroyed ()

      @Override
    protected void onDestroy() {
        boolean retry = true;
        int counter = 0;
        while(retry && counter<1000)
        {
            counter++;
            try{thread.setRunnung(false);
                thread.join();
                retry = false;
                thread = null; //garbage can coll
            }catch(InterruptedException e){e.printStackTrace();}
        }

    }