Dừng chuỗi lặp trong Java

Question

Tôi đang sử dụng một chuỗi liên tục đọc từ hàng đợi.

Cái gì như:

public void run() { 
    Object obj; 
    while(true) { 
     synchronized(objectsQueue) { 
      if(objectesQueue.isEmpty()) { 
       try { 
        objectesQueue.wait(); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 

       obj = objectesQueue.poll(); 
      } 
     } 

     // Do something with the Object obj 
    } 
} 

cách tốt nhất để ngăn chặn chủ đề này là gì?

tôi thấy hai lựa chọn:

1 - Kể từ Thread.stop() bị phản đối, tôi có thể thực hiện một phương pháp stopThisThread() có sử dụng một n nguyên tử biến kiểm tra điều kiện.

2 - Gửi đối tượng Sự kiện chết hoặc thứ gì đó tương tự như hàng đợi. Khi luồng tìm nạp một sự kiện tử vong, nó thoát ra.

Tôi thích cách thứ nhất, tuy nhiên, tôi không biết khi nào cần gọi phương thức stopThisThread(), vì có thể trên đường đến hàng đợi và tín hiệu dừng có thể đến trước (không mong muốn).

Mọi đề xuất?

Answer 1

Phương thức tiếp cận DeathEvent (hoặc thường được gọi là "thuốc độc") hoạt động tốt nếu bạn cần hoàn thành tất cả công việc trên hàng đợi trước khi tắt. Vấn đề là điều này có thể mất nhiều thời gian.

Nếu bạn muốn dừng lại càng sớm càng tốt, tôi đề nghị bạn làm điều này

BlockingQueue<O> queue = ... 

... 

public void run() { 
    try { 
     // The following test is necessary to get fast interrupts. If 
     // it is replaced with 'true', the queue will be drained before 
     // the interrupt is noticed. (Thanks Tim) 
     while (!Thread.interrupted()) { 
      O obj = queue.take(); 
      doSomething(obj); 
     } 
    } catch (InterruptedException ex) { 
     // We are done. 
    } 
} 

Để dừng thread t rằng instantiated với phương thức run, chỉ cần gọi t.interrupt();.

Nếu bạn so sánh mã ở trên với các câu trả lời khác, bạn sẽ nhận thấy cách sử dụng số BlockingQueue và Thread.interrupt() đơn giản hóa giải pháp.

Tôi cũng tuyên bố rằng thêm một lá cờ stop là không cần thiết và trong bức tranh lớn, có thể gây hại. Một chuỗi công nhân được xử lý tốt nên tôn trọng một ngắt. Một ngắt bất ngờ đơn giản có nghĩa là nhân viên đang được chạy trong một ngữ cảnh mà lập trình viên ban đầu không lường trước được. Điều tốt nhất là nếu người lao động làm những gì nó được yêu cầu làm ... tức là nó nên dừng lại ... có hay không điều này phù hợp với quan điểm của lập trình viên ban đầu.

Answer 2

Phương pháp tiếp cận 1 là tùy chọn ưu tiên.

Chỉ cần đặt trường biến động stop thành true và gọi interrupt() trên chuỗi đang chạy. Điều này sẽ buộc bất kỳ phương thức I/O nào chờ để trở về với một số InterruptedException (và nếu thư viện của bạn được viết chính xác thì điều này sẽ được xử lý một cách duyên dáng).

Answer 3

Tôi nghĩ rằng hai trường hợp của bạn thực sự thể hiện hành vi tương tự. Đối với trường hợp thứ hai, xem xét Thread A thêm DeathEvent sau đó Thread B thêm một FooEvent. Khi công việc của bạn nhận được DeathEvent thì vẫn còn một FooEvent đằng sau nó, đó là cùng một kịch bản mà bạn mô tả trong Option 1, trừ khi bạn cố gắng xóa hàng đợi trước khi trở về, nhưng sau đó bạn chủ yếu giữ nguyên luồng còn lại, khi bạn đang cố gắng dừng lại.

Tôi đồng ý với bạn rằng tùy chọn đầu tiên là điều mong muốn hơn. Một giải pháp tiềm năng sẽ phụ thuộc vào cách xếp hàng của bạn.Nếu nó là một phần của công việc lớp chủ đề của bạn, bạn có thể có stopThisThread của bạn() phương pháp thiết lập một lá cờ đó sẽ trả về một giá trị thích hợp (hoặc ném ngoại lệ) từ ví dụ gọi enqueuing:

MyThread extends Thread{ 
    boolean running = true; 

    public void run(){ 
    while(running){ 
     try{ 
     //process queue... 
     }catch(InterruptedExcpetion e){ 
     ... 
     } 
    } 
    } 

    public void stopThisThread(){ 
    running = false; 
    interrupt(); 
    } 

    public boolean enqueue(Object o){ 
    if(!running){ 
     return false; 
     OR 
     throw new ThreadNotRunningException(); 
    } 
    queue.add(o); 
    return true; 
    } 
} 

Sau đó nó sẽ là trách nhiệm của đối tượng cố gắng để enqueue sự kiện để đối phó với nó một cách thích hợp, nhưng ít nhất nó sẽ biết rằng sự kiện này không có trong hàng đợi, và sẽ không được xử lý.

Answer 4

Tôi thường đặt cờ trong lớp có Chủ đề trong đó và trong mã Chủ đề của tôi tôi sẽ làm. (LƯU Ý: Thay vì trong khi (đúng) tôi làm khi (cờ))

Sau đó, tạo phương thức trong lớp để đặt cờ thành sai;

private volatile bool flag = true; 

public void stopThread() 
{ 
    flag = false; 
} 

    public void run() { 
     Object obj; 
     while(flag) { 
      synchronized(objectsQueue) { 
       if(objectesQueue.isEmpty()) { 
        try { 
         objectesQueue.wait(); 
        } catch (InterruptedException e) { 
         e.printStackTrace(); 
        } 

        obj = objectesQueue.poll(); 
       } 
      } 

      // Do something with the Object obj 
     } 
    } 

Answer 5

Trong chuỗi trình đọc của bạn có điểm dừng biến boolean. Khi bạn muốn cho thread này dừng thiết lập thius thành true và ngắt thread. Trong chuỗi trình đọc khi an toàn (khi bạn không có đối tượng chưa được xử lý), hãy kiểm tra trạng thái của biến dừng và trả về vòng lặp nếu được đặt. như dưới đây.

public class readerThread extends Thread{ 
    private volitile boolean stop = false; 
    public void stopSoon(){ 
     stop = true; 
     this.interrupt(); 
    } 
    public void run() { 
     Object obj; 
     while(true) { 
      if(stop){ 
       return; 
      } 
      synchronized(objectsQueue) { 
      if(objectesQueue.isEmpty()) { 
       try { 
        objectesQueue.wait(); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
       if(stop){ 
        return; 
       }  
       obj = objectesQueue.poll(); 
       // Do something with the Object obj 
      } 
     } 
    } 


} 
public class OtherClass{ 
    ThreadReader reader; 
    private void start(){ 
      reader = ...; 
      reader.start(); 
    } 

    private void stop(){ 
      reader.stopSoon(); 
      reader.join();  // Wait for thread to stop if nessasery. 
    } 
} 

Answer 6

Tại sao không sử dụng bộ lập lịch mà bạn có thể dừng lại khi cần? Trình lên lịch chuẩn hỗ trợ lập lịch lặp lại, cũng chờ chuỗi công nhân hoàn thành trước khi lên lịch lại một lần chạy mới.

ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); 
service.scheduleWithFixedDelay(myThread, 1, 10, TimeUnit.SECONDS); 

mẫu này sẽ chạy chuỗi của bạn với thời gian trễ là 10 giây, khi khởi động xong, khởi động lại sau 10 giây. Và thay vì phải tái tạo lại bánh xe, bạn sẽ nhận được

service.shutdown() 

thời gian (thực)) không cần thiết nữa.

ScheduledExecutorService Javadoc