ServerSocket 用法

最新推荐文章于 2024-07-13 11:10:41 发布
最新推荐文章于 2024-07-13 11:10:41 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： JAVA 文章标签： 服务器 class socket thread exception
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qqMCY/article/details/18550267
版权

ServerSocket 选项

SO_TIMEOUT:表示等待客户连接的超时时间。

SO_REUSEADDR:表示是否允许重用服务器所绑定的地址。

SO_RCVBUF:表示接收数据的缓冲区的大小。



我们先实现一个简单的服务器

package multithread1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;


public class EchoServer {

	private int port = 8000;
	private ServerSocket serverSocket;

	public EchoServer() throws IOException {

		serverSocket = new ServerSocket(port);
		System.out.println("服务器启动");

	}

	public void service() {
		while (true) {
			Socket socket = null;
			try {
				socket = serverSocket.accept();
				Thread workThread = new Thread(new Handler(socket));
				workThread.start();

			} catch (IOException e) {
				// TODO: handle exception
				e.printStackTrace();

			}
		}
	}
	
	
	public static void main(String args[]) throws IOException {
		new EchoServer().service();
	}

	class Handler implements Runnable {
		private Socket socket;

		public Handler(Socket socket) {
			this.socket = socket;

		}

		private PrintWriter getWriter(Socket socket) throws IOException {
			OutputStream socketOut = socket.getOutputStream();
			return new PrintWriter(socketOut, true);

		}

		private BufferedReader getReader(Socket socket) throws IOException {
			InputStream socketIn = socket.getInputStream();
			return new BufferedReader(new InputStreamReader(socketIn));

		}

		public String echo(String msg) {
			return "echo:" + msg;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub
			try {
				System.out.println("New connection accepted "
						+ socket.getInetAddress() + ":" + socket.getPort());
				BufferedReader br = getReader(socket);
				PrintWriter pw = getWriter(socket);
				String msg = null;
				while ((msg = br.readLine()) != null) {
					System.out.println(msg);
					pw.println(echo(msg));
					if (msg.equals("bye")) 
						break;
				}

			} catch (IOException e) {
				// TODO: handle exception
				e.printStackTrace();
				
			}finally
			{
				try {
					if (socket != null) 
						socket.close();
					
				} catch (IOException e2) {
					// TODO: handle exception
					e2.printStackTrace();
				}
			}

		}

	}
}


多线程的例子

ThreadPoolTester

package multithread1;

public class ThreadPoolTester {

	public static void main(String[] args) {
		
		int num1 = 5;
		int num2 = 3;

		
		
		int numTasks = num1; //Integer.parseInt(args[0]);
		int poolSize = num2; //Integer.parseInt(args[1]);
		
		ThreadPool threadPool = new ThreadPool(poolSize);
		for (int i = 0; i < numTasks; i++) {
			threadPool.execute(createTask(i));
			
		}
		threadPool.join();
		
		
		
	}
	
	private static Runnable createTask(final int taskID) {
		return new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("TASK " + taskID + ":start");
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO: handle exception
					System.out.println("Task " + taskID + ":end");
				}
				
			}
		};
	}
	
}



多线程服务器例子

线程池代码：

ThreadPool

package multithread1;

import java.util.LinkedList;

public class ThreadPool extends ThreadGroup{

	private boolean isClosed = false;  //线程池是否关闭
	private LinkedList<Runnable> workQueue; //表示工作队列
	private static int threadPoolID;        //表示线程池ID
	
	private int threadID;					//表示工作线程ID
	
	
	
	//poolSize 指定线程池中得工作线程数目
	public ThreadPool(int poolSize) {
		super("ThreadPool-" + (threadPoolID++));
		// TODO Auto-generated constructor stub
		setDaemon(true);
		//创建工作队列
		workQueue = new LinkedList<Runnable>();
		for (int i = 0; i < poolSize; i++) {
			new WorkThread().start();   //创建并启动工作线程
			
		}
	}
	
	//向工作队列中加入一个新任务，由工作线程去执行该任务
	public synchronized void execute(Runnable task) {
		if (isClosed) {
			//线程池被关闭则抛出IllegalStateException异常
			throw  new IllegalStateException();
			
		}
		if (task != null) {
			workQueue.add(task);
			//唤醒正在getTask()方法中等待任务的工作线程
			notify();
		}
	}
	
	//从工作队列中取出一个任务，工作线程会调用此方法
	protected synchronized Runnable getTask()throws InterruptedException {
		
		while (workQueue.size() == 0) {
			if (isClosed) {
				return null;
			}
			//如果工作队列中没有任务，就等待任务
			wait();
		}
		return workQueue.removeFirst();
		
	}
	//关闭线程池
	public synchronized void close() {
		if (isClosed) {
			isClosed = true;
			//清空工作队列
			workQueue.clear();
			interrupt();
		}
	}
	
	//等待工作线程把所有任务执行完
	public void join() {
		synchronized (this) {
			isClosed = true;
			
			notifyAll();//唤醒还在getTask()方法中等待任务额工作流程
		}
		
		Thread[] threads = new Thread[activeCount()];
		//enumerate()方法继承自ThreadGroup类，获得线程组中当期所有活着的工作流程
		int count = enumerate(threads);
		//等待所有工作线程运行结束
		for (int i = 0; i < count; i++) {
			try {
				threads[i].join();//等待工作线程运行结束
			} catch (InterruptedException e) {
				// TODO: handle exception
			}
		}
		
	}
	
	
	//内部类：工作线程
	private class WorkThread extends Thread
	{
		public WorkThread () {
			//加入到当前ThreadPool 线程组中
			super(ThreadPool.this,"WorkThread-" + (threadID++));
			
		}
		
		
		@Override
		public void run() {
			// TODO Auto-generated method stub
			super.run();
			while (!isInterrupted()) {
				Runnable task = null;
				try {
					//取出任务
					task = getTask();
					
				} catch (InterruptedException e) {
					// TODO: handle exception
				}
				//如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
				if (task == null) {
					return;
				}
				
				try {//运行任务，异常在catch 代码块中捕获
					task.run();
					
				} catch (Throwable e) {
					// TODO: handle exception
					e.printStackTrace();
					
				}
			}
			
		}
	}
	

	
}


多线程服务器：

EchoServer

package multithread1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;


public class EchoServer {

	private int port = 8000;
	private ServerSocket serverSocket;
	private ThreadPool threadPool;
	private final int POOL_SIZE = 4;
	
	

	public EchoServer() throws IOException {

		serverSocket = new ServerSocket(port);
		/*
		 * 创建线程池
		 * Runtime 的availableProcessors()方法返回当前系统的CPU的数目
		 * 系统的CPU越多，线程池中的工作线程的数目也越多
		 * */
		threadPool = new ThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
		
		System.out.println("服务器启动");

	}

	public void service() {
		while (true) {
			Socket socket = null;
			try {
				socket = serverSocket.accept();
				threadPool.execute(new Handler(socket));
				

			} catch (IOException e) {
				// TODO: handle exception
				e.printStackTrace();

			}
		}
	}
	
	
	public static void main(String args[]) throws IOException {
		new EchoServer().service();
	}

	class Handler implements Runnable {
		private Socket socket;

		public Handler(Socket socket) {
			this.socket = socket;

		}

		private PrintWriter getWriter(Socket socket) throws IOException {
			OutputStream socketOut = socket.getOutputStream();
			return new PrintWriter(socketOut, true);

		}

		private BufferedReader getReader(Socket socket) throws IOException {
			InputStream socketIn = socket.getInputStream();
			return new BufferedReader(new InputStreamReader(socketIn));

		}

		public String echo(String msg) {
			return "echo:" + msg;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub
			try {
				System.out.println("New connection accepted "
						+ socket.getInetAddress() + ":" + socket.getPort());
				BufferedReader br = getReader(socket);
				PrintWriter pw = getWriter(socket);
				String msg = null;
				while ((msg = br.readLine()) != null) {
					System.out.println(msg);
					pw.println(echo(msg));
					if (msg.equals("bye")) 
						break;
				}

			} catch (IOException e) {
				// TODO: handle exception
				e.printStackTrace();
				
			}finally
			{
				try {
					if (socket != null) 
						socket.close();
					
				} catch (IOException e2) {
					// TODO: handle exception
					e2.printStackTrace();
				}
			}

		}

	}
}


使用JDK的线程池

java.util.concurrent 

package multithread1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class EchoServer {

	private int port = 8000;
	private ServerSocket serverSocket;
	private ExecutorService executorService;
	
	private final int POOL_SIZE = 4;
	
	

	public EchoServer() throws IOException {

		serverSocket = new ServerSocket(port);
		/*
		 * 创建线程池
		 * Runtime 的availableProcessors()方法返回当前系统的CPU的数目
		 * 系统的CPU越多，线程池中的工作线程的数目也越多
		 * */
		
		executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
		
		
		System.out.println("服务器启动");

	}

	public void service() {
		while (true) {
			Socket socket = null;
			try {
				socket = serverSocket.accept();
				executorService.execute(new Handler(socket));
			} catch (IOException e) {
				// TODO: handle exception
				e.printStackTrace();

			}
		}
	}
	
	
	public static void main(String args[]) throws IOException {
		new EchoServer().service();
	}

	class Handler implements Runnable {
		private Socket socket;

		public Handler(Socket socket) {
			this.socket = socket;

		}

		private PrintWriter getWriter(Socket socket) throws IOException {
			OutputStream socketOut = socket.getOutputStream();
			return new PrintWriter(socketOut, true);

		}

		private BufferedReader getReader(Socket socket) throws IOException {
			InputStream socketIn = socket.getInputStream();
			return new BufferedReader(new InputStreamReader(socketIn));

		}

		public String echo(String msg) {
			return "echo:" + msg;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub
			try {
				System.out.println("New connection accepted "
						+ socket.getInetAddress() + ":" + socket.getPort());
				BufferedReader br = getReader(socket);
				PrintWriter pw = getWriter(socket);
				String msg = null;
				while ((msg = br.readLine()) != null) {
					System.out.println(msg);
					pw.println(echo(msg));
					if (msg.equals("bye")) 
						break;
				}

			} catch (IOException e) {
				// TODO: handle exception
				e.printStackTrace();
				
			}finally
			{
				try {
					if (socket != null) 
						socket.close();
					
				} catch (IOException e2) {
					// TODO: handle exception
					e2.printStackTrace();
				}
			}

		}

	}
}



防止死锁的代码。

package multithread1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;

public class EchoServer {

	private int port = 8000;
	private ServerSocket serverSocket;
	private ExecutorService executorService;

	private final int POOL_SIZE = 4;

	private int portForShutdown = 8001;
	private ServerSocket serverSocketForShutdown;
	private boolean isShutdown = false;

	private Thread shutdownThread = new Thread() {
		public synchronized void start() {
			this.setDaemon(true);
			super.start();
		};

		public void run() {
			while (!isShutdown) {
				Socket socketForShutdown = null;
				try {
					socketForShutdown = serverSocketForShutdown.accept();
					BufferedReader br = new BufferedReader(
							new InputStreamReader(
									socketForShutdown.getInputStream()));
					String command = br.readLine();
					if (command.equals("shutdown")) {
						long beginTime = System.currentTimeMillis();
						socketForShutdown.getOutputStream().write(
								"服务器正在关闭\r\n".getBytes());
						isShutdown = true;
						// 请求关闭线程池
						// 线程池不再接收新的任务，但是会继续执行完工作队列中现有的任务
						executorService.shutdown();

						// 等待关闭线程池，每次等待的超时时间为30秒
						while (!executorService.isTerminated()) {
							executorService.awaitTermination(30,
									TimeUnit.SECONDS);

						}

						serverSocket.close();

						long endTime = System.currentTimeMillis();
						socketForShutdown
								.getOutputStream()
								.write(("服务器已经关闭" + "用" + (endTime - beginTime) + "毫秒")
										.getBytes());
						socketForShutdown.close();
						serverSocketForShutdown.close();

					} else {
						socketForShutdown.getOutputStream().write(
								"错误的命令\r\n".getBytes());
						socketForShutdown.close();
					}

				} catch (Exception e) {
					// TODO: handle exception
					e.printStackTrace();
				}
			}
		};

	};

	public EchoServer() throws IOException {

		serverSocket = new ServerSocket(port);
		serverSocket.setSoTimeout(60000);
		serverSocketForShutdown = new ServerSocket(portForShutdown);

		/*
		 * 创建线程池 Runtime 的availableProcessors()方法返回当前系统的CPU的数目
		 * 系统的CPU越多，线程池中的工作线程的数目也越多
		 */

		executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
				.availableProcessors() * POOL_SIZE);
		shutdownThread.start();
		System.out.println("服务器启动");

	}

	public void service() {
		while (!isShutdown) {
			Socket socket = null;
			try {
				socket = serverSocket.accept();
				socket.setSoTimeout(60000);
				executorService.execute(new Handler(socket));
				
			} catch (SocketTimeoutException e) {
				// TODO: so exception
				
			}catch (RejectedExecutionException e) {
				// TODO: handle exception
				try {
					if (socket != null) 
						socket.close();
				} catch (IOException e2) {}
				return;
				
			}catch (SocketException e) {
				// TODO: handle exception
				if (e.getMessage().indexOf("socket closed") != -1) return;
			}
			catch (IOException e) {
				// TODO: handle exception
				e.printStackTrace();
				
			}
		}
	}

	public static void main(String args[]) throws IOException {
		new EchoServer().service();
	}

	class Handler implements Runnable {
		private Socket socket;

		public Handler(Socket socket) {
			this.socket = socket;

		}

		private PrintWriter getWriter(Socket socket) throws IOException {
			OutputStream socketOut = socket.getOutputStream();
			return new PrintWriter(socketOut, true);

		}

		private BufferedReader getReader(Socket socket) throws IOException {
			InputStream socketIn = socket.getInputStream();
			return new BufferedReader(new InputStreamReader(socketIn));

		}

		public String echo(String msg) {
			return "echo:" + msg;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub
			try {
				System.out.println("New connection accepted "
						+ socket.getInetAddress() + ":" + socket.getPort());
				BufferedReader br = getReader(socket);
				PrintWriter pw = getWriter(socket);
				String msg = null;
				while ((msg = br.readLine()) != null) {
					System.out.println(msg);
					pw.println(echo(msg));
					if (msg.equals("bye"))
						break;
				}

			} catch (IOException e) {
				// TODO: handle exception
				e.printStackTrace();

			} finally {
				try {
					if (socket != null)
						socket.close();

				} catch (IOException e2) {
					// TODO: handle exception
					e2.printStackTrace();
				}
			}

		}

	}
}


Java网络编程精解之ServerSocket用法详解一
轻轻草原
10-25 1864
第3章 ServerSocket用法详解 第10章 Java语言的反射机制 第13章 基于MVC和RMI的分布 ServerSocket用法详解一 Java语言的反射机制一 基于MVC和RMI的分布式应用一 ServerSocket用法详解二 Java语言的反射机制二 基于M...
ServerSocket 用法详解
11-12
ServerSocket 用法详解(3)
Java的ServerSocket
weixin_63490470的博客
12-29 2097
是 Java 网络编程中的一个核心类，用于实现服务器端的套接字连接。这个类的对象可以绑定到一个特定的端口上，并侦听该端口上的客户端连接请求。当接受一个请求时，它会创建一个新的Socket对象，通过这个Socket，服务器可以与客户端进行通信。以下是使用下面是一个简单的以下是使用。
Java Socket和ServerSocket 使用
u013749113的博客
05-14 3619
在Java中，Socket和ServerSocket是用于创建网络连接的重要类。Socket类用于创建客户端套接字，服务器Socket类用于创建服务器套接字。使用Socket和ServerSocket，我们可以轻松地创建基于TCP或UDP的网络连接，并实现数据传输和通信。在使用Socket和ServerSocket时，我们需要遵循一定的步骤，例如创建套接字、监听连接请求、发送和接收数据，最后关闭套接字。
Java网络编程精解之ServerSocket用法详解
09-02
本文将详细讲解ServerSocket的使用方法及其在多线程环境下的应用。 1. ServerSocket的构造方法 - ServerSocket()：默认构造方法，没有指定端口和连接请求队列长度，可能由系统自动分配端口。 - ServerSocket(int ...
serversocket用法
06-07
使用ServerSocket的accept()方法可以监听客户端的连接请求，并返回与客户端通信的Socket对象，例如： Socket socket = serverSocket.accept(); // 监听客户端连接请求并返回与客户端通信的Socket对象 3. 与客户端...
ServerSocket用法详解
01-03
在这个“ServerSocket用法详解”中，我们将深入探讨如何使用`ServerSocket`来构建服务端应用，并结合`java.util.concurrent`包中的线程池技术，提升服务器的并发处理能力。 首先，让我们了解`ServerSocket`的基本...
ServerSocket的使用
一飞冲天的专栏
06-14 387
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.InetAddress; import java.net.ServerSocket; import java.ne
ServerSocket实现一个简单的Web服务器demo
03-22
ServerSocket实现一个简单的Web服务器demo
三. ServerSocket 用法详解(二)
lin49940的专栏
08-08 4683
 本篇文章观点和例子来自 《Java网络编程精解》， 作者为孙卫琴， 出版社为电子工业出版社。 接上篇 三. ServerSocket 用法详解(一)        在ThreadPool 类中定义了一个LinkedList 类型的 workQueue 成员变量, 它表示工作队列, 用来存放线程池要执行的任务, 每个任务都是 Runnable 实例. ThreadPool 类的客户
Socket 、ServerSocket 常用方法简介
conge
03-02 253
    Socket,ServerSocket 用于TCP/IP协议   (1)Socket:   1.Socket 最常用构造方法: &lt;1&gt;:public Socket(String host,int port); host是连接所需服务器的名称或者ip地址 , port是端口号   2. 最常用的两个方法: &lt;1&gt;:public Output...
Socket & ServerSocket 使用
KawYang的博客
08-18 358
文章目录示例一服务器端客户端文件上传服务器客户端B/S 模式模拟总结SocketServerSocket 示例一 服务器端 // ServerSocket 会等待 客户端发送请求，，一旦接收到请求会创建一个 Socket 与 客户端进行通讯 ServerSocket serverSocket = new ServerSocket(8888); System.out.println("====== ServerStart ====="); // 等待客户端发送请求 Socket socket =
Socket和ServerSocket的使用
tuanjie108的专栏
12-24 1086
Socket和ServerSocket： 所谓socket通常也称作"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。Socket和ServerSocket类库位于java .net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是
Java 中的 ServerSocket类
最新发布
yimeixiaolangzai的博客
07-13 951
类是 Java 网络编程中至关重要的组件。它提供了创建服务器套接字、监听端口、接受客户端连接等基本功能。在实际应用中，通常会结合多线程技术来处理多个客户端连接，以提高服务器的并发能力。通过掌握类的基本使用方法和高级特性，你可以构建出高效、可靠的服务器程序。无论是简单的聊天应用，还是复杂的企业级系统，都是一个不可或缺的工具。希望这篇文章能够帮助你更好地理解和使用类。如果你有任何问题或想法，欢迎在评论区分享！
Java-ServerSocket介绍
架构师之路。。
12-23 1528
Java中的ServerSocket是一种用于建立服务器端socket的类。它允许程序在指定端口上监听客户端的连接请求，并在连接成功后与客户端进行数据交互。ServerSocket类提供了一些方法，用于控制服务器端socket的行为，如绑定端口、监听连接请求、接受连接、关闭连接等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杜甲同学

感谢打赏，我会继续努力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值