Java NIO usage and principle Analysis (d) (EXT)

Some of the details about the buffer are described in the previous article, and it is now finally possible to get into the most interesting parts of NiO that are non-blocking I/O. Typically, when synchronizing I/O operations, if the data is read, the code blocks until there is data available for reading. Similarly, the write call will block until the data can be written. The traditional server/client mode is based on TPR (thread per request), and the server establishes a thread for each client request, which is solely responsible for processing a customer request. One problem with this pattern is that the number of threads increases, and a large number of threads increase the cost of the server. Most implementations, in order to avoid this problem, have adopted a thread pool model and set the maximum number of thread pool threads, which brings new problems, if there are 200 threads in the thread pool, and 200 users are doing large file downloads, the No. 201 user's request will not be processed in time. Even if the No. 201 user only wants to request a page of a few KB size. The traditional server/client pattern is as follows:

NiO non-blocking I/O is based on the reactor mode of operation, I/O calls will not be blocked, instead of registering interested in specific I/O events, such as the arrival of readable data, new socket connections and so on, in the event of a particular incident, the system informs us. The core object of implementing nonblocking I/O in NiO is that Selector,selector is registering various I/O events, and when those events occur, it is the object that tells us what happened, as shown here:

As you can see, when any registered event such as read or write occurs, the corresponding Selectionkey can be obtained from the selector, and the event that occurs and the specific selectablechannel of the event can be found from the Selectionkey. To get the data that the client sent over. Refer to Java NIO usage and principle Analysis (i) for Selectablechannel

Using NiO non-blocking I/O to write server handlers can be broadly divided into the following three steps:

1. Register an event of interest to the selector object
2. Get events of interest from selector
3. According to the different events to deal with the corresponding

Next we use a simple example to illustrate the whole process. The first is to register an event of interest to the Selector object:

[Java]View PlainCopyprint?

2. /*
4. * Register Event
6. * */
8. Protected Selector Getselector () throws IOException {
10. //Create selector object
12. Selector sel = Selector.open ();
16. //Create selectable channels and configure as nonblocking mode
18. Serversocketchannel Server = Serversocketchannel.open ();
20. Server.configureblocking (false);
24. //BIND channel to specified port
26. ServerSocket socket = Server.socket ();
28. Inetsocketaddress address = new inetsocketaddress (port);
30. Socket.bind (address);
34. //Register an event of interest to selector
36. Server.register (SEL, selectionkey.op_accept);
38. return sel;
40. }

The Serversocketchannel object is created and the Configureblocking () method is called, configured as nonblocking mode, the next three lines of code bind the channel to the specified port, and finally the event is registered to selector, where the parameter is specified as Op_ Accept, which specifies that we want to listen to the Accept event, which is the event generated when a new connection occurs, the only parameter we can specify for the Serversocketchannel channel is op_accept.

Get an event of interest from selector, that is, start listening and enter the inner loop:

[Java]View PlainCopyprint?

2. /*
4. * Start monitoring
6. * */
8. Public void Listen () {
10. System.out.println ("Listen on" + port);
12. try {
14. While (true) {
16. //The call will block until at least one event occurs
18. Selector.select ();
20. set<selectionkey> keys = Selector.selectedkeys ();
22. Iterator<selectionkey> iter = Keys.iterator ();
24. While (Iter.hasnext ()) {
26. Selectionkey key = (Selectionkey) iter.next ();
28. Iter.remove ();
30. Process (key);
32. }
34. }
36. } catch (IOException e) {
38. E.printstacktrace ();
40. }
42. }

In non-blocking I/O, the internal loop pattern basically follows this approach. First call the Select () method, which blocks until at least one event occurs, and then uses the Selectedkeys () method to get the selectionkey of the event, and then uses the iterator to loop.

The final step is to write the corresponding processing code according to the different events:

[Java]View PlainCopyprint?

2. /*
4. * Processing according to different events
6. * */
8. protected void process (Selectionkey key) throws ioexception{
10. //Receive requests
12. if (key.isacceptable ()) {
14. Serversocketchannel Server = (Serversocketchannel) key.channel ();
16. Socketchannel channel = Server.accept ();
18. Channel.configureblocking (false);
20. Channel.register (selector, selectionkey.op_read);
22. }
24. //Read information
26. Else if (key.isreadable ()) {
28. Socketchannel channel = (Socketchannel) key.channel ();
30. int count = channel.read (buffer);
32. if (Count > 0) {
34. Buffer.flip ();
36. Charbuffer Charbuffer = decoder.decode (buffer);
38. Name = Charbuffer.tostring ();
40. Selectionkey SKey = Channel.register (selector, selectionkey.op_write);
42. Skey.attach (name);
44. } Else {
46. Channel.close ();
48. }
50. Buffer.clear ();
52. }
54. //write event
56. Else if (key.iswritable ()) {
58. Socketchannel channel = (Socketchannel) key.channel ();
60. String name = (string) key.attachment ();
64. Bytebuffer block = Encoder.encode (Charbuffer.wrap ("Hello" + name);
66. if (block! = null)
68. {
70. Channel.write (block);
72. }
74. Else
76. {
78. Channel.close ();
80. }
84. }
86. }

Here, we judge whether to accept the request, read the data or write the event, and make different processing respectively.

Here are four articles on the use and principle analysis of Java NIO. Java NIO provides a set of abstractions, such as channels, buffers, selectors, which greatly simplifies the way we write high-performance, hair-styling server programs, with the opportunity to continue talking about some of the ideas behind using Java NiO.

Original address: http://blog.csdn.net/wuxianglong/article/details/6612282

Java NIO usage and principle Analysis (d) (EXT)