android線程延遲

1. android延時載入的幾種做法

在項目開發中，經常需要通過延時載入來實現滿足我們的項目要求。那到底怎樣來實現延時，下面結合java與android的相關方法來實現延時問題。
一.利用線程的Sleep方法
二. 利用Timer和TimerTask延時器
三.利用android自帶的Handler消息處理
四.SchleExecutorService介面處理延時 迭代

2. android在主線程中使用handle.postdelay做延時操作對主線程資源消耗大嗎

android在主線程中使用handle.postdelay做延時操作對主線程資源消耗不大,因為handler中有一個消息池,是靜態的消息池, 建議去了解一下Android中的Handler, Looper, MessageQueue之間的關系就知道了.

3. 安卓線程handler.post傳送消息有延時，怎麼辦

延遲是跟網路有關系的，HANDLER.POST沒有大多關聯。我用的時候也出現同樣的問題 換網路就原滿解決了，請採納

4. 安卓線程handler.post傳送消息有延時，怎麼辦

延遲是跟網路有關系的，
HANDLER.POST沒有大多關聯。
我用的時候也出現同樣的問題
換網路就原滿解決了

5. android 開發中如何實現讓程序執行一條語句後延時一段時間後再執行下面的語句

你這方法完全是利用了單片機處理速度慢才會有偽延時效果，實際上那時機器正在運算，放在好點的機器上運算速度快了當然就沒延時效果了。正統的延時還是要用到樓上說的線程，安卓還有一個timer類也可以用於定時。

6. Android中的線程池

 線程池的好處

1、重用線程池中的線程，避免線程的創建與銷毀帶來的性能開銷

2、能有效控制線程池的最大並發數，避免大量線程因搶占資源而導致的阻塞

3、能對線程進行簡單的管理，提供定時或者指定間隔時間、循環執行等操作

線程池的概率來自於java的Executor介面，實現類是ThreadPoolExecutor, 它提供一系列的參數來配置線程池，以此構建不同的線程池。Android的線程池分4類，都是通過Executors所提供的工廠方法來得到。

ThreadPoolExecutor有四個構造函數，下面這個是最常用的

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnnable> workQueue, ThreadFactory threadFactory)

corePoolSize

線程池中的核心線程數，默認情況下核心線程會在線程池中一直存活，即使他們處於閑置狀態。如果設置ThreadPoolExecutor 中的allowCoreThreadTimeOut = true, 核心線程在等待新任務到來時有超時機制，時間超過keepAliveTime所指定的時間後，核心線程會終止。

maximumPoolSize

最大線程數

keepAliveTime

非核心線程閑置的超時時間，超過這個時間，非核心線程會被回收。核心線程則要看allowCoreThreadTimeOut屬性的值。

unit

時間單位

workQueue

線程池中的工作隊列

threadFactory

線程工廠，為線程池提供創建新線程的功能。

舉個例子，我們常用的okhttp內部也是使用了線程池，它的ThreadPoolExecutor主要是定義在Dispatcher類裡面。 使用的是CachedThreadPool。

executorService = ThreadPoolExecutor(0, Int.MAX_VALUE, 60, TimeUnit.SECONDS, SynchronousQueue(), ThreadFactory("okhttp Dispatcher", false))

1、FixedThreadPool

通過Executors的newFixedThreadPool（）創建，這是一個線程數量固定的線程池，裡面所有的線程都是核心線程。

public static ExecutorService newFixedThreadPool(int nThreads){

return new ThreadPoolExecutor(nThreads, nThreads, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())

}

2、CachedThreadPool

通過Executors的newCacheThreadPool（）創建，這是一個線程數量不定的線程池，裡面所有的線程都是非核心線程。最大線程數是無限大，當線程池中的線程都處於活動狀態時，新的task會創建新的線程來處理，否則就使用空閑的線程處理，所有的線程都是60s的超時時間，超時後會自動回收。

public static ExecutorService newFixedThreadPool(){

return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>())

}

3、ScheledThreadPool

通過Executors的newScheledThreadPool（）創建, 核心線程固定，非核心線程無限大，當非核心線程空閑時，會立即被回收。適合做定時任務或者固定周期的重復任務。

public static ExecutorService newScheledThreadPool(int corePoolSize){

return new ThreadPoolExecutor(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new DelayedWorkQueue())

}

4、SingleThreadExcecutor

通過Executors的newSingleThreadPool（）創建，內部只有一個核心線程。

public static ExecutorService newFixedThreadPool(){

return new ThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())

}

課外知識：LinkedBlockingQueue

LinkedBlockingQueue是由鏈表組成的阻塞隊列，內部head 指向隊列第一個元素，last指向最後一個元素。入隊和出隊都會加鎖阻塞，都是使用了不同的鎖。

DelayedWorkQueue

延時隊列，隊內元素必須是Delayed的實現類。對內元素會按照Delayed時間進行排序，對內元素只有在delayed時間過期了才能出隊。

入隊的時候不阻塞隊列，出隊的時候，如果隊列為空或者隊列里所有元素都等待時間都沒有到期，則該線程進入阻塞狀態。

7. android怎麼讓一個方法延時幾秒

開啟新線程
new Thread(new Runnable(){
public void run(){
Thread.sleep(XXXX);
handler.sendMessage(); //告訴主線程執行任務
}
}).start

8. 能主動讓android主線程等待1s嗎

對於Android apk的主線程，原則上是不能等的，雖然確實可以堵塞主線程1s。讓主線程等待1s，就意味著程序無響應1s， 無響應時間過長，系統是會彈對話框來殺掉程序的。

9. android 開發中如何實現讓程序執行一條語句後延時一段時間後再執行下面的語句

延時操作，可以用下列方案：

方案1：線程阻斷

try {

Thread.currentThread().sleep(2000);//阻斷2秒

} catch (InterruptedException e) {

e.printStackTrace();

}

方案2：使用Handler的postDelayed延遲操作。

mHandler .postDelayed(mRunnable, 3000); // 在Handler中執行子線程並延遲3s。

private Runnable mRunnable = new Runnable() {

@Override

public void run() {

mHandler.sendEmptyMessage(1);

}

};

Handler mHandler = new Handler() {

@Override

public void handleMessage(Message msg) {

super.handleMessage(msg);

//3s後執行代碼

}

}。

10. android中開線程延時問題

我想做到的效果是屏幕中畫一個圓，然後圓會慢慢變小，當半徑變成1時停止變小。然後每觸摸一次屏幕圓半徑會增大，直到半徑到100停止。我把這兩個寫在了兩個線程里，但是目前運行下來觸摸屏放大圓可以，但是圓自己慢慢變小卻不行。

MainActivity.java 重要 代碼

public class MainActivity extends Activity{

private Thread thread1;
private Thread thread2;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
final FrameLayout frame=new FrameLayout(this);
setContentView(frame);
frame.findViewById(R.id.framelayout1);
final MyView view=new MyView(this);

thread1=new Thread(new Runnable(){
@Override
public void run(){
view.setOnTouchListener(new OnTouchListener(){
@Override
public boolean onTouch(View v,MotionEvent event){
++view.r;
view.invalidate();
return true;
}
});
}
});

thread2=new Thread(new Runnable(){
@Override
public void run(){
--view.r;
view.invalidate();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});

thread1.start();
thread2.start();
frame.addView(view);
if (view.r==1)
{
thread2.interrupt();
}
if (view.r==100){
thread1.interrupt();
}
}

}

class MyView extends View{
int r=10,x,y;
public MyView(Context context){
super(context);
x=context.getResources().getDisplayMetrics().widthPixels/2;
y=context.getResources().getDisplayMetrics().heightPixels/2;
}
@Override
protected void onDraw(Canvas canvas){
super.onDraw(canvas);
canvas.drawColor(Color.WHITE);
Paint paint=new Paint();
paint.setAntiAlias(true);
paint.setStrokeWidth(3);
paint.setStyle(Style.STROKE);
paint.setColor(Color.BLUE);
canvas.drawCircle(x,y,r,paint);
}
}