Question

我想在一些睡眠时间后开始异步任务。为此我使用线程，我在该线程中启动我的异步任务finally块。但它无法在线程异常中创建一个处理程序。

我使用以下逻辑。

 thread= new Thread() 
            {
                public void run() 
                {
                   try 
                   {
                      int waited = 0;
                      while (waited < 300) 
                      {
                         sleep(100);
                         waited += 100;                                          
                      }
                   } 
                   catch (InterruptedException e) 
                   {
                      // do nothing
                   }
                   finally 
                   {     

                     Load ld=new Load();
                  ld.execute();
                   }
                }
            };
            thread.start();

Answer 1

嗯，首先，如果最终目标是在延迟一段时间后运行AsyncTask，我会使用Handler.postDelayed而不是创建单独的Thread并在那里睡觉：

new Handler().postDelayed(new Runnable() {

    @Override
    public void run() {
        new Load().execute();
    }
}, 300); //300ms timeout

但是，如果你真的想取笑Android，你可以创建HandlerThread - 特殊的线程，里面有looper，所以你的AsyncTask不再抱怨了：

thread= new HandlerThread("my_thread") 
        {
            public void run() 
            {
               try 
               {
                  int waited = 0;
                  while (waited < 300) 
                  {
                     sleep(100);
                     waited += 100;                                          
                  }
               } 
               catch (InterruptedException e) 
               {
                  // do nothing
               }
               finally 
               {     

                 Load ld=new Load();
                 ld.execute();
               }
            }
        };
        thread.start();

请注意，您有责任在此主题上致电quit()。此外，我不确定如果在AsyncTask完成之前退出此线程会发生什么。我不记得AsyncTask在哪里发布结果 - 到主线程，或者从它调用的线程...... 在任何情况下，第二个选项只是一个混乱，所以不要这样做:)使用第一个

Answer 2

new Handler().postDelayed(new Runnable() {

        @Override
        public void run() {
            // Do whatever you want. 
        }
    }, SPLASH_TIME_OUT);

}

您可以像上面一样使用。 SPLASH_TIME_OUT是你想要延迟的毫秒值。

Answer 3

您必须在UI线程中运行AsyncTask，因此您可以使用以下内容：

class YourThread extends Thread{
private Activity _activity;
public YourThread(Activity _activity){
this activity =  _activity;}
public void run() 
                {
                   try 
                   {
                      int waited = 0;
                      while (waited < 300) 
                      {
                         sleep(100);
                         waited += 100;                                          
                      }
                   } 
                   catch (InterruptedException e) 
                   {
                      // do nothing
                   }
                   finally 
                   {     
activity.runOnUiThread(new Runnable() {

            @Override
            public void run() {
                Load ld=new Load();
                  ld.execute();
            }
        });
                   }
                }
}

并在你的活动中调用这样的线程：

YourThread thread = new YourThread(this);
thread.start();

另请注意：使用软参考活动或不要忘记在活动被销毁时杀死。

Answer 4

就像下面的代码一样：全局定义一个线程。

 public static Thread thread;

    thread= new Thread() {
    public void run() {

    sleep(time);

    Message msg = setTextHandler.obtainMessage(2);                                                 
    setTextHandler.sendMessage(msg);

     }
  };
  thread.start();

并且您的处理程序看起来像

 private final Handler setTextHandler = new Handler() {
 @Override
 public void handleMessage(Message msg) {
      if (thread!= null) {
          thread.interrupt();
          thread= null;
      }
      switch (msg.what) {
        case 2: //do your work here
                Load ld=new Load();
                ld.execute();
                break;
      }
    }
 };

如何在一个线程中启动Asychoronous任务最终在android中阻止

4 个答案: