这是我的例子

创建一个Java Utils

    import android.app.ProgressDialog;
    import android.content.Context;
    import android.content.Intent;

    public class Utils {

        public static void showDummyWaitingDialog(final Context context, final Intent startingIntent) {
            // ...
            final ProgressDialog progressDialog = ProgressDialog.show(context, "Please wait...", "Loading data ...", true);

            new Thread() {
                public void run() {
                    try{
                        // Do some work here
                        sleep(5000);
                    } catch (Exception e) {
                    }
                    // start next intent
                    new Thread() {
                        public void run() {
                        // Dismiss the Dialog 
                        progressDialog.dismiss();
                        // start selected activity
                        if ( startingIntent != null) context.startActivity(startingIntent);
                        }
                    }.start();
                }
            }.start();  

        }

    }    

这个问题的一个解决方案是使用Handler.postDelayed()方法。一些谷歌培训材料提出了同样的解决方案。

@Override
public void onClick(View v) {
    my_button.setBackgroundResource(R.drawable.icon);

    Handler handler = new Handler(); 
    handler.postDelayed(new Runnable() {
         @Override 
         public void run() { 
              my_button.setBackgroundResource(R.drawable.defaultcard); 
         } 
    }, 2000); 
}

然而，有些人指出，上面的解决方案会导致内存泄漏，因为它使用了一个非静态的内部匿名类，该类隐式地保存了对其外部类(activity)的引用。当活动上下文被垃圾收集时，这是一个问题。

一个更复杂的解决方案，避免内存泄漏子类Handler和Runnable与静态内部类在活动中，因为静态内部类不持有对它们的外部类的隐式引用:

private static class MyHandler extends Handler {}
private final MyHandler mHandler = new MyHandler();

public static class MyRunnable implements Runnable {
    private final WeakReference<Activity> mActivity;

    public MyRunnable(Activity activity) {
        mActivity = new WeakReference<>(activity);
    }

    @Override
    public void run() {
        Activity activity = mActivity.get();
        if (activity != null) {
            Button btn = (Button) activity.findViewById(R.id.button);
            btn.setBackgroundResource(R.drawable.defaultcard);
        }
    }
}

private MyRunnable mRunnable = new MyRunnable(this);

public void onClick(View view) {
    my_button.setBackgroundResource(R.drawable.icon);

    // Execute the Runnable in 2 seconds
    mHandler.postDelayed(mRunnable, 2000);
}

注意，Runnable使用活动的WeakReference，这在需要访问UI的静态类中是必要的。

你可以试试这件，它很短

SystemClock.sleep(7000);

警告:永远不要在UI线程上这样做。

用这个睡觉。后台线程。

你的问题的完整解决方案是: 这是可用的API 1

findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(final View button) {
                button.setBackgroundResource(R.drawable.avatar_dead);
                final long changeTime = 1000L;
                button.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        button.setBackgroundResource(R.drawable.avatar_small);
                    }
                }, changeTime);
            }
        });

不需要创建tmp处理程序。此外，这个解决方案比@tronman更好，因为我们不通过Handler保留视图。 我们也没有在坏线程创建Handler的问题;)

文档

公共静态空白睡眠(长毫秒) 在API级别1中添加 在返回之前等待给定的毫秒数(uptimeMillis)。类似于sleep(long)，但不抛出InterruptedException;Interrupt()事件被延迟到 下一个可中断操作。 至少在经过指定的毫秒数之后才返回。 参数 Ms在返回前进入睡眠状态，正常运行时间以毫秒计。

视图类postDelayed的代码:

/**
 * <p>Causes the Runnable to be added to the message queue, to be run
 * after the specified amount of time elapses.
 * The runnable will be run on the user interface thread.</p>
 *
 * @param action The Runnable that will be executed.
 * @param delayMillis The delay (in milliseconds) until the Runnable
 *        will be executed.
 *
 * @return true if the Runnable was successfully placed in to the
 *         message queue.  Returns false on failure, usually because the
 *         looper processing the message queue is exiting.  Note that a
 *         result of true does not mean the Runnable will be processed --
 *         if the looper is quit before the delivery time of the message
 *         occurs then the message will be dropped.
 *
 * @see #post
 * @see #removeCallbacks
 */
public boolean postDelayed(Runnable action, long delayMillis) {
    final AttachInfo attachInfo = mAttachInfo;
    if (attachInfo != null) {
        return attachInfo.mHandler.postDelayed(action, delayMillis);
    }
    // Assume that post will succeed later
    ViewRootImpl.getRunQueue().postDelayed(action, delayMillis);
    return true;
}

这就是我在一天结束时所做的——现在工作得很好:

@Override
    public void onClick(View v) {
        my_button.setBackgroundResource(R.drawable.icon);
        // SLEEP 2 SECONDS HERE ...
        final Handler handler = new Handler(); 
        Timer t = new Timer(); 
        t.schedule(new TimerTask() { 
                public void run() { 
                        handler.post(new Runnable() { 
                                public void run() { 
                                 my_button.setBackgroundResource(R.drawable.defaultcard); 
                                } 
                        }); 
                } 
        }, 2000); 
    }

除了Yankowsky先生的答案之外，您还可以使用postDelayed()。这在任何视图(例如，你的卡)上都是可用的，并且需要一个Runnable和一个延迟期。它在延迟之后执行Runnable。

如果您使用Kotlin和协程，您可以简单地做到

GlobalScope.launch {
   delay(3000) // In ms
   //Code after sleep
}

如果你需要更新UI

GlobalScope.launch {
  delay(3000)
  GlobalScope.launch(Dispatchers.Main) {
    //Action on UI thread
  }
}