菜鳥初學Java的備忘錄（九） (轉)

菜鳥初學Java的備忘錄（九） (轉)[@more@]

年1月25日 星期六 雨

我突然發現了利用介面實現多執行緒和利用類構造執行緒體的不同了，以前我好像並沒有太多的注意.利用類構造執行緒體的時候,需要使用這個類來定義執行緒,比如MyThread thread1=New MyThread(),而使用介面建立執行緒體的時候,只需要用到Thread類就可以了,比如Thread thread1=new Thread(MyThread).這在幾天前所講的多執行緒的Socket中均有體現.

前面不懈的努力使我現在可以繼續原先未完成的工作,正式向連線池版本的Socket進發了.

回顧一下我們是如何建立多執行緒的MultiThreadRemoteFileServer的,這得看看前幾天的內容了.概括起來,就是為每個等待連線的客戶new一個執行緒使用,來一個分配一個.每當有客戶機申請一個連線時都在一個新 Thread 中建立一個新 ConnectionHandler(注:使用介面構造的執行緒體).這意味著可能有一打 Thread在整個中執行著.顯然,系統的開銷會因為連線客戶的數目的增長而不斷增加.我們不能夠不考慮到開銷增加到一定程度的時候系統會承受不住的可能.因此,得想個辦法限制連線客戶的數量,提高伺服器的.

那麼解決的方案是:在伺服器端，我們在伺服器啟動時建立一定數量的PooledConnectionHandler，我們把進入的連線放入一個連線池中並讓PooledConnectionHandler 打理剩下的事情.客戶端的完全不用修改,這樣設計的優點如下:

1.限定了允許同時連線的數目。
2.只需要啟動PooledConnectionHandler執行緒有限次

這兩句話的涵義將在其後的程式中得到體現,下面是 PooledRemoteFileServer 類的結構:

import .io.*;
import java.*;
import java.util.*;

public class PooledRemoteFileServer {
  protected int maxConnections;//定義能同時處理的客戶機連線的最大數目  protected int listenPort;//定義要的埠號
  protected ServerSocket serverSocket;

  public PooledRemoteFileServer(int aListenPort, int maxConnections) {
  listenPort = aListenPort;
  this.maxConnections = maxConnections;
  }
  public static void main(String[] args) {
  }
  public void setUpHandlers(){//建立數目為maxConnections的 PooledConnectionHandler
  }
  public void acceptConnections(){//在 ServerSocket 上監聽傳入的客戶機連線,和前面的RemoteFileServer,MultiThreadRemoteFileServer中的監聽程式完全一樣
  }
  protected void handleConnection(Socket incomingConnection) {
  }//連線處理程式
}

同樣,首先來看main
public static void main(String[] args) {
  PooledRemoteFileServer server = new PooledRemoteFileServer(3000, 3);
  server.setUpHandlers();//同前面所有伺服器的main函式不同,我們先要建立一個連線池,這個池裡面有三個可用的connectionHandler
  server.acceptConnections();//一旦就緒，就開始監聽

下面我們就來看建立三個connectionHandler的程式如何實現:

public void setUpHandlers(){
  for (int i = 0; i < maxConnections; i++) {
  PooledConnectionHandler currentHandler = new PooledConnectionHandler();
  new Thread(currentHandler, "Handler " + i).start();
  }
}

setUpHandlers() 方法建立maxConnections個PooledConnectionHandler並在新 Thread 中啟用它們. PooledConnectionHandler在這裡是一個用介面(Runnable)實現的執行緒體.用實現了Runnable的物件來建立Thread使我們可以在 Thread start() 並且可以期望在Runnable上呼叫了 run()。也就是說,我們的 PooledConnectionHandler 將等著處理進入的連線，每個都在它自己的Thread中進行。我們在示例中只建立三個Thread，而且一旦伺服器執行，這就不能被改變。

acceptConnections()方法這裡就略去不寫了,看看連線處理程式handleConnection(Socket incomingConnection)

protected void handleConnection(Socket connectionToHandle) {
  PooledConnectionHandler.processRequest(connectionToHandle);
}

這裡連線處理程式直接呼叫了PooledConnectionHandler執行緒類的類方法processRequest對監聽到的連線進行處理,顯然這個processRequest是一個靜態方法.

PooledRemoteFileServer類中的方法均涉及到一個重要的執行緒類,PooledConnectionHandler.下面就看看這樣一個用介面實現的類長什麼樣:

public class PooledConnectionHandler implements Runnable {
  protected Socket connection;//代表當前正在處理的Socket
  protected static List pool = new LinkedList();//名為 pool 的靜態 LinkedList 儲存需被處理的連線,也就是用LinkedList來模擬一個連線池
  public PooledConnectionHandler() {//建構函式
  }
  public void handleConnection() {//對連線的I/O操作在這裡了
  }
  public static void processRequest(Socket requestToHandle) {//處理客戶連線,將他們加入連線池
  }
  public void run() {//等待有連線來,來了,就調handleConnection()處理
  }
}

可以看出,這個類與多執行緒Socket那一天的ConnectionHandler非常相似,但不同的是,它帶有處理連線池的手段.

首先看看要在監聽程式中用到的processRequest()方法
public static void processRequest(Socket requestToHandle) {
  synchronized (pool) {
  pool.add(pool.size(), requestToHandle);
  pool.notifyAll();
  }
}

這裡的requestToHandle就是要處理的客戶連線socket.可以這樣說,processRequest所做的工作就是把客戶連線加入到連線池當中.但是要確保在對連線池(Pool)進行操作的時候沒有其他的執行緒干擾,就需要獲取連線池的物件鎖,並使用同步塊,前面所瞭解有關synchronized的概念在這裡就可以派上用場了.

那麼，既然已經保證了我們是唯一“涉水”的人，我們就可以把傳入的 Socket 新增到 LinkedList 的尾端.一旦我們新增了新的連線，我們就可以使用pool.notifyall通知其它正在等待該池的 Thread,連線池的物件鎖解除,現在可用了.從另外一個角度來說,也可以說是通知另外一個正在等待的執行緒,一些條件已經具備了.

那麼這個在等待的執行緒是什麼呢?

我們來實現PooledConnectionHandler上的run()方法,它將在連線池上等待,並且池中一有連線就處理它,所以是這個要處理連線的執行緒在等待著呢:

public void run() {
  while (true) {
  synchronized (pool) {
  while (pool.isEmpty()) {
  try {
  pool.wait();
  } catch (InterruptedException e) {return;}
  }
  connection = (Socket) pool.remove(0);//攫取池中的第一個連線,使之成為馬上就要處理的connection
  }
  handleConnection();//然後交給handleConnection處理
  }
}

這個函式告訴了我們每個PooledConnectionHandler執行緒主要都在run些什麼.顯然,它是要不停的去看連線池中有沒有接入的連線,如果有,馬上處理,因此它在等待"連線池有連線了"這樣一個條件.那麼誰來告訴它這個條件滿足了呢,顯然是剛才的processRequest.當processRequest發出通知(pool.notify())的時候,這個條件就滿足了，這時run()中的處理程式就不用再繼續等待了,就可以馬上去出一個連線進行處理.反過來說,在這個條件沒有滿足之前,wait()所在的執行緒還是要處於阻塞狀態，或者是說停滯狀態.由於同樣要對pool進行操作，所以這裡也需要使用到同步塊.

讓我們再次複習一下物件鎖的概念.當 run() 擁有池的互斥鎖時，processRequest() 如何能夠把連線放到池中呢？答案是對池上的 wait() 的呼叫釋放鎖，而 wait() 接著就在自己返回之前再次攫取該鎖。這就使得池物件的其它同步程式碼可以獲取該鎖。

 

最後，我們看看PooledConnectionHandler執行緒中的handleConnection()方法.跟在多執行緒伺服器中不同，我們的PooledConnectionHandler有一個 handleConnection() 方法。這個方法的程式碼跟非池式的,也就是多執行緒伺服器中的ConnectionHandler上的 run() 方法的程式碼完全一樣。首先，我們把 OutputStream 和 InputStream 分別包裝進（用 Socket 上的 getOutputStream() 和 getInputStream()）BufferedReader 和 PrintWriter。然後我們逐行讀目標，就象我們在多執行緒示例中做的那樣。再一次，我們獲取一些位元組之後就把它們放到本地的 line 變數中，然後寫出到客戶機。完成讀寫操作之後，我們關閉 FileReader 和開啟的流。

講到這裡,我們可以看到,程式中有兩個類,PooledRemoteFileServer和PooledConnectionHandler.PooledRemoteFileServer並不直接處理連線請求,它只是負責監聽這些連線,並把他們仍到連線池裡面,至於處理的具體環節,都交給PooledConnectionHandler負責了。

我們的帶有連線池的伺服器研究完了。讓我們回顧一下建立和使用“池版”伺服器的步驟：

1.建立一個新種類的連線處理程式（我們稱之為 PooledConnectionHandler）來處理池中的連線。
2.修改伺服器以建立和使用一組 PooledConnectionHandler。

附:PooledRemoteFileServer.java的原始碼

import java.io.*;
import java.net.*;
import java.util.*;

public class PooledRemoteFileServer {
  protected int maxConnections;
  protected int listenPort;
  protected ServerSocket serverSocket;
  public PooledRemoteFileServer(int aListenPort, int maxConnections) {
  listenPort = aListenPort;
  this.maxConnections = maxConnections;
  }
  public void acceptConnections() {
  try {
  ServerSocket server = new ServerSocket(listenPort, 5);
  Socket incomingConnection = null;
  while (true) {
  incomingConnection = server.accept();
  handleConnection(incomingConnection);
  }
  } catch (BindException e) {
  System.out.println("Unable to bind to port " + listenPort);
  } catch (IOException e) {
  System.out.println("Unable to instantiate a ServerSocket on port: " + listenPort);
  }
  }
  protected void handleConnection(Socket connectionToHandle) {
  PooledConnectionHandler.processRequest(connectionToHandle);
  }
  public static void main(String[] args) {
  PooledRemoteFileServer server = new PooledRemoteFileServer(3000, 3);
  server.setUpHandlers();
  server.acceptConnections();
  }
  public void setUpHandlers() {
  for (int i = 0; i < maxConnections; i++) {
  PooledConnectionHandler currentHandler = new PooledConnectionHandler();
  new Thread(currentHandler, "Handler " + i).start();
  }
  }
}

class PooledConnectionHandler implements Runnable {
  protected Socket connection;
  protected static List pool = new LinkedList();
  public PooledConnectionHandler() {
  }
  public void handleConnection() {
  try {
  PrintWriter streamWriter = new PrintWriter(connection.getOutputStream());
  BufferedReader streamReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));

  String fileToRead = streamReader.readLine();
  BufferedReader fileReader = new BufferedReader(new FileReader(fileToRead));

  String line = null;
  while ((line = fileReader.readLine()) != null)
  streamWriter.println(line);

  fileReader.close();
  streamWriter.close();
  streamReader.close();
  } catch (FileNotFoundException e) {
  System.out.println("Could not find requested file on the server.");
  } catch (IOException e) {
  System.out.println("Error handling a client: " + e);
  }
  }
  public static void processRequest(Socket requestToHandle) {
  synchronized (pool) {
  pool.add(pool.size(), requestToHandle);
  pool.notifyAll();
  }
  }
  public void run() {
  while (true) {
  synchronized (pool) {
  while (pool.isEmpty()) {
  try {
  pool.wait();
  } catch (InterruptedException e) {
  return;
  }
  }
  connection = (Socket) pool.remove(0);
  }
  handleConnection();
  }
  }
}