android下載線程池

『壹』 線程池什麼時候用android中的線程池什麼時候用非同步任務怎麼 使用

線程同步時用到線程，主要控制並發性操作，避免同時提交造成系統處理失誤。連接資料庫時用到線程池，可以避免亂碼問題。

『貳』 android多線程下載的問題。

1. string太長？你的url有多長？string的最大長度應該是2^31 - 1。

2. 你要先判斷file是否存在，不存在就創建

java">Filefile=newFile(fileName);
if(!file.exists()){
//判斷創建文件是否成功
if(file.createNewFile()){
//寫入
}else{
//文件創建失敗
}
}

『叄』 android 線程池有什麼用

//在Android中實現線程池，首先需要實現一個線程工廠（ThreadFactory）的子類，具體實現方式如下所示（PriorityThreadFactory.Java）：
import android.os.Process;
/**
* A thread factory that create threads with a given thread priority
* @author jony
* @version 1.0
*/
public class PriorityThreadFactory implements ThreadFactory{
private final String mName;
private final int mPriority;
private final AtomicInteger mNumber = new AtomicInteger();

public PriorityThreadFactory(String name, int priority) {
mName = name;// 線程池的名稱
mPriority = priority;//線程池的優先順序
}
@Override
public Thread newThread(Runnable r) {
return new Thread(r, mName +"-"+mNumber.getAndIncrement()){
@Override
public void run() {
// 設置線程的優先順序
Process.setThreadPriority(mPriority);
super.run();
}
};
}
}
//以上是創建線程池的一個工具類，接下來為大家介紹本篇文章的重點，線程池的實現方式，具體實現方式如下所示（MyThreadPool.java）：
package com.tcl.actionbar;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
package com.tcl.actionbar;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ThreadFactory;

// 線程池的實現方式
public class MyThreadPool {
private final static int POOL_SIZE = 4;// 線程池的大小最好設置成為CUP核數的2N
private final static int MAX_POOL_SIZE = 6;// 設置線程池的最大線程數
private final static int KEEP_ALIVE_TIME = 4;// 設置線程的存活時間
private final Executor mExecutor;
public MyThreadPool() {
// 創建線程池工廠
ThreadFactory factory = new PriorityThreadFactory("thread-pool", android.os.Process.THREAD_PRIORITY_BACKGROUND);
// 創建工作隊列
BlockingQueue<Runnable> workQueue = new LinkedBlockingDeque<Runnable>();
mExecutor = new ThreadPoolExecutor(POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS, workQueue, factory);
}
// 在線程池中執行線程
public void submit(Runnable command){
mExecutor.execute(command);
}
}

『肆』 android 線程池需要關閉嗎

不需要關閉

線程池的引入好處：
1.提升性能。創建和消耗對象費時費CPU資源
2.防止內存過度消耗。控制活動線程的數量，防止並發線程過多。
3.線程池技術能提高伺服器程序性能的，還顯著減少了創建線程的數目。
4.在Android中當同時並發多個網路線程時，引入線程池技術會極大地提高APP的性能。

『伍』 android 是自己設計線程池 怎麼用

使用線程池最大的優點是我們可以對我們開啟的線程進行跟進，當我們不需要處理的時候可以將它shutdow掉，同時當我們定義了一個線程池之後，可以復用線程而不需要開啟更多線程，這點對於我們手機開發是至關重要的，你開啟的thread越多意味著你的app內存消耗越多，速度也就越來越慢，提高現有線程的復用是一個很棒的選擇
線程池中處理線程的類別較多如：
限制按順序來執行任務的線程池、一個一個任務的執行線程池、按指定個數來執行任務的線程池、創建一個可在指定時間里執行任務的線程池，亦可重復執行、按指定工廠模式來執行的線程池

『陸』 android中的線程池 怎麼用

Java的線程池對Android也是適用的
線程池的作用：
線程池作用就是限制系統中執行線程的數量。
根據系統的環境情況，可以自動或手動設置線程數量，達到運行的最佳效果；少了浪費了系統資源，多了造成系統擁擠效率不高。用線程池控制線程數量，其他線程
排隊等候。一個任務執行完畢，再從隊列的中取最前面的任務開始執行。若隊列中沒有等待進程，線程池的這一資源處於等待。當一個新任務需要運行時，如果線程
池中有等待的工作線程，就可以開始運行了；否則進入等待隊列。
為什麼要用線程池:
1.減少了創建和銷毀線程的次數，每個工作線程都可以被重復利用，可執行多個任務。
2.可以根據系統的承受能力，調整線程池中工作線線程的數目，防止因為消耗過多的內存，而把伺服器累趴下(每個線程需要大約1MB內存，線程開的越多，消耗的內存也就越大，最後死機)。

Java通過Executors提供四種線程池，分別為：
newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。
newFixedThreadPool 創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。
newScheledThreadPool 創建一個定長線程池，支持定時及周期性任務執行。
newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

1.newCachedThreadPool

/**
* 可以緩存線程池
*/
public static void Function1() {
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 50; i++) {
final int index = i;
try {
Thread.sleep(100); // 休眠時間越短創建的線程數越多
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
executorService.execute(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("active count = " + Thread.activeCount()
+ " index = " + index);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
}

列印結果
active count = 2 index = 0
active count = 3 index = 1
active count = 4 index = 2
active count = 5 index = 3
active count = 6 index = 4
active count = 7 index = 5
active count = 8 index = 6
active count = 9 index = 7
active count = 10 index = 8
active count = 11 index = 9
active count = 11 index = 10
active count = 11 index = 11
active count = 11 index = 12
active count = 11 index = 13
active count = 11 index = 14
active count = 11 index = 15
active count = 11 index = 16
active count = 11 index = 17
active count = 11 index = 18
active count = 11 index = 19
active count = 11 index = 20
active count = 11 index = 21
active count = 11 index = 22
active count = 11 index = 23
active count = 11 index = 24
active count = 11 index = 25
active count = 11 index = 26
active count = 11 index = 27
active count = 11 index = 28
active count = 11 index = 29
active count = 11 index = 30
active count = 11 index = 31
active count = 11 index = 32
active count = 11 index = 33
active count = 11 index = 34
active count = 11 index = 35
active count = 11 index = 36
active count = 11 index = 37
active count = 11 index = 38
active count = 11 index = 39
active count = 11 index = 40
active count = 11 index = 41
active count = 11 index = 42
active count = 11 index = 43
active count = 11 index = 44
active count = 11 index = 45
active count = 11 index = 46
active count = 11 index = 47
active count = 11 index = 48
active count = 10 index = 49
從列印消息來看開始線程數在增加，後來穩定，可以修改休眠時間，休眠時間越短創建的線程數就越多，因為前面的還沒執行完，線程池中沒有可以執行的就需要創建；如果把休眠時間加大，創建的線程數就會少

2.newFixedThreadPool 根據傳入的參數創建線程數目
/**
* 定長線程池
*/
public static void Function2() {
ExecutorService executorService = Executors.newFixedThreadPool(3);
for (int i = 0; i < 30; i++) {
final int index = i;
executorService.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println("index = " + index
+ " thread count = " + Thread.activeCount());
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
}

3.newScheledThreadPool
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/**
* 定長線程池，可做延時
*/
public static void Function3() {
ScheledExecutorService executorService = Executors
.newScheledThreadPool(5);
executorService.schele(new Runnable() {

@Override
public void run() {
System.out.println("delay 3 seconds" + " thread count = "
+ Thread.activeCount());
}
}, 3, TimeUnit.SECONDS);
}

/**
* 定期執行，可以用來做定時器
*/
public static void Function4() {
ScheledExecutorService executorService = Executors
.newScheledThreadPool(3);
executorService.scheleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out
.println("delay 1 seconds, and excute every 3 seconds"
+ " thread count = " + Thread.activeCount());
}
}, 1, 3, TimeUnit.SECONDS);
}
列印結果
?

1
2
3
4
5
6
7
8
9

delay 1 seconds, and excute every 3 seconds thread count = 2
delay 1 seconds, and excute every 3 seconds thread count = 3
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4

4.newSingleThreadExecutor這個最簡單
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/**
* 單例線程
*/
public static void Function5() {
ExecutorService singleThreadExecutor = Executors
.newSingleThreadExecutor();
for (int i = 0; i < 5; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {

@Override
public void run() {
try {
System.out.println("index = " + index
+ " thread count = " + Thread.activeCount());
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
}

列印結果：
?

1
2
3
4
5

index = 0 thread count = 2
index = 1 thread count = 2
index = 2 thread count = 2
index = 3 thread count = 2
index = 4 thread count = 2

『柒』 android 線程池 怎麼用

我覺得使用線程池最大的優點是我們可以對我們開啟的線程進行跟進，當我們不需要處理的時候可以將它shutdow掉，同時當我們定義了一個線程池之後，可以復用線程而不需要開啟更多線程，這點對於我們手機開發是至關重要的，你開啟的thread越多意味著你的app內存消耗越多，速度也就越來越慢，提高現有線程的復用是一個很棒的選擇

線程池中處理線程的類別較多如：

限制按順序來執行任務的線程池、一個一個任務的執行線程池、按指定個數來執行任務的線程池、創建一個可在指定時間里執行任務的線程池，亦可重復執行、按指定工廠模式來執行的線程池

『捌』 Android的App中線程池的使用，具體使用多少個線程池

這個需要根據實際情況來確定的，一般來說根據模塊的功能和優先順序來區分，比如你一些必須載入的如用戶登錄就不要和圖片載入的用同一個線程池，當然這種情況比較少見，用戶和伺服器配置數據的應該單獨用一個線程池，下載模塊應該獨立一個，其它數據展示的用一個，曾經就出現過APP啟動的時候請求的線程過多導致用戶登錄線程一直排不上超時的情況

『玖』 android 使用線程池注意什麼

[java] view plain


ExecutorService pool = Executors.newFixedThreadPool(2); //創建一個能放兩個線程的池子
Thread t1 = new Thread();
Thread t2 = new Thread();

pool.execute(t1);
pool.execute(t2);//這是非同步的

如果要想知道,t1和t2，都走完了。

需要這么寫

[java] view plain


pool.shutdown();//先關閉線程池，不會影響已運行的線程
while (true) {
if (pool.isTerminated()) {
//所有任務完成
break;
}
Thread.sleep(200);

還有一種寫法

[java] view plain


List<Future> list=new ArrayList<Future>();
list.add(exe.submit(new Runnable() {
@Override
public void run() {

}
}));
for(int i=0;i<list.size();i++){
try {
list.get(i).get();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
這種方法會阻礙主線程

『拾』 android中怎麼用線程池

一般是按照CPU的核數來定義，例如是4核的，一般一個fixed線程池定義為4個線程左右。