java socket编程收藏之四(线程池)

最新推荐文章于 2024-05-28 21:42:23 发布

iteye_17600

最新推荐文章于 2024-05-28 21:42:23 发布

阅读量84

点赞数

分类专栏： Socket通讯文章标签：编程 Socket Java thread .net

本文链接：https://blog.csdn.net/iteye_17600/article/details/81885239

版权

Socket通讯专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1)Server端

Java代码

import java.io.*;
import java.net.*;
public class PooledRemoteFileServer {
//服务器能同时处理的活动客户机连接的最大数目
protected int maxConnections;
//进入的连接的侦听端口
protected int listenPort;
//将接受客户机连接请求的 ServerSocket
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("");
}
catch(IOException e) {
System.out.println(""+listenPort);
}
}
/**
* 委派PooledConnectionHandler处理连接
*/
protected void handleConnection(Socket connectionToHandle) {
PooledConnectionHandler.processRequest(connectionToHandle);
}
/**
* 创建maxConnections个PooledConnectionHandler并在新Thread中激活它们。
* PooledConnectionHandler将等着处理进入的连接，每个都在它自己的Thread中进行。
*/
public void setUpHandlers() {
for(int i=0; i<maxConnections; i++) {
PooledConnectionHandler currentHandler = new PooledConnectionHandler();
new Thread(currentHandler, "Handler " + i).start();
}
}
public static void main(String args[]) {
PooledRemoteFileServer server = new PooledRemoteFileServer(1001, 3);
server.setUpHandlers();
server.acceptConnections();
}
}

import java.io.*;
import java.net.*;
public class PooledRemoteFileServer {
   //服务器能同时处理的活动客户机连接的最大数目
    protected int maxConnections;
   //进入的连接的侦听端口
    protected int listenPort;
    //将接受客户机连接请求的 ServerSocket 
    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("");
        }
        catch(IOException e) {
            System.out.println(""+listenPort);
        }
    }
    
    /**
     * 委派PooledConnectionHandler处理连接
     */
    protected void handleConnection(Socket connectionToHandle) {
        PooledConnectionHandler.processRequest(connectionToHandle);
    }
    
    /**
     * 创建maxConnections个PooledConnectionHandler并在新Thread中激活它们。
     * PooledConnectionHandler将等着处理进入的连接，每个都在它自己的Thread中进行。
     */
    public void setUpHandlers() {
        for(int i=0; i<maxConnections; i++) {
            PooledConnectionHandler currentHandler = new PooledConnectionHandler();
            new Thread(currentHandler, "Handler " + i).start();
        }
    }
    public static void main(String args[]) {
        PooledRemoteFileServer server = new PooledRemoteFileServer(1001, 3);
        server.setUpHandlers(); 
        server.acceptConnections();
    }
}

(2)实现线程池的类

Java代码

import java.io.*;
import java.net.*;
import java.util.*;
public class PooledConnectionHandler implements Runnable {
//connection是当前正在处理的 Socket
protected Socket connection;
//静态 LinkedList 保存需被处理的连接,工作队列
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("");
}
catch(IOException e) {
System.out.println(""+e);
}
}
/**
* 将把传入请求添加到池中，并告诉其它正在等待的对象该池已经有一些内容
* @param requestToHandle
*/
@SuppressWarnings("unchecked")
public static void processRequest(Socket requestToHandle) {
//确保没有别人能跟我们同时修改连接池
synchronized(pool) {
//把传入的Socket添加到LinkedList的尾端
pool.add(pool.size(), requestToHandle);
//通知其它正在等待该池的Thread，池现在已经可用
pool.notifyAll();
}
}
public void run() {
while(true) {
synchronized(pool) {
while(pool.isEmpty()) {
try {
//对池上的wait()的调用释放锁，而wait()接着就在自己返回之前再次攫取该锁
pool.wait();//在连接池上等待，并且池中一有连接就处理它
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
//恰巧碰上非空池的处理程序将跳出while(pool.isEmpty())循环并攫取池中的第一个连接
connection= (Socket)pool.remove(0);
}
handleConnection();
}
}
}

import java.io.*;
import java.net.*;
import java.util.*;
public class PooledConnectionHandler implements Runnable {
    //connection是当前正在处理的 Socket 
	protected Socket connection;
	//静态 LinkedList 保存需被处理的连接,工作队列
    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("");
        }
        catch(IOException e) {
            System.out.println(""+e);
        }
    }
	/**
	 * 将把传入请求添加到池中，并告诉其它正在等待的对象该池已经有一些内容
	 * @param requestToHandle
	 */	
    @SuppressWarnings("unchecked")
	public static void processRequest(Socket requestToHandle) {
    	//确保没有别人能跟我们同时修改连接池
        synchronized(pool) {
        	//把传入的Socket添加到LinkedList的尾端
            pool.add(pool.size(), requestToHandle);
            //通知其它正在等待该池的Thread，池现在已经可用
            pool.notifyAll();
        }
    }
    public void run() {
        while(true) {
            synchronized(pool) {
                while(pool.isEmpty()) {
                    try {
                    	//对池上的wait()的调用释放锁，而wait()接着就在自己返回之前再次攫取该锁
                        pool.wait();//在连接池上等待，并且池中一有连接就处理它
                    }
                    catch(InterruptedException e) {
                        e.printStackTrace(); 
                    }
                }
                //恰巧碰上非空池的处理程序将跳出while(pool.isEmpty())循环并攫取池中的第一个连接
                connection= (Socket)pool.remove(0); 
            }
            handleConnection();
        }
    }
}

(3)Client端

Java代码

import java.io.*;
import java.net.*;
/**
* 用您想连接的机器的 IP 地址和端口实例化 Socket。
* 获取 Socket 上的流以进行读写。
* 把流包装进 BufferedReader/PrintWriter 的实例，如果这样做能使事情更简单的话。
* 对 Socket 进行读写。
* 关闭打开的流。
* @author Administrator
*/
public class RemoteFileClient {
protected BufferedReader socketReader;
protected PrintWriter socketWriter;
protected String hostIp;
protected int hostPort;
/**
* 构造方法
*/
public RemoteFileClient(String hostIp, int hostPort) {
this.hostIp = hostIp;
this.hostPort=hostPort;
}
/**
* 向服务器请求文件的内容,告诉服务器我们想要什么文件并在服务器传回其内容时接收该内容
*/
public String getFile(String fileNameToGet) {
StringBuffer fileLines = new StringBuffer();
try {
socketWriter.println(fileNameToGet);
socketWriter.flush();
String line = null;
while((line=socketReader.readLine())!=null)
fileLines.append(line+"\n");
}
catch(IOException e) {
System.out.println("Error reading from file: "+fileNameToGet);
}
return fileLines.toString();
}
/**
* 连接到远程服务器,创建我们的 Socket 并让我们访问该套接字的流
*/
public void setUpConnection() {
try {
Socket client = new Socket(hostIp,hostPort);
socketReader = new BufferedReader(new InputStreamReader(client.getInputStream()));
socketWriter = new PrintWriter(client.getOutputStream());
}
catch(UnknownHostException e) {
System.out.println("Error1 setting up socket connection: unknown host at "+hostIp+":"+hostPort);
}
catch(IOException e) {
System.out.println("Error2 setting up socket connection: "+e);
}
}
/**
* 使用完毕连接后负责“清除”。
*/
public void tearDownConnection() {
try {
socketWriter.close();
socketReader.close();
}catch(IOException e) {
System.out.println("Error tearing down socket connection: "+e);
}
}
public static void main(String args[]) {
RemoteFileClient remoteFileClient = new RemoteFileClient("127.0.0.1",1001);
remoteFileClient.setUpConnection();
StringBuffer fileContents = new StringBuffer();
fileContents.append(remoteFileClient.getFile("D:/test.txt"));
//remoteFileClient.tearDownConnection();
System.out.println(fileContents);
}
}

iteye_17600

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java socket编程收藏之四(线程池)

1)Server端Java代码 import java.io.*; import java.net.*; public class PooledRemoteFileServer { //服务器能同时处理的活动客户机连接的最大数目 protected int maxConnections; //进入...
复制链接

扫一扫