Java executors (thread pool)

Sun in the JAVA5, the Java thread of the class library to do a lot of expansion, in which the thread pool is one of the new features of JAVA5, in addition to the thread pool, there are many multi-threaded related content, for multi-threaded programming has brought great convenience. In order to write high-performance and stable and reliable multithreaded programs, the new content of the thread part is particularly important.

The contents of the JAVA5 line assigns feature are all under Java.util.concurrent, which contains a number of interfaces and classes, and familiarity with this part of the API feature is a difficult learning process. At present, the information and books on this aspect are few and far between, and the book on the thread of the big belongs to the knowledge level before Java5.

Of course, the new features do not have a need for long-line programs, before JAVA5 General can write excellent multi-threaded program. But the price is different.

The basic idea of the thread pool is also the idea of an object pool, which opens up a memory space in which many (not dead) threads are stored, and the thread execution schedule is handled by the pool manager. When a thread task is taken from a pool, the threads object is pooled after execution, which avoids the performance overhead of repeatedly creating thread objects and saves system resources.

Before Java5, to implement a thread pool is quite difficult, now Java5 for us to do everything, we just need to follow the provided API to use, can enjoy the great convenience of the thread pool.

JAVA5 's thread pool can be divided into two categories: a fixed-size thread pool and a variable-size connection pool.

Before using the thread pool, you must know how to create a thread pool, and in Java5, you need to know about the API of the Java.util.concurrent.Executors class, which provides a lot of static methods for creating connection pools that you must master.

A fixed-size thread pool, Newfixedthreadpool:

[Java]View Plaincopy

2. Package app.executors;
6. Import java.util.concurrent.Executors;
8. Import Java.util.concurrent.ExecutorService;
12. /**
14. * Java Thread: thread pool
16. *
18. * @author Feng Xiaowei
20. */
22. Public class Test {
24. public static void Main (string[] args) {
26. //Create a thread pool that can reuse a fixed number of threads
28. Executorservice pool = Executors.newfixedthreadpool (5);
30. //Create thread
32. Thread T1 = new MyThread ();
34. Thread t2 = new MyThread ();
36. Thread t3 = new MyThread ();
38. Thread T4 = new MyThread ();
40. Thread T5 = new MyThread ();
42. //Put the thread into the pool for execution
44. Pool.execute (t1);
46. Pool.execute (T2);
48. Pool.execute (T3);
50. Pool.execute (T4);
52. Pool.execute (T5);
54. //close thread pool
56. Pool.shutdown ();
58. }
60. }
64. Class MyThread extends Thread {
66. @Override
68. public Void Run () {
70. System.out.println (Thread.CurrentThread (). GetName () + "executing ...  ");
72. }
74. }

Output Result:

[HTML]View Plaincopy

1. Pool-1-thread-1 is executing ...
2. Pool-1-thread-3 is executing ...
3. Pool-1-thread-4 is executing ...
4. Pool-1-thread-2 is executing ...
5. Pool-1-thread-5 is executing ...

Change the parameters in Executorservice pool = Executors.newfixedthreadpool (5): Executorservice pool = Executors.newfixedthreadpool (2), The output is:

[HTML]View Plaincopy

1. Pool-1-thread-1 is executing ...
2. Pool-1-thread-1 is executing ...
3. Pool-1-thread-2 is executing ...
4. Pool-1-thread-1 is executing ...
5. Pool-1-thread-2 is executing ...

As can be seen from the above results, the Newfixedthreadpool parameter specifies the maximum number of threads that can be run, which will not run after the number of lines loads in. Second, threads that join the thread pool are managed, and the threads are not affected by the order of accession.

Second, single task thread pool, Newsinglethreadexecutor:

Just change the Executorservice pool = Executors.newfixedthreadpool (2) in the above code to Executorservice pool = Executors.newsinglethreadexecutor ();

Output Result:

[HTML]View Plaincopy

1. Pool-1-thread-1 is executing ...
2. Pool-1-thread-1 is executing ...
3. Pool-1-thread-1 is executing ...
4. Pool-1-thread-1 is executing ...
5. Pool-1-thread-1 is executing ...

As you can see, each call to the Execute method is, in fact, the last call to the Thread-1 run method.

Three, variable size thread pool, Newcachedthreadpool:

Similar to the above, just change the way the pool was created: executorservice pool = Executors.newcachedthreadpool ();

Output:

[HTML]View Plaincopy

1. Pool-1-thread-1 is executing ...
2. Pool-1-thread-2 is executing ...
3. Pool-1-thread-4 is executing ...
4. Pool-1-thread-3 is executing ...
5. Pool-1-thread-5 is executing ...

This approach is characterized by the creation of thread pools for new threads as needed, but reusing them when previously constructed threads are available.

Iv. delayed Connection pool, Newscheduledthreadpool:

[Java]View Plaincopy

2. Package app.executors;
6. Import java.util.concurrent.Executors;
8. Import Java.util.concurrent.ScheduledExecutorService;
10. Import Java.util.concurrent.TimeUnit;
14. /**
16. * Java Thread: thread pool
18. *
20. * @author Feng Xiaowei
22. */
24. Public class Test {
26. public static void Main (string[] args) {
28. //Create a thread pool that can schedule commands to run after a given delay or perform them on a regular basis.
30. Scheduledexecutorservice pool = Executors.newscheduledthreadpool (2);
32. //created implements the Runnable interface object, the thread object of course also implements the Runnable interface
34. Thread T1 = new MyThread ();
36. Thread t2 = new MyThread ();
38. Thread t3 = new MyThread ();
40. //Put the thread into the pool for execution
42. Pool.execute (t1);
44. //Using the method of deferred execution style
46. Pool.schedule (T2, timeunit.milliseconds);
48. Pool.schedule (T3, ten, timeunit.milliseconds);
52. //close thread pool
54. Pool.shutdown ();
56. }
58. }
62. Class MyThread extends Thread {
64. @Override
66. public Void Run () {
68. System.out.println (Thread.CurrentThread (). GetName () + "executing ...  ");
70. }
72. }

Readers can try to change the parameters of Executors.newscheduledthreadpool (2) to get more experience, of course, let

[Java]View Plaincopy

1. @Override
2. Public void Run () {
3. System.out.println (Thread.CurrentThread (). GetName () + "executing ...  ");
4. }

into an infinite loop, you can get more usage about Pool.shutdown ().

V: Single-task delayed connection pool (similar to the above, it is not written). Of course, we can also customize the thread pool, here will not write, tired ah ...

Transferred from: http://blog.csdn.net/coding_or_coded/article/details/6856014

Java executors (thread pool)