Trang chủ » Bài 29: AsyncTask – thread & handler trong Android – Lập trình Android cơ bản
Bài 29: AsyncTask – thread & handler trong Android – Lập trình Android cơ bản
Góc học tậpKhóa học lập trình Android & iOS miễn phí

Bài 29: AsyncTask – thread & handler trong Android – Lập trình Android cơ bản

Admin 7 Th12, 2021
Chia sẻ:
35 0

1. Tổng quan

Khi một ứng dụng Android được khởi chạy, thì hệ thống Android sẽ start một New Linux Process cho ứng dụng đó cùng với một Thread duy nhất để thực thi. Đó là main UI thread. Android xử lý tất cả các sự kiện/tác vụ trên một thread duy nhất gọi là main UI thread. Main UI thread không xử lý các hoạt động đồng thời vì nó chỉ xử lý một sự kiện/task tại một thời điểm.
Do vậy, nếu bạn thực hiện một tác vụ gì đó mà tốn nhiều thời gian trên main UI thread sẽ gây ra hiện tượng treo ứng dụng hay còn gọi là ANR(Application Not Responding).
Để xử lý các tác vụ cần nhiều thời gian như: Tải file từ internet, nén hoặc giải nén… thì chúng ta phải tách tác vụ đó khỏi main UI thread( gọi là xử lý đa nhiệm). Android cung cấp một số công cụ để bạn có thể làm được điều đó như:
  1. Sử dụng Service – IntentService
  2. Sử dụng Thread – một khái niệm của Java
  3. Loader trong Android
  4. Hoặc sử dụng AsyncTask trong Android…
Nhưng trước hết, chúng ta cùng nhau tìm hiểu xử lý đa nhiệm trong Android là gì? Và khi nào cần phải xử lý đa nhiệm thay vì thực hiện ngay trên UI thread?

1.1 Xử lý đa nhiệm trong Android

Nếu các sự kiện hoặc một task nào đó không được xử lý đồng thời. Thì toàn bộ mã của ứng dụng Android sẽ chạy trên luồng chính và code sẽ được thực hiện tuần tự từng dòng một.
Giả sử nếu bạn thực hiện một công việc/ tác vụ cần thời gian xử lý như tải nhạc từ Internet, ứng dụng sẽ hiển thị trạng thái treo cho đến khi tải xong.
Để mang lại trải nghiệm người dùng tốt, tất cả tác vụ có khả năng chạy chậm đều phải chạy không đồng bộ.
Mình có thể tạm liệt kê một số tác vụ cần thời gian xử lý như:
  1. Truy cập tài nguyên (như MP3, JSON, Hình ảnh) từ Internet.
  2. Thao tác với cơ sở dữ liệu.
  3. Tương tác với webService như RESTful, SOAP…
  4. Các Logic phức tạp mất khá nhiều thời gian như: Nén/giải nén file, sao chép/di chuyển file trong bộ nhớ…
Và còn rất nhiều các trường hợp khác cần phải xử lý bất đồng bộ, đa nhiệm khác nữa. Tùy vào ứng dụng của bạn như thế nào mà ứng biến cho phù hợp.
Bây giờ chúng ta sẽ đi vào từng thành phần của bài viết nhé.

2. Thread

Vậy Thread là gì? Thread được định nghĩa là một luồng dùng để thực thi một chương trình. Java Virtual Machine cho phép một chương trình có thể có nhiều Thread thực thi đồng thời. Mỗi Thread đều có độ ưu tiên của nó. Rồi mỗi Thread có thể được đánh dấu là Daemon . Daemon Thread là một loại Thread có độ ưu tiên thấp, cung cấp dịch vụ cho người dùng, là Thread duy trì hoạt động cho đến khi tất cả các Threads khác hoàn thành công việc hay chết đi thì nó cũng mới chết theo. Ví dụ cụ thể là trình dọn rác trong Java là một Daemon Thread. Để tạo mới Thread ta có hai cách. Cách thứ nhất là kế thừa (extends) từ class Thread:
private class MyThread extends Thread{
                @Override
                public void run() {
                    //TODO
                }
         }
        ...
        new MyThread().start();
Cách thứ 2 là thực thi (implements) interface Runnable:
private class MyRunnable implements Runnable{
                @Override
                public void run() {
                    //TODO
                }
        }
        ...
        new Thread(new MyRunnable()).start();
Trong Java chỉ có đơn kế thừa nên cách thứ hai sẽ linh động hơn. Tùy vào bài toán mà bạn có thể chọn cách sử dụng cho thích hợp nhé. Multiple Thread dịch ra tiếng việt là đa luồng, hay nhiều Thread. Tức là trong một chương trình, có thể có đồng thời nhiều Thread được thực thi. Khi một chương trình nhiều công việc mà chỉ có một Thread thực thi thì sẽ không hiệu quả, như vậy nhiều Thread làm việc thì sẽ hiệu quả hơn, và chúng chạy đồng thời. Các Thread này chia sẽ cùng một không gian tài nguyên, số lượng Thread càng nhiều thì độ phức tạp sẽ càng tăng, nên phải sử dụng cho hợp lý không thì chương trình sẽ xung đột, quá trình thực thi sẽ sai, thậm chí có thể chết chương trình.

2.1 Main Thread và UI Thread, Worker Thread.

Trong Android, khi chương trình được khởi chạy, hệ thống sẽ start một Thread ban đầu cùng với một Process. Thì Thread đó chính là Main Thread. Vậy vì sao Main Thread lại thường được gọi là UI Thread thì có 2 lý do chính đáng sau đây.
  1. Thread này có nhiệm vụ gửi các sự kiện đến widget, tức là đến các view ở giao diện điện thoại, thậm chí cả các sự kiện vẽ.
  2. Ngoài ra Thread này cũng phải tương tác với bộ công cụ Android UI (Android UI toolkit) gồm hai gói thư viện là android.widget và android.view.
Có khi nào Main Thread lại không được gọi là UI Thread không? Đó là khi một chương trình có nhiều hơn một Thread phụ trách việc xử lý giao diện.
Còn một trường hợp nữa là Worker Thread, chính là Thread mà bạn tạo thêm cho chương trình để nó thực thi một công việc nào đó không liên quan đến giao diện, Thread này cũng được gọi là Background Thread.

2.2 Hiện tượng ANR trong Android.

Có khi nào bạn dùng điện thoại Android mà thấy xuất hiện Dialog tương tự như hình sau đây không?
  1. Khi có nhiều thứ thực thi trên UI Thread, và có một công việc gì đó cần phải thực hiện lâu như kết nối mạng hay truy vấn cơ sở dữ liệu, khi đó UI sẽ bị block. Người dùng cảm thấy như ứng dụng đang bị treo, nhưng thực ra nó đang thực thi công việc của mình trên UI Thread. Nếu UI bị block hơn vài giây (trung bình là 5 giây) thì hệ thống Android sẽ xuất hiện hộp thoại như trên, cho phép người dùng có thể đóng chương trình hoặc chờ đợi. Nếu như ứng dụng thường xuyên có những hiện tượng như vậy thì sẽ bất tiện cho người dùng. Chính vì vậy, để không xảy ra hiện tượng trên thì Android là đề ra 2 rules sau đây yêu cầu lập trình viên phải tuân theo:
  1. Không được block UI Thread.
  2. Không được kết nối tới bộ công cụ Android UI (Android UI toolkit) từ một Thread không phải là UI Thread.
  1. Giờ mình sẽ đưa ra một ví dụ các bạn xem code thế này có vấn đề gì không nhé?
public void onClick(View view) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Bitmap b = loadImageFromNetwork("http://example.com/img.png");
                        mImageView.setImageBitmap(b);
                    }
                }).start();
            }
Ta thấy việc kết nối internet để load hình ảnh được thực hiện một Thread khác (Worker Thread hay Background Thread) nên sẽ không block UI, thỏa mãn rule thứ nhất. Nhưng ở trong Thread này nó đã trực tiếp tác động đến UI bằng câu lệnh mImageView.setImageBitmap(b) và không thỏa mãn rule thứ 2 nên code sẽ không chạy được. Từ Worker Thread ta không thể update UI. Từ đó Android đã cung cấp cho Worker Thread một số phương thức sau để làm điều đó.
1. *Activity.runOnUiThread(Runnable)*
2. *View.post(Runnable)*
3. *View.postDelayed(Runnable, long)*
NaNundefinedSau đây ta xem ví dụ tiếp theo.
public void onClick(View view) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        final Bitmap b = loadImageFromNetwork("http://example.com/img.png");
                        mImageView.post(new Runnable() {
                            @Override
                            public void run() {
                                mImageView.setImageBitmap(b);
                            }
                        });
                    }
                }).start();
            }
Bây giờ thì code hoàn toàn có thể chạy được đúng không nào. Nhưng ba phương thức trên chỉ phù hợp với một số bài toán. Nếu phương thức trên không có tham số là một View hay Activity truyền vào thì nó không thể update UI được, hoặc một số bài toán với dữ liệu lớn thì cũng không thể cập nhật giao diện bằng cách này được. Vậy giải pháp là gì? Chúng ta có hai cách đó là dùng Handler, hoặc là AsyncTask.

3. Handler

Đầu tiên, Handlers không phải là một khái niệm mới, chúng đã có từ rất lâu. Cụ thể là bao lâu? Theo mình được biết thì là từ thời API level 1 rồi. Mặc dù vậy, mình vẫn luôn cảm thấy các bạn vẫn chưa thực sự khai thác triệt để, kể cả mình cũng vậy .
Có thể hiểu Handler là một class khi khai báo trong ứng dụng nó sẽ có chức năng giống với “listener” của các control khác trên màn hình. Điểm khác biệt là các control khác thì lắng nghe “onKey”, “onClick” còn Handlers thì là handleMessage.

3.1 Vậy, một Handler có thể làm gì?

  1. Sắp xếp và xử lý các messages
  2. Sắp xếp và thực hiện các Runnables
  3. Có thể chạy trên một Thread khác nơi mà Handler được tạo ra
  4. Có thể tái sử dụng nhiều lần khi cần
Handler trong android có một hạn chế là “sự không rõ ràng”. Nó không phải là một Runnable, mà cũng không phải là Thread
Bạn có thể xem Handler như là một cơ chế cao cấp để xử lý hàng đợi. Việc hàng đợi này chứa Messages hay Runnables, hay việc chúng nên được xử lý trên main thread hay các background thread không quan trọng.
Handler vẫn sẽ được tạo ra để xử lý đống Messages này, từng cái một. Và đây chính là điều cần phải nhớ.
Một ví dụ điển hình của việc sử dụng Handler: khi bạn có một Runnable và bạn làm gì đó với background android thread. Và đến một lúc – bạn muốn cập nhật dữ liệu lên UI.
Trong trường hợp này, bạn hãy gán giá trị cần cập nhật cho Handler bằng cú pháp new Handler(Looper.getMainLooper). Sau đó gọi handler.post()thực hiện công việc của UI bên trong post(). Thật tuyệt phải không nào?
private void postTaskInsideBackgroundTask() {
        Thread backgroundThread = new Thread(new Runnable() {
            @Override
            public void run() {
                // pretend to do something "background-y"
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                mainThreadHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        tv04.setText("Hi from a Handler inside of a background Thread!");
                    }
                });
            }
        });
        backgroundThread.start();
    }
Chúng ta đều biết rằng, một AsyncTask chỉ có thể được thực hiện một lần. Điều này không xảy ra với Handlers.
Thậm chí có một lớp đặc biệt có thể xử lý một vài các Handlers cùng lúc đó là HandlerThread.
HandlerThread có thể thay phiên xử lý cho cả Looper, một cách tự động. Vì vậy bạn không cần phải lo lắng về điều này.

4. AsyncTask

AsyncTask là một abstract Android class, giúp ứng dụng Android xử lý main UI thread hiệu quả hơn. AsyncTask trong Android cho phép chúng ta thực hiện những tác vụ dài mà không ảnh hưởng đến main thread.

4.1 Khi nào thì sử dụng AsyncTask?

Để dễ hình dung, mình giả sử bạn tạo một ứng dụng Android để tải xuống tệp MP3 từ Internet.
Sơ đồ trạng thái dưới đây cho thấy một loạt các hoạt động sẽ diễn ra khi bạn chạy ứng dụng
Trong khi chờ nhận file MP3 từ máy chủ, ứng dụng sẽ bị treo vì main thread vẫn đang chờ tác vụ tải xuống hoàn tất.
Để khắc phục điều này, chúng ta có thể tạo thread mới và thực hiện các tác vụ trên thread mới đó. Do đó giao diện người dùng sẽ không bị ảnh hưởng và treo nữa
Nhưng việc xử lý với thread riêng biệt có thể tạo ra một số vấn đề như việc cập nhật giao diện người dùng. Bạn sẽ cần phải cập nhập trạng thái download được bao nhiêu % file đó, và khi kết thúc tải thì cũng phải cập nhập cho người dùng biết. Nếu bạn sử dụng Thread đơn giản của java thì việc cập nhập này sẽ khá phức tạp.
Android đã xem xét tất cả các vấn đề này và tạo một lớp chuyên dụng có tên là AsyncTask.

4.2 Cách triển khai AsyncTask trong Android?

Tạo một class mới bên trong Activity và kế thừa từ AsyncTask như dưới đây
private class DownloadMp3Task extends AsyncTask<URL, Integer, Long> {
 protected Long doInBackground(URL... urls) {
      //Yet to code
     }
 protected void onProgressUpdate(Integer... progress) {
     //Yet to code
     }
 protected void onPostExecute(Long result) {
     //Yet to code
     }
}
Để thực thi tác vụ, đơn giản bằng cách gọi phương thức execute
new DownloadMp3Task().execute(mp3URL);
Bản chất Asynctask gồm có 4 bước:
Bước 1: onPreExecute()
Được thực hiện trước khi bắt đầu thực hiện tác vụ. Hàm được gọi trước phương thức doInBackground() và được gọi trên UI thread.
Thông thường, hàm này được dùng để hiển thị thanh progressbar thông báo cho người dùng biết tác vụ bắt đầu thực hiện
Bước 2: doInBackground()
Tất cả code mà cần thời gian thực hiện sẽ được đặt trong hàm này.  Vì hàm này được thực hiện ở một thread hoàn toàn riêng biệt với UI thread nên bạn không được phép cập nhật giao diện ở đây.
Để có thể cập nhập giao diện khi tác vụ đang thực hiện. Ví dụ như cập nhập trạng thái % file đã download được, chúng ta sẽ phải sử dụng đến hàm bên dưới onProgressUpdate()
Bước 3: onProgressUpdate()
Hàm này được gọi khi trong hàm doInBackground()gọi đến hàm publishProgress()
Bước 4: onPostExecute()
Hàm này được gọi khi doInBackground hàm thành công việc. Kết quả của doInBackground() sẽ được trả cho hàm này để hiển thị lên giao diện người dùng.
Trong quá trình Asynctask thực hiện tác vụ, bạn hoàn toàn có thể tạm dừng bất kể lúc nào mà không cần phải đợi AsyncTask làm xong. Đơn giản là bạn gọi hàm cancel(boolean)

4.3 Một số lưu ý về các sử dụng AsynctTask

  1. Lớp AsyncTask phải được thực hiện trên UI Thread
  2. Hàm execute(Params…) phải được gọi trên UI Thread
  3. Không nên gọi onPreExecute (), onPostExecute(), doInBackground (Params…), onProgressUpdate (Progress…) theo cách thủ công.
  4. Task chỉ được thực thi một lần tại một thời điểm (Exception sẽ được throw nếu thực hiện lần thứ hai).
Như vậy là mình đã hướng dẫn các bạn kiến thức cơ bản về cách sử dụng AsyncTask trong Android. Khi bạn đã nắm được bản chất thì việc sử dụng và ứng biến trong từng trường hợp cụ thể sẽ rất dễ dàng.

5. Tổng kết

Trên đây là bài viết về AsyncTask – thread & handler trong Android và mối quan hệ giữa chúng được mình tổng hợp từ nhiều trang web khác nhau, hi vọng bài viết có thể giúp đỡ được các bạn ít nhiều trong quá trình làm việc của mình
Tài liệu tham khảo :
Từ khóa:
Chia sẻ:
35 0

Bình luận

Leave a Reply

avatar
  Subscribe  
Notify of