Executors provides four thread pools

Java Concurrency Programming--executors

Thread pool idea is a kind of object pool idea, open a piece of memory space, inside contains many (not dead) threads, the pool thread execution schedule is handled by the pool manager. When a thread task is taken, one from the pool is executed and the object is returned to the pool. This avoids the performance overhead of repeatedly creating thread objects, saving the resources of the system.

Code: http://www.cnblogs.com/chenjingjing/articles/1683745.html

A fixed-size thread pool Newfixedthreadpool

Second, single task thread pool Newsinglethreadexecutor

for both of these connection pools, the size is fixed, and when the thread (or task) of the pool to be joined exceeds the maximum size of the pool, a queue waits for the pool to enter this thread. Once the threads in the pool are complete, a thread queued for execution is pooled.

Three, the variable size thread pool Newcachedthreadpool

Iv. delayed Connection pool Newscheduledthreadpool

V. custom thread pool threadpoolexecutor (one meal parameter)

----------------------------------------------------------------------------

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 code

2. Package test;
4. Import Java.util.concurrent.ExecutorService;
6. Import java.util.concurrent.Executors;
8. Public class Threadpoolexecutortest {
10. public static void Main (string[] args) {
12. Executorservice Cachedthreadpool = Executors.newcachedthreadpool ();
14. For (int i = 0; i < i++) {
16. final int index = i;
18. try {
20. Thread.Sleep (Index * 1000);
22. } catch (Interruptedexception e) {
24. E.printstacktrace ();
26. }
28. Cachedthreadpool.execute (new Runnable () {
30. public Void Run () {
32. SYSTEM.OUT.PRINTLN (index);
34. }
36. });
38. }
40. }
42. }

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 code

2. Package test;
4. Import Java.util.concurrent.ExecutorService;
6. Import java.util.concurrent.Executors;
8. Public class Threadpoolexecutortest {
10. public static void Main (string[] args) {
12. Executorservice Fixedthreadpool = Executors.newfixedthreadpool (3);
14. For (int i = 0; i < i++) {
16. final int index = i;
18. Fixedthreadpool.execute (new Runnable () {
20. public Void Run () {
22. try {
24. SYSTEM.OUT.PRINTLN (index);
26. Thread.Sleep (2000);
28. } catch (Interruptedexception e) {
30. E.printstacktrace ();
32. }
34. }
36. });
38. }
40. }
42. }

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 ()

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

Java code

2. Package test;
4. Import java.util.concurrent.Executors;
6. Import Java.util.concurrent.ScheduledExecutorService;
8. Import Java.util.concurrent.TimeUnit;
10. Public class Threadpoolexecutortest {
12. public static void Main (string[] args) {
14. Scheduledexecutorservice Scheduledthreadpool = Executors.newscheduledthreadpool (5);
16. Scheduledthreadpool.schedule (new Runnable () {
18. public Void Run () {
20. SYSTEM.OUT.PRINTLN ("delay 3 seconds");
22. }
24. }, 3, timeunit.seconds);
26. }
28. }

Represents a delay of 3 seconds for execution.

The sample code is executed periodically as follows:

Java code

2. Package test;
4. Import java.util.concurrent.Executors;
6. Import Java.util.concurrent.ScheduledExecutorService;
8. Import Java.util.concurrent.TimeUnit;
10. Public class Threadpoolexecutortest {
12. public static void Main (string[] args) {
14. Scheduledexecutorservice Scheduledthreadpool = Executors.newscheduledthreadpool (5);
16. Scheduledthreadpool.scheduleatfixedrate (new Runnable () {
18. public Void Run () {
20. SYSTEM.OUT.PRINTLN ("Delay 1 seconds, and excute every 3 seconds");
22. }
24. }, 1, 3, timeunit.seconds);
26. }
28. }

Represents a delay of 1 seconds after every 3 seconds.

(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 code

2. Package test;
4. Import Java.util.concurrent.ExecutorService;
6. Import java.util.concurrent.Executors;
8. Public class Threadpoolexecutortest {
10. public static void Main (string[] args) {
12. Executorservice singlethreadexecutor = Executors.newsinglethreadexecutor ();
14. For (int i = 0; i < i++) {
16. final int index = i;
18. Singlethreadexecutor.execute (new Runnable () {
20. public Void Run () {
22. try {
24. SYSTEM.OUT.PRINTLN (index);
26. Thread.Sleep (2000);
28. } catch (Interruptedexception e) {
30. E.printstacktrace ();
32. }
34. }
36. });
38. }
40. }
42. }

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

You can monitor the number of threads we create, run a non-terminating thread, and create a specified amount of threads, using the JDK's own monitoring tools to observe:
Tools Catalog:C:\Program files\java\jdk1.6.0_06\bin\jconsole.exe
Run the program to make a slight change:

Java code

2. Package test;
4. Import Java.util.concurrent.ExecutorService;
6. Import java.util.concurrent.Executors;
8. Public class Threadpoolexecutortest {
10. public static void Main (string[] args) {
12. Executorservice singlethreadexecutor = Executors.newcachedthreadpool ();
14. For (int i = 0; i < ; i++) {
16. final int index = i;
18. Singlethreadexecutor.execute (new Runnable () {
20. public Void Run () {
22. try {
24. While (true) {
26. SYSTEM.OUT.PRINTLN (index);
28. Thread.Sleep ( 1000);
30. }
32. } catch (Interruptedexception e) {
34. E.printstacktrace ();
36. }
38. }
40. });
42. try {
44. Thread.Sleep (500);
46. } catch (Interruptedexception e) {
48. E.printstacktrace ();
50. }
52. }
54. }
56. }

The effect is as follows:

Select the program we run:

Monitor running status

Please go to Iteye website to see Java Xiao Qiang original, thank you!

http://cuisuqiang.iteye.com/!

---------------------------------------------------

Executors provides four thread pools