Multithreaded Endpoint Service Publishers (excerpt)

Multithreaded Endpoint Service Publishers

Excerptfrom: JAVA Web services: building and running

Ningzhanga

Java Web Services: Build and Run is an example-driven way of describing the Java-related APIs covered by XML Web services and RESTful Web services in a clear and pragmatic way, and the 1th chapter describes the Java Web Services QuickStart. This section is about multithreaded endpoint service publishers.

AD:2014WOT Global Software Technology Summit Beijing Station course video release

1.1 Multi-Threaded endpoint Service publisher

Multithreading the Endpoint Publisher

In previous examples, the endpoint publisher was single-threaded, meaning that only one client request could be processed concurrently at the same time. Before you process the next request, you must wait for the published service to complete the process that is currently being processed. If the service request that is currently being processed is suspended, no further service requests can be made until the pending request has been processed.

In a formal product environment, the endpoint Publisher needs to process multiple client requests concurrently, so that multiple unpredictable client requests can be processed at the same time. For the underlying computer systems, such as for the Chenduo processor (smp,symmetric multiprocessor) system, each individual CPU can concurrently handle different client requests. In a single-processor computer environment, a time-sharing mechanism can be used to complete concurrent processing of client requests within the same time. The Java language supports multi-threaded concurrency processing mechanisms. Therefore, what we need to solve is how to make the endpoint publisher also support multithreading mechanism. The JWS framework supports endpoint multi-threading mode, and the program staff does not have to face complex and difficult-to-control synchronization blocks (Synchronized block), wait and notify method invocations, and so on.

The endpoint object has a executor property that defines the standard Get/set method. Excutor is used to perform a running (Runnable) task, such as a Java thread instance. (The Runnable interface in Java only defines a common interface method with no return value: Run ().) The Executor object is a good choice for multithreading because the executor provides a high level of encapsulation for the commit and management of the task being performed. The first step in enabling the endpoint Publisher to support multithreading is to create a executor class with the following code:

2. Package ch01.ts;
6. Import Java.util.concurrent.ThreadPoolExecutor;
8. Import Java.util.concurrent.LinkedBlockingQueue;
10. Import Java.util.concurrent.TimeUnit;
12. Import Java.util.concurrent.locks.ReentrantLock;
14. Import java.util.concurrent.locks.Condition;
18. Public class Mythreadpool extends Threadpoolexecutor {
20. private static final int pool_size = 10;
22. private Boolean is_paused;
24. private Reentrantlock Pause_lock = new Reentrantlock ();
26. private Condition unpaused = Pause_lock.newcondition ();
30. Public Mythreadpool () {
32. Super (Pool_size, //core pool size
34. Pool_size, //maximum pool size
36. 0L, //keep-alive time for idle thread
38. Timeunit.seconds, //time unit for keep-alive setting
40. New Linkedblockingqueue<runnable> (pool_size)); //Work Queue
42. }
46. //Some overrides
48. protected void BeforeExecute (Thread T, Runnable R) {
50. Super.beforeexecute (t, R);
52. Pause_lock.lock ();
54. try {
56. while (is_paused) unpaused.await ();
58. }
62. catch (Interruptedexception e) {t.interrupt ();}
64. finally {pause_lock.unlock ();}
66. }
70. public void Pause () {
72. Pause_lock.lock ();
74. try {
76. is_paused = true;
78. }
80. finally {pause_lock.unlock ();}
82. }
86. public void Resume () {
88. Pause_lock.lock ();
90. try {
92. is_paused = false;
94. Unpaused.signalall ();
96. }
98. finally {pause_lock.unlock ();}
100. }
102. }

Mythreadpool creates a thread pool of 10 threads, which are stored using a fixed-size queue. When a thread pool is used, the next task in the queue must wait until an idle thread in the thread sink is freed. The details of these management are handled automatically by the thread pool. Mythreadpool rewritten several methods in the Threadpoolexecutor.

With the Mythreadpool object, the endpoint Publisher can support multithreading. Here is the revised code based on the previous release program, which decomposes the publishing task in different ways:

2. Package ch01.ts;
4. Import Javax.xml.ws.Endpoint;
6. Class TIMEPUBLISHERMT { //MT for multithreaded
8. private Endpoint Endpoint;
12. public static void Main (string[] args) {
14. TIMEPUBLISHERMT self = new timepublishermt ();
16. Self.create_endpoint ();
18. Self.configure_endpoint ();
20. Self.publish ();
22. }
24. private void Create_endpoint () {
26. Endpoint = endpoint.create (new Timeserverimpl ());
28. }
32. private void Configure_endpoint () {
34. Endpoint.setexecutor (new Mythreadpool ());
36. }
38. private Void Publish () {
40. int port = 8888;
42. String url = "http://localhost:" + port + "/ts";
44. Endpoint.publish (URL);
46. System.out.println ("Publishing timeserver on port" + port);
48. }
50. }

After the Threadpoolworker is written, the rest of the work is to set the executor property of the endpoint instance in this example, and the Publisher does not involve any details of thread management.

Multi-threaded endpoint publishers are better suited to some lightweight products, but in a real application scenario, the above is not a service container; A service container can publish multiple Web services on the same port. Some web containers, such as Tomcat, provide these feature implementations, which are more appropriate for use when publishing multiple Web services. The Web service in the following example will show you how to publish through Tomcat.

Multithreaded Endpoint Service Publishers (excerpt)