jdk1.4 构建 java多线程,并发设计框架 使用列子(三)

2. import java.io.*;
3. import java.net.Socket;
4. import java.io.BufferedInputStream;
5. import java.io.ByteArrayOutputStream;
6. import java.net.SocketException;
7. //import java.nio.ByteBuffer;
9. /**
10.  * 获取相关数据流.
11.  * 把读取的数据流,发送给处理数据流的对象ProcessRequestData.
12.  * @author guishuanglin 2008-11-3
13.  * 
14.  */
15. public class ProcessRequestStream implements Runnable {
16.     //ByteArrayOutputStream
17.     private ConcurrentQueue cQueue;
18.     private String hostAddress;
19.     private Socket socket;
20.     private InputStream in;
21.     private BufferedInputStream bufInput;
22.     private ByteArrayOutputStream buffeData;
23.     private int requestCount;
24.     private byte b[];
25.     private byte end[];
26.     private int len;
27.     private int maxBuffer = 1024;
29.     /**
30.      * @param ss
31.      * @param requestNum
32.      */
33.     public ProcessRequestStream(Socket st,int requestCount,int cacheByte,ConcurrentQueue cQueue) {
34.         socket = st;
35.         this.cQueue = cQueue;
36.         this.maxBuffer = cacheByte;
37.         this.requestCount= requestCount;
38.         end = new byte[]{101, 110, 100};
39.         b   = new byte[1024];
40.         System.out.println("Request["+requestCount+"],buffer byte: "+cacheByte);
41.         try {
42.             //连接超时设置30s
43.             socket.setSoTimeout(30000);
44.             in = socket.getInputStream();
45.             bufInput = new BufferedInputStream(in);
46.             hostAddress  = socket.getInetAddress().getHostAddress();
47.         } catch (IOException ie) {
48.             System.out.println("Request["+requestCount+"],读取客户端[" + hostAddress + "]的输入流失败.");
49.             ReleaseResource();
50.             ie.printStackTrace();
51.             System.exit(0);
52.         }
53.     }
55.     public void run() {
56.         bufferStreamData();
57.     }
58.     /**
59.      * @date 2008-11-5
60.      */
61.     public void bufferStreamData() {
62.         // 读取输入流,如果由于流末尾已到达而不再有数据，则返回 -1，表示对方已经关闭.
63.         try{
64.             //第一次读数据
65.             len = bufInput.read(b);
66.             if(len != -1){
67.                 this.newOutputStream();
68.                 buffeData.write(b, 0, len);
69.                 while ((len = bufInput.read(b)) != -1) {
70.                     if(buffeData.size() < this.maxBuffer){
71.                         buffeData.write(b, 0, len);
72.                     }else{
73.                         newOutputStream();
74.                         buffeData.write(b, 0, len);
75.                     }
76.                 }
77.             }
78.             bufInput.close();
79.             in.close();
80.             socket.close();
81.         } catch (SocketException se) {
82.             se.printStackTrace();
83.         } catch (IOException io) {
84.             io.printStackTrace();
85.         } finally {
86.             //流的结束处加上完成读的3字节的end单独标志.
87.             newOutputStream();
88.             buffeData.write(end, 0, end.length);
89.             cQueue.enQueue(buffeData);
90.             System.out.println("Request["+requestCount+"],读取流数据完成.");
91.             ReleaseResource();
92.         }
93.     }
94.     
95.     public void newOutputStream(){
96.         if(buffeData != null && buffeData.size()>0){
97.             //int i = cQueue.size()+1;
98.             cQueue.enQueue(buffeData);
99.             //System.out.println("Request["+requestCount+"],add buffer queue,current size: "+i);
100.         }
101.         buffeData = null;
102.         buffeData = new ByteArrayOutputStream();
103.     }
104.     
105.     public void ReleaseResource() {
106.         try {
107.             buffeData =null;
108.             bufInput  =null;
109.             if(in!=null)
110.                 in.close();
111.             in=null;
112.             if(socket!=null)
113.                 socket.close();
114.             socket=null;
115.             b=null;
116.             end=null;
117.             System.out.println("Request["+requestCount+"],客户端[" + hostAddress + "]会话socket已断开.");
118.             hostAddress=null;
119.             cQueue   = null;
120.         } catch (IOException e) {
121.             e.printStackTrace();
122.         }
123.     }
125. }

 接到 Socket流后，处理流数据，把数据放入并发队列中。