Làm thế nào để dừng đúng luồng trong Java?

Tôi cần một giải pháp để dừng đúng luồng trong Java.

Tôi có IndexProcessorlớp thực hiện giao diện 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;
            }
        }

    }
}

Và tôi có ServletContextListenerlớp bắt đầu và dừng chuỗi:

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.");
        }
    }
}

Nhưng khi tôi tắt tomcat, tôi nhận được ngoại lệ trong lớp IndexProcessor của mình:

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)

Tôi đang sử dụng JDK 1.6. Vì vậy, câu hỏi là:

Làm thế nào tôi có thể dừng chủ đề và không ném bất kỳ ngoại lệ?

PS Tôi không muốn sử dụng .stop();phương pháp vì nó không được dùng nữa.

Trong IndexProcessorlớp, bạn cần một cách để thiết lập một cờ thông báo cho luồng rằng nó sẽ cần chấm dứt, tương tự như biến runmà bạn đã sử dụng chỉ trong phạm vi lớp.

Khi bạn muốn dừng chuỗi, bạn đặt cờ này và gọi join()trên luồng và đợi cho nó kết thúc.

Đảm bảo rằng cờ là luồng an toàn bằng cách sử dụng biến dễ bay hơi hoặc bằng cách sử dụng các phương thức getter và setter được đồng bộ hóa với biến được sử dụng làm cờ.

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;
            }
        }

    }
}

Sau đó trong 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.");
        }
    }
}

Sử dụng Thread.interrupt()là một cách hoàn toàn chấp nhận được để làm điều này. Trên thực tế, nó có thể thích hơn một lá cờ như được đề xuất ở trên. Lý do là nếu bạn đang trong một cuộc gọi chặn gián đoạn (như Thread.sleephoặc sử dụng các hoạt động Kênh java.nio), bạn thực sự sẽ có thể thoát ra khỏi những cuộc gọi đó ngay lập tức.

Nếu bạn sử dụng cờ, bạn phải đợi thao tác chặn kết thúc và sau đó bạn có thể kiểm tra cờ của mình. Trong một số trường hợp, bạn phải làm điều này bằng mọi cách, chẳng hạn như sử dụng tiêu chuẩn InputStream/ OutputStreamkhông bị gián đoạn.

Trong trường hợp đó, khi một luồng bị gián đoạn, nó sẽ không làm gián đoạn IO, tuy nhiên, bạn có thể dễ dàng thực hiện việc này thường xuyên trong mã của mình (và bạn nên làm điều này tại các điểm chiến lược nơi bạn có thể dừng và dọn dẹp một cách an toàn)

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

Giống như tôi đã nói, lợi thế chính Thread.interrupt()là bạn có thể thoát ra khỏi các cuộc gọi bị gián đoạn, điều mà bạn không thể làm với cách tiếp cận cờ.

Câu trả lời đơn giản: Bạn có thể dừng một chủ đề THỰC TẾ theo một trong hai cách phổ biến:

• Phương thức chạy đạt một chương trình con trả về.
• Chạy phương thức kết thúc, và trả về ngầm.

Bạn cũng có thể dừng chủ đề NGOẠI TỆ:

• Gọi system.exit(điều này sẽ giết chết toàn bộ quá trình của bạn)
• Gọi interrupt()phương thức của đối tượng luồng *
• Xem nếu luồng có một phương thức được triển khai có vẻ như nó sẽ hoạt động (như kill()hoặc stop())

*: Kỳ vọng là điều này được cho là dừng một chuỗi. Tuy nhiên, những gì luồng thực sự làm khi điều này xảy ra hoàn toàn phụ thuộc vào những gì nhà phát triển đã viết khi họ tạo ra việc thực hiện luồng.

Một mô hình phổ biến mà bạn thấy khi triển khai phương thức chạy là a while(boolean){}, trong đó boolean thường là một cái gì đó được đặt tên isRunning, đó là một biến thành viên của lớp luồng của nó, nó dễ bay hơi và thường được truy cập bởi các luồng khác bằng phương thức sắp xếp setter, ví dụ kill() { isRunnable=false; }. Các chương trình con này là tốt bởi vì chúng cho phép luồng phát hành bất kỳ tài nguyên nào nó giữ trước khi kết thúc.

Bạn phải luôn kết thúc chuỗi bằng cách kiểm tra cờ trong run()vòng lặp (nếu có).

Chủ đề của bạn sẽ trông như thế này:

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;
    }
}

Sau đó, bạn có thể kết thúc chuỗi bằng cách gọi thread.stopExecuting(). Bằng cách đó, chủ đề được kết thúc sạch sẽ, nhưng điều này mất đến 15 giây (do giấc ngủ của bạn). Bạn vẫn có thể gọi thread.interrupt () nếu nó thực sự khẩn cấp - nhưng cách ưu tiên luôn là kiểm tra cờ.

Để tránh phải chờ 15 giây, bạn có thể chia nhỏ giấc ngủ như thế này:

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

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

Thông thường, một chủ đề bị chấm dứt khi nó bị gián đoạn. Vì vậy, tại sao không sử dụng boolean bản địa? Hãy thử 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- Làm thế nào tôi có thể giết một chủ đề? không sử dụng stop ();

Để đồng bộ hóa các luồng, tôi thích sử dụng CountDownLatchnó giúp các luồng chờ cho đến khi quá trình được thực hiện hoàn tất. Trong trường hợp này, lớp worker được thiết lập với một CountDownLatchthể hiện với số lượng đã cho. Một cuộc gọi đến awaitphương thức sẽ chặn cho đến khi tổng số hiện tại bằng không do các yêu cầu của countDownphương thức hoặc bộ thời gian chờ đã đạt được. Cách tiếp cận này cho phép ngắt một luồng ngay lập tức mà không phải chờ thời gian chờ đã chỉ định để trôi qua:

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;
        }

    }
}

Khi bạn muốn hoàn thành việc thực hiện luồng khác, hãy thực hiện CountDown trên CountDownLatchvàjoin luồng luồng cho luồng chính:

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.");
        } 
    }
}

Một số thông tin bổ sung. Cả cờ và ngắt đều được đề xuất trong tài liệu Java.

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();
    }
}

Đối với một chuỗi chờ trong thời gian dài (ví dụ: cho đầu vào), hãy sử dụng Thread.interrupt

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

Tôi đã không làm gián đoạn hoạt động trong Android, vì vậy tôi đã sử dụng phương pháp này, hoạt động hoàn hảo:

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;
 }

Thỉnh thoảng tôi sẽ thử 1000 lần trong onDestroy () / contextDestroyed () của tôi

      @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();}
        }

    }