Java (Android) thread pool

  1. The disadvantage of new thread
Perform an asynchronous task are you still just following the new thread? [Java]View Plaincopy

1. New Thread (new Runnable () {
3. @Override
4. public Void Run () {
5. //TODO auto-generated method stub
6. }
7. }). Start ();

Then you are out too much, and the drawbacks of new thread are as follows:

A. Each new thread creates a poor performance for the newly created object.
B. Lack of unified management of threads, the possibility of unlimited new threads, competing with each other, and potentially consuming excessive system resources can lead to freezing or oom.
C. Lack of additional functionality, such as timed execution, periodic execution, and thread interruption.
The benefits of the four thread pools provided by new Thread,java are:
A. Reusing existing threads, reducing the cost of object creation, extinction, and performance.
B. Can effectively control the maximum number of concurrent threads, improve the utilization of system resources, while avoiding excessive resource competition, avoid clogging.
C. Provide functions such as timed execution, periodic execution, single-threaded, concurrency control, etc.

2. Java thread Pool
Java provides four thread pools through executors, namely:
Newcachedthreadpool creates a cacheable thread pool that can flexibly reclaim idle threads if the thread pool length exceeds the processing needs, and creates a new thread if it is not recyclable.
Newfixedthreadpool creates a thread pool that controls the maximum number of concurrent threads, and the excess threads wait in the queue.
Newscheduledthreadpool creates a fixed-line pool that supports timed and recurring task execution.
Newsinglethreadexecutor creates a single threaded thread pool that performs tasks with only a single worker thread, ensuring that all tasks are executed in the specified order (FIFO, LIFO, priority).

(1). Newcachedthreadpool
Creates a cacheable thread pool that can flexibly reclaim idle threads if the thread pool length exceeds the processing needs, and creates a new thread if it is not recyclable. The sample code is as follows:

[Java]View Plaincopy

2. Executorservice Cachedthreadpool = Executors.newcachedthreadpool ();
4. for (int i = 0; i < i++) {
6. final int index = i;
8. try {
10. Thread.Sleep (Index * 1000);
12. } catch (Interruptedexception e) {
14. E.printstacktrace ();
16. }
20. Cachedthreadpool.execute (new Runnable () {
24. @Override
26. public Void Run () {
28. SYSTEM.OUT.PRINTLN (index);
30. }
32. });
34. }

The thread pool is infinitely large, and when the first task is completed when the second task is performed, the threads that perform the first task are reused instead of each new thread.

(2). Newfixedthreadpool
Creates a thread pool that controls the maximum number of concurrent threads, and the excess threads wait in the queue. The sample code is as follows:

[Java]View Plaincopy

2. Executorservice Fixedthreadpool = Executors.newfixedthreadpool (3);
4. for (int i = 0; i < i++) {
6. final int index = i;
8. Fixedthreadpool.execute (new Runnable () {
12. @Override
14. public Void Run () {
16. try {
18. SYSTEM.OUT.PRINTLN (index);
20. Thread.Sleep (2000);
22. } catch (Interruptedexception e) {
24. //TODO auto-generated catch block
26. E.printstacktrace ();
28. }
30. }
32. });
34. }

Because the thread pool size is 3, each task outputs index after sleep for 2 seconds, so 3 digits are printed every two seconds.

The size of a fixed-length pool is best set based on system resources. such as Runtime.getruntime (). Availableprocessors (). Refer to Preloaddatacache.

(3) Newscheduledthreadpool
Create a fixed-line pool that supports timed and recurring task execution. The deferred execution sample code is as follows:

[Java]View Plaincopy

1. Scheduledexecutorservice Scheduledthreadpool = Executors.newscheduledthreadpool (5);
2. Scheduledthreadpool.schedule (new Runnable () {
4. @Override
5. public Void Run () {
6. SYSTEM.OUT.PRINTLN ("delay 3 seconds");
7. }
8. }, 3, timeunit.seconds);

Represents a delay of 3 seconds for execution.

Regular code execution is as follows:

[Java]View Plaincopy

1. Scheduledthreadpool.scheduleatfixedrate (new Runnable () {
3. @Override
4. public Void Run () {
5. SYSTEM.OUT.PRINTLN ("Delay 1 seconds, and excute every 3 seconds");
6. }
7. }, 1, 3, timeunit.seconds);

Represents a delay of 1 seconds after every 3 seconds.

Scheduledexecutorservice is safer and more powerful than a timer, and there is a separate comparison in the back.

(4), Newsinglethreadexecutor
Creates a single threaded thread pool that performs tasks with only a single worker thread, ensuring that all tasks are executed in the specified order (FIFO, LIFO, priority). The sample code is as follows:

[Java]View Plaincopy

2. Executorservice singlethreadexecutor = Executors.newsinglethreadexecutor ();
4. for (int i = 0; i < i++) {
6. final int index = i;
8. Singlethreadexecutor.execute (new Runnable () {
12. @Override
14. public Void Run () {
16. try {
18. SYSTEM.OUT.PRINTLN (index);
20. Thread.Sleep (2000);
22. } catch (Interruptedexception e) {
24. //TODO auto-generated catch block
26. E.printstacktrace ();
28. }
30. }
32. });
34. }

The results are output sequentially, which is equivalent to performing each task sequentially.

Single threading is useful in some cases, and most GUI programs are single-threaded. The use of single threading in Android for performance tuning is described later.

Java (Android) thread pool