Agorandroid: Executando tarefas sequencialmente em outra Thread no Android

Este post exemplifica uma necessidade que às vezes ocorre em um projeto: executar uma série de tarefas sequencialmente em uma thread.
Para fazer isso temos um recurso em Java que atende perfeitamente ao requisito acima: a estrutura Executor. Um executor é basicamente um gerenciador de threads e tarefas.
O exemplo consiste em executar uma série de tarefas numa única thread que é controlada por um executor. A tarefa vai ser representada por uma classe que vai implementar um Runnable (MyTask). Para não ficar invisível vamos atualizar a tela com o Dialog.
Vamos também usar uma outra thread para definir o Executor e submeter as tarefas para execução e aguardar até o fim de todas as tarefas para encerrar o Dialog ( MyControlThread).

Os códigos:
TesteExecutorsActivity.java

package br.com.agorandroid.testeexecutors;

import android.app.Activity;
import android.os.Bundle;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import android.app.ProgressDialog;
import android.os.Handler;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class TesteExecutorsActivity extends Activity {
  Button button;
  MyControlThread mThread;
  ProgressDialog mDialog;
  Handler mHandler;
  int LIMITE = 10;
     /** Called when the activity is first created. */
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
         button = (Button) findViewById(R.id.iniciarthread);
         
         button.setOnClickListener(new  OnClickListener() {
          public void onClick(View v) {
           ativaThread();
          }
         });
     }

private void ativaThread() {
   mDialog = ProgressDialog.show(this, "Aguarde", "Processando...", false, false);
      mHandler = new Handler();
      mThread = new MyControlThread(LIMITE);
      mThread.start();
     }

private class MyControlThread extends Thread {
      private int numTasks;
      
      public MyControlThread(int tasks) {
       this.numTasks = tasks;
      }
      
      @Override
       public void run() {
         ExecutorService executor =  Executors.newSingleThreadExecutor();
       for (int i = 1; i <= numTasks; i++) {
        Runnable worker = new MyTask("task" +i, 5);
        executor.submit(worker);
       }
       executor.shutdown();
       while (!executor.isTerminated()) {
        try {
      Thread.sleep(1000);
     } catch (InterruptedException e) {
     }
       }
       mHandler.post(new Runnable() {
        @Override
        public void run() {
         mDialog.dismiss();
        }
       }); 
      }
     }
     
     private class MyTask implements Runnable {
      private int numLoops;
      private String nome;
      
      public MyTask(String nome, int loops) {
       this.nome = nome;
       numLoops = loops;
      }
      
       public void run() {
       mHandler.post(new Runnable() {
        @Override
        public void run() {
         mDialog.setMessage("Processando " + nome);
        }
       });       
    
       fazerAlgoDemorado();
       
       mHandler.post(new Runnable() {
        @Override
        public void run() {
         Toast.makeText(TesteExecutorsActivity.this, "Fim da " + nome, Toast.LENGTH_SHORT).show();
        }
       });
      }
         
       private void fazerAlgoDemorado() {
       int i = 0;
       do {
         try {
          Thread.sleep(1000); 
          i++;
         } catch (InterruptedException e) { 
         }
        } while (i<numLoops); 
        
       } 
     }
     
 }

main.xml

Manifest file

PS: Algumas considerações sobre o código: No trecho abaixo, devemos observar o seguinte:
a. O executor é definido com uma thread para podermos executar as tarefas sequencialmente uma a uma.
b. O loop for é para simular a submissão de "n" tarefas, normalmente teríamos diversas tarefas diferentes sendo submetidas da seguinte forma:
PS1: Nas tarefas, o Handler é utilizado para executar algum código na UI Thread, normalmente para alterar a tela.

Executando no emulador: