Quero poder chamar o método a seguir após um atraso especificado. No objetivo c, havia algo como:

[self performSelector:@selector(DoSomething) withObject:nil afterDelay:5];

Existe um equivalente desse método no android com java? Por exemplo, eu preciso poder chamar um método após 5 segundos.

public void DoSomething()
{
     //do something here
}

Kotlin

Handler().postDelayed({
  //Do something after 100ms
}, 100)

Java

final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Eu não poderia usar nenhuma das outras respostas no meu caso. Eu usei o java Timer nativo.

new Timer().schedule(new TimerTask() {          
    @Override
    public void run() {
        // this code will be executed after 2 seconds       
    }
}, 2000);

Nota: Essa resposta foi dada quando a pergunta não especificou o Android como contexto. Para obter uma resposta específica ao segmento da interface do usuário do Android, consulte aqui.

Parece que a API do Mac OS permite que o encadeamento atual continue e agende a execução da tarefa de forma assíncrona. No Java, a função equivalente é fornecida pelo java.util.concurrentpacote. Não sei ao certo quais limitações o Android pode impor.

private static final ScheduledExecutorService worker = 
  Executors.newSingleThreadScheduledExecutor();

void someMethod() {
  ⋮
  Runnable task = new Runnable() {
    public void run() {
      /* Do something… */
    }
  };
  worker.schedule(task, 5, TimeUnit.SECONDS);
  ⋮
}

Para executar algo no thread da interface do usuário após 5 segundos:

new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something here
    }
}, 5000);

você pode usar o Handler dentro do UIThread:

runOnUiThread(new Runnable() {

    @Override
    public void run() {
         final Handler handler = new Handler();
         handler.postDelayed(new Runnable() {
           @Override
           public void run() {
               //add your code here
           }
         }, 1000);

    }
});

Obrigado por todas as ótimas respostas, encontrei uma solução que melhor se adapta às minhas necessidades.

Handler myHandler = new DoSomething();
Message m = new Message();
m.obj = c;//passing a parameter here
myHandler.sendMessageDelayed(m, 1000);

class DoSomething extends Handler {
    @Override
    public void handleMessage(Message msg) {
      MyObject o = (MyObject) msg.obj;
      //do something here
    }
}

Kotlin& JavaMuitas maneiras

1. Usando Handler

Handler().postDelayed({
    TODO("Do something")
    }, 2000)

2. Usando o TimerTask

Timer().schedule(object : TimerTask() {
    override fun run() {
        TODO("Do something")
    }
}, 2000)

Ou ainda mais curto

Timer().schedule(timerTask {
    TODO("Do something")
}, 2000)

Ou o menor seria

Timer().schedule(2000) {
    TODO("Do something")
}

3. Usando Executors

Executors.newSingleThreadScheduledExecutor().schedule({
    TODO("Do something")
}, 2, TimeUnit.SECONDS)

Em Java

1. Usando Handler

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something
    }
}, 2000);

2. Usando Timer

new Timer().schedule(new TimerTask() {          
    @Override
    public void run() {
        // Do something
    }
}, 2000);

3. Usando ScheduledExecutorService

private static final ScheduledExecutorService worker = Executors.newSingleThreadScheduledExecutor();

Runnable runnable = new Runnable() {
  public void run() {
      // Do something
  }
  };
worker.schedule(runnable, 2, TimeUnit.SECONDS);

Veja esta demonstração:

import java.util.Timer;
import java.util.TimerTask;

class Test {
     public static void main( String [] args ) {
          int delay = 5000;// in ms 

          Timer timer = new Timer();

          timer.schedule( new TimerTask(){
             public void run() { 
                 System.out.println("Wait, what..:");
              }
           }, delay);

           System.out.println("Would it run?");
     }
}

Se você precisar usar o manipulador, mas estiver em outro thread, poderá usá-lo runonuithreadpara executar o manipulador no thread da interface do usuário. Isso o salvará das exceções lançadas pedindo para ligarLooper.Prepare()

runOnUiThread(new Runnable() {
    @Override
    public void run() {
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                //Do something after 1 second
            }
        }, 1000);
    }
});

Parece bastante confuso, mas esse é um dos caminhos.

Eu prefiro usar o View.postDelayed()método, código simples abaixo:

mView.postDelayed(new Runnable() {
    @Override
    public void run() {
        // Do something after 1000 ms
    }
}, 1000);

Aqui está a minha solução mais curta:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something after 100ms
    }
}, 100);

final Handler handler = new Handler(); 
Timer t = new Timer(); 
t.schedule(new TimerTask() { 
    public void run() { 
        handler.post(new Runnable() { 
            public void run() { 
                //DO SOME ACTIONS HERE , THIS ACTIONS WILL WILL EXECUTE AFTER 5 SECONDS...
            }
        }); 
    } 
}, 5000); 

Se você estiver usando o Android Studio 3.0 e superior, poderá usar expressões lambda. O método callMyMethod()é chamado após 2 segundos:

new Handler().postDelayed(() -> callMyMethod(), 2000);

Caso você precise cancelar a execução atrasada, use o seguinte:

Handler handler = new Handler();
handler.postDelayed(() -> callMyMethod(), 2000);

// When you need to cancel all your posted runnables just use:
handler.removeCallbacksAndMessages(null);

Sugiro o Timer , que permite agendar um método a ser chamado em um intervalo muito específico. Isso não bloqueará sua interface do usuário e manterá seu aplicativo sensível enquanto o método estiver sendo executado.

A outra opção é a wait (); método, isso bloqueará o encadeamento atual pelo período especificado. Isso fará com que sua interface do usuário pare de responder se você fizer isso no thread da interface do usuário.

Para um atraso de manipulação de linha simples, você pode fazer o seguinte:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        // Do someting
    }
}, 3000);

Eu espero que isso ajude

Você pode usar isso para a solução mais simples:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Write your code here
    }
}, 5000); //Timer is in ms here.

Senão, Abaixo pode ser outra solução útil limpa:

new Handler().postDelayed(() -> 
{/*Do something here*/}, 
5000); //time in ms

Você pode torná-lo muito mais limpo usando as expressões lambda recém-introduzidas:

new Handler().postDelayed(() -> {/*your code here*/}, time);

Portanto, existem algumas coisas a considerar aqui, pois existem muitas maneiras de esfolar esse gato. Embora todas as respostas já tenham sido dadas, foram selecionadas e escolhidas. Eu acho que é importante que isso seja revisado com diretrizes de codificação adequadas para evitar que alguém vá na direção errada apenas por causa da "resposta simples selecionada pela maioria".

Então, primeiro vamos discutir a resposta simples pós-adiada que é a resposta selecionada pelo vencedor em geral neste tópico.

Algumas coisas a considerar. Após o atraso da postagem, você poderá encontrar vazamentos de memória, objetos mortos, ciclos de vida que desapareceram e muito mais. Portanto, lidar com isso corretamente também é importante. Você pode fazer isso de duas maneiras.

Por uma questão de desenvolvimento moderno, fornecerei em KOTLIN

Aqui está um exemplo simples de como usar o encadeamento da interface do usuário em um retorno de chamada e confirmar que sua atividade ainda está ativa e bem quando você pressiona seu retorno de chamada.

  Handler(Looper.getMainLooper()).postDelayed({
            if(activity != null && activity?.isFinishing == false){
                txtNewInfo.visibility = View.GONE
            }
        }, NEW_INFO_SHOW_TIMEOUT_MS)

No entanto, isso ainda não é perfeito, pois não há motivo para acessar sua chamada de retorno se a atividade desaparecer. portanto, uma maneira melhor seria manter uma referência a ele e remover seus retornos de chamada assim.

    private fun showFacebookStylePlus1NewsFeedOnPushReceived(){
        A35Log.v(TAG, "showFacebookStylePlus1NewsFeedOnPushReceived")
        if(activity != null && activity?.isFinishing == false){
            txtNewInfo.visibility = View.VISIBLE
            mHandler.postDelayed({
                if(activity != null && activity?.isFinishing == false){
                    txtNewInfo.visibility = View.GONE
                }
            }, NEW_INFO_SHOW_TIMEOUT_MS)
        }
    }

e, é claro, lida com a limpeza na onPause, para que não atinja o retorno de chamada.

    override fun onPause() {
        super.onPause()
        mHandler.removeCallbacks(null)
    }

Agora que falamos do óbvio, vamos falar sobre uma opção mais limpa com as corotinas dos dias modernos e o kotlin :). Se você ainda não os está usando, está realmente perdendo.

   fun doActionAfterDelay() 
        launch(UI) {
            delay(MS_TO_DELAY)           
            actionToTake()
        }
    }

ou se você quiser sempre executar uma interface do usuário nesse método, basta:

  fun doActionAfterDelay() = launch(UI){ 
      delay(MS_TO_DELAY)           
      actionToTake()
  }

É claro que, assim como o PostDelayed, você deve garantir o cancelamento, para que você possa realizar as verificações de atividade após a chamada de atraso ou cancelá-la na onPause, como na outra rota.

var mDelayedJob: Job? = null
fun doActionAfterDelay() 
   mDelayedJob = launch(UI) {
            try {
               delay(MS_TO_DELAY)           
               actionToTake()
            }catch(ex: JobCancellationException){
                showFancyToast("Delayed Job canceled", true, FancyToast.ERROR, "Delayed Job canceled: ${ex.message}")
            }
        }
   }
}

// manipular limpeza

override fun onPause() {
   super.onPause()
   if(mDelayedJob != null && mDelayedJob!!.isActive) {
      A35Log.v(mClassTag, "canceling delayed job")
      mDelayedJob?.cancel() //this should throw CancelationException in coroutine, you can catch and handle appropriately
   }
}

Se você colocar a inicialização (UI) na assinatura do método, o trabalho poderá ser atribuído na linha de código de chamada.

para que a moral da história seja segura com suas ações atrasadas, remova seus retornos de chamada ou cancele seus trabalhos e, é claro, confirme que você tem o ciclo de vida certo para tocar nos itens em seu retorno de retorno atrasado. As Coroutines também oferecem ações canceláveis.

Também é importante notar que você geralmente deve lidar com as várias exceções que podem surgir com as corotinas. Por exemplo, um cancelamento, uma exceção, um tempo limite, o que você decidir usar. Aqui está um exemplo mais avançado, se você decidir realmente começar a utilizar corotinas.

   mLoadJob = launch(UI){
            try {
                //Applies timeout
                withTimeout(4000) {
                    //Moves to background thread
                    withContext(DefaultDispatcher) {
                        mDeviceModelList.addArrayList(SSDBHelper.getAllDevices())
                    }
                }

                //Continues after async with context above
                showFancyToast("Loading complete", true, FancyToast.SUCCESS)
            }catch(ex: JobCancellationException){
                showFancyToast("Save canceled", true, FancyToast.ERROR, "Save canceled: ${ex.message}")
            }catch (ex: TimeoutCancellationException) {
                showFancyToast("Timed out saving, please try again or press back", true, FancyToast.ERROR, "Timed out saving to database: ${ex.message}")
            }catch(ex: Exception){
                showFancyToast("Error saving to database, please try again or press back", true, FancyToast.ERROR, "Error saving to database: ${ex.message}")
            }
        }

Eu criei um método mais simples para chamar isso.

public static void CallWithDelay(long miliseconds, final Activity activity, final String methodName)
    {
        new Handler().postDelayed(new Runnable() {

            @Override
            public void run() {
                try {
                    Method method =  activity.getClass().getMethod(methodName);
                    method.invoke(activity);
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }, miliseconds);
    }

Para usá-lo, basta ligar para: .CallWithDelay(5000, this, "DoSomething");

Abaixo de um funciona quando você obtém,

java.lang.RuntimeException: Não é possível criar manipulador dentro do encadeamento que não chamou Looper.prepare ()

final Handler handler = new Handler(Looper.getMainLooper());
handler.postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Usando o Kotlin, podemos conseguir fazendo o seguinte

Handler().postDelayed({
    // do something after 1000ms 
}, 1000)

É muito fácil usar o CountDownTimer. Para mais detalhes https://developer.android.com/reference/android/os/CountDownTimer.html

import android.os.CountDownTimer;

// calls onTick every second, finishes after 3 seconds
new CountDownTimer(3000, 1000) { 

   public void onTick(long millisUntilFinished) {
      Log.d("log", millisUntilFinished / 1000);
   }

   public void onFinish() {
      // called after count down is finished
   } 
}.start();

Se você usa o RxAndroid, o tratamento de threads e erros fica muito mais fácil. O código a seguir é executado após um atraso

   Observable.timer(delay, TimeUnit.SECONDS)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(aLong -> {
           // Execute code here
        }, Throwable::printStackTrace);

todo mundo parece esquecer de limpar o manipulador antes de postar uma nova mensagem ou executável. Caso contrário, eles poderiam se acumular e causar um mau comportamento.

handler.removeMessages(int what);
// Remove any pending posts of messages with code 'what' that are in the message queue.

handler.removeCallbacks(Runnable r)
// Remove any pending posts of Runnable r that are in the message queue.

Aqui está outra maneira complicada: não lançará exceção quando os elementos da interface do usuário executáveis ​​mudarem.

public class SimpleDelayAnimation extends Animation implements Animation.AnimationListener {

    Runnable callBack;

    public SimpleDelayAnimation(Runnable runnable, int delayTimeMilli) {
        setDuration(delayTimeMilli);
        callBack = runnable;
        setAnimationListener(this);
    }

    @Override
    public void onAnimationStart(Animation animation) {

    }

    @Override
    public void onAnimationEnd(Animation animation) {
        callBack.run();
    }

    @Override
    public void onAnimationRepeat(Animation animation) {

    }
}

Você pode chamar a animação assim:

view.startAnimation(new SimpleDelayAnimation(delayRunnable, 500));

A animação pode ser anexada a qualquer visualização.

Aqui está a resposta em Kotlin, pessoas preguiçosas, preguiçosas:

Handler().postDelayed({
//doSomethingHere()
}, 1000)

Eu gosto de coisas mais limpas: aqui está minha implementação, código embutido para usar dentro do seu método

new Handler().postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Uma solução adequada no android:

private static long SLEEP_TIME = 2 // for 2 second
.
.
MyLauncher launcher = new MyLauncher();
            launcher.start();
.
.
private class MyLauncher extends Thread {
        @Override
        /**
         * Sleep for 2 seconds as you can also change SLEEP_TIME 2 to any. 
         */
        public void run() {
            try {
                // Sleeping
                Thread.sleep(SLEEP_TIME * 1000);
            } catch (Exception e) {
                Log.e(TAG, e.getMessage());
            }
            //do something you want to do
           //And your code will be executed after 2 second
        }
    }

Solução semelhante, mas muito mais limpa de usar

Escreva esta função fora da classe

fun delay(duration: Long, `do`: () -> Unit) {

    Handler().postDelayed(`do`, duration)

}

Uso:

delay(5000) {
    //Do your work here
}

No Android, podemos escrever abaixo do código kotlin para atrasar a execução de qualquer função

class MainActivity : AppCompatActivity() {

private lateinit var handler: Handler

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    handler= Handler()
    handler.postDelayed({
        doSomething()
    },2000)
}

private fun doSomething() {
    Toast.makeText(this,"Hi! I am Toast Message",Toast.LENGTH_SHORT).show()
}
}