Làm cách nào để chạy một chuỗi Runnable trong Android theo các khoảng thời gian xác định?

Tôi đã phát triển một ứng dụng để hiển thị một số văn bản theo các khoảng thời gian xác định trong màn hình giả lập Android. Tôi đang sử dụng Handlerlớp học. Đây là một đoạn trong mã của tôi:

handler = new Handler();
Runnable r = new Runnable() {
    public void run() {
        tv.append("Hello World");               
    }
};
handler.postDelayed(r, 1000);

Khi tôi chạy ứng dụng này, văn bản chỉ được hiển thị một lần. Tại sao?

Cách khắc phục đơn giản cho ví dụ của bạn là:

handler = new Handler();

final Runnable r = new Runnable() {
    public void run() {
        tv.append("Hello World");
        handler.postDelayed(this, 1000);
    }
};

handler.postDelayed(r, 1000);

Hoặc chúng ta có thể sử dụng chủ đề bình thường chẳng hạn (với Người chạy ban đầu):

Thread thread = new Thread() {
    @Override
    public void run() {
        try {
            while(true) {
                sleep(1000);
                handler.post(this);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};

thread.start();

Bạn có thể coi đối tượng có thể chạy của mình giống như một lệnh có thể được gửi đến hàng đợi tin nhắn để thực thi và xử lý như một đối tượng trợ giúp được sử dụng để gửi lệnh đó.

Thông tin chi tiết có tại đây http://developer.android.com/reference/android/os/Handler.html

new Handler().postDelayed(new Runnable() {
    public void run() {
        // do something...              
    }
}, 100);

Tôi nghĩ có thể cải thiện giải pháp đầu tiên của Alex2k8 để cập nhật chính xác từng giây

1. Mã gốc:

public void run() {
    tv.append("Hello World");
    handler.postDelayed(this, 1000);
}

2.Phân tích

• Trong chi phí trên, giả sử tv.append("Hello Word")chi phí T mili giây, sau khi hiển thị 500 lần thời gian trễ là 500 * T mili giây
• Nó sẽ tăng chậm khi chạy thời gian dài

3. Giải pháp

Để tránh điều đó, chỉ cần thay đổi thứ tự của postDelayed (), để tránh bị trì hoãn:

public void run() {
    handler.postDelayed(this, 1000);
    tv.append("Hello World");
}

Để lặp lại tác vụ, bạn có thể sử dụng

new Timer().scheduleAtFixedRate(task, runAfterADelayForFirstTime, repeaingTimeInterval);

gọi nó như thế

new Timer().scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {

            }
        },500,1000);

Đoạn mã trên sẽ chạy lần đầu tiên sau nửa giây (500) và lặp lại sau mỗi giây (1000)

Ở đâu

nhiệm vụ là phương thức được thực thi

sau thời gian thực hiện ban đầu

( khoảng thời gian để lặp lại việc thực hiện)

Thứ hai

Và bạn cũng có thể sử dụng CountDownTimer nếu bạn muốn thực thi số lần Nhiệm vụ.

    new CountDownTimer(40000, 1000) { //40000 milli seconds is total time, 1000 milli seconds is time interval

     public void onTick(long millisUntilFinished) {
      }
      public void onFinish() {
     }
    }.start();

//Above codes run 40 times after each second

Và bạn cũng có thể làm điều đó với runnable. tạo một phương thức runnable như

Runnable runnable = new Runnable()
    {
        @Override
        public void run()
        {

        }
    };

Và gọi nó theo cả hai cách

new Handler().postDelayed(runnable, 500 );//where 500 is delayMillis  // to work on mainThread

HOẶC LÀ

new Thread(runnable).start();//to work in Background 

Tôi tin cho trường hợp điển hình này, tức là chạy một cái gì đó với một khoảng thời gian cố định, Timerlà phù hợp hơn. Đây là một ví dụ đơn giản:

myTimer = new Timer();
myTimer.schedule(new TimerTask() {          
@Override
public void run() {
    // If you want to modify a view in your Activity
    MyActivity.this.runOnUiThread(new Runnable()
        public void run(){
            tv.append("Hello World");
        });
    }
}, 1000, 1000); // initial delay 1 second, interval 1 second

Sử dụng Timercó một vài lợi thế:

• Độ trễ ban đầu và khoảng thời gian có thể được chỉ định dễ dàng trong các scheduleđối số hàm
• Có thể dừng bộ hẹn giờ bằng cách gọi đơn giản myTimer.cancel()
• Nếu bạn muốn chỉ có một luồng đang chạy, hãy nhớ gọi myTimer.cancel() trước khi lên lịch cho một luồng mới (nếu myTimer không null)

Handler handler=new Handler();
Runnable r = new Runnable(){
    public void run() {
        tv.append("Hello World");                       
        handler.postDelayed(r, 1000);
    }
}; 
handler.post(r);

Nếu tôi hiểu chính xác tài liệu của phương thức Handler.post ():

Làm cho r Runnable được thêm vào hàng đợi tin nhắn. Runnable sẽ được chạy trên luồng mà trình xử lý này được đính kèm.

Vì vậy, các ví dụ được cung cấp bởi @ alex2k8, mặc dù đang hoạt động chính xác, không giống nhau. Trong trường hợp, nơi Handler.post()được sử dụng, không có chủ đề mới được tạo ra . Bạn chỉ cần đăng Runnablelên chủ đề Handlerđể được thực hiện bởi EDT . Sau đó, EDT chỉ thực thi Runnable.run(), không có gì khác.

Ghi nhớ : Runnable != Thread.

Kotlin

private lateinit var runnable: Runnable
override fun onCreate(savedInstanceState: Bundle?) {
    val handler = Handler()
    runnable = Runnable {
        // do your work
        handler.postDelayed(runnable, 2000)
    }
    handler.postDelayed(runnable, 2000)
}

Java

Runnable runnable;
Handler handler;

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    handler = new Handler();
    runnable = new Runnable() {
        @Override
        public void run() {
            // do your work
            handler.postDelayed(this, 1000);
        }
    };
    handler.postDelayed(runnable, 1000);
}

Một ví dụ thú vị là bạn có thể liên tục thấy một bộ đếm / đồng hồ bấm giờ đang chạy trong luồng riêng biệt. Cũng hiển thị GPS-Location. Trong khi hoạt động chính Giao diện người dùng đã có.

Trích đoạn:

try {    
    cnt++; scnt++;
    now=System.currentTimeMillis();
    r=rand.nextInt(6); r++;    
    loc=lm.getLastKnownLocation(best);    

    if(loc!=null) { 
        lat=loc.getLatitude();
        lng=loc.getLongitude(); 
    }    

    Thread.sleep(100); 
    handler.sendMessage(handler.obtainMessage());
} catch (InterruptedException e) {   
    Toast.makeText(this, "Error="+e.toString(), Toast.LENGTH_LONG).show();
}

Để xem mã xem tại đây:

Ví dụ về luồng hiển thị Vị trí GPS và Thời gian hiện tại có thể chạy cùng với Giao diện người dùng của hoạt động chính

bây giờ trong Kotlin bạn có thể chạy các chủ đề theo cách này:

class SimpleRunnable: Runnable {
    public override fun run() {
        println("${Thread.currentThread()} has run.")
    }
}
fun main(args: Array<String>) {
    val thread = SimpleThread()
    thread.start() // Will output: Thread[Thread-0,5,main] has run.
    val runnable = SimpleRunnable()
    val thread1 = Thread(runnable)
    thread1.start() // Will output: Thread[Thread-1,5,main] has run
}

Kotlin với quân đoàn

Trong Kotlin, sử dụng coroutines bạn có thể làm như sau:

CoroutineScope(Dispatchers.Main).launch { // Main, because UI is changed
    ticker(delayMillis = 1000, initialDelayMillis = 1000).consumeEach {
        tv.append("Hello World")
    }
}

Hãy thử nó ở đây !