线程池server

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


public class Server
{
//服务器端口
    private static final int SERVERPORT = 54321; 
    //客户端连接
    private static List<Socket> mClientList = new ArrayList<Socket>(); 
    //线程池
    private ExecutorService mExecutorService;  
    //ServerSocket对象
    private ServerSocket mServerSocket;  
    //开启服务器
    public static void main(String[] args)
{
new Server();
}
public Server()
{
try
{
//设置服务器端口
mServerSocket = new ServerSocket(SERVERPORT);
//创建一个线程池
mExecutorService = Executors.newCachedThreadPool();
System.out.println("start...");
//用来临时保存客户端连接的Socket对象
Socket client = null;
while (true)
{
//接收客户连接并添加到list中
client = mServerSocket.accept(); 
mClientList.add(client);
//开启一个客户端线程
mExecutorService.execute(new ThreadServer(client));
}
}
catch (IOException e)
{
e.printStackTrace();
}
}   
    //每个客户端单独开启一个线程
static class ThreadServer implements Runnable
{
private Socket mSocket;
private BufferedReader mBufferedReader;
private PrintWriter mPrintWriter;
private String mStrMSG;


public ThreadServer(Socket socket) throws IOException
{
this.mSocket = socket;
mBufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
mStrMSG = "user:"+this.mSocket.getInetAddress()+" come total:" + mClientList.size();
sendMessage();
}
public void run()
{
try
{
while ((mStrMSG = mBufferedReader.readLine()) != null)
{
if (mStrMSG.trim().equals("exit"))
{
//当一个客户端退出时
mClientList.remove(mSocket);
mBufferedReader.close();
mPrintWriter.close();
mStrMSG = "user:"+this.mSocket.getInetAddress()+" exit total:" + mClientList.size();
mSocket.close();
sendMessage();
break;
}
else
{
mStrMSG = mSocket.getInetAddress() + ":" + mStrMSG;
sendMessage();
}
}
}
catch (IOException e)
{
e.printStackTrace();
}
}
//发送消息给所有客户端
private void sendMessage() throws IOException
{
System.out.println(mStrMSG);
for (Socket client : mClientList)
{
mPrintWriter = new PrintWriter(client.getOutputStream(), true);
mPrintWriter.println(mStrMSG);
}
}
}
}
这个是完整源码 python实现 Django 【python毕业设计】基于Python的天气预报(天气预测分析)(Django+sklearn机器学习+selenium爬虫)可视化系统.zip 源码+论文+sql脚本 完整版 数据库是mysql 本研究旨在开发一个基于Python的天气预报可视化系统,该系统结合了Django框架、sklearn机器学习库和Selenium爬虫技术,实现对天气数据的收集、分析和可视化。首先,我们使用Selenium爬虫技术从多个天气数据网站实时抓取气象数据,包括温度、湿度、气压、风速等多项指标。这些数据经过清洗和预处理后本研究旨在开发一个基于Python的天气预报可视化系统,该系统结合了Django框架、sklearn机器学习库和Selenium爬虫技术,实现对天气数据的收集、分析和可视化。首先,我们使用Selenium爬虫技术从多个天气数据网站实时抓取气象数据,包括温度、湿度、气压、风速等多项指标。这些数据经过清洗和预处理后,将其存储在后端数据库中,以供后续分析。 其次,采用s,将其存储在后端数据库中,以供后续分析。 其次,采用sklearn机器学习库构建预测模型,通过时间序列分析和回归方法,对未来天气情况进行预测。我们利用以往的数据训练模型,以提高预测的准确性。通过交叉验证和超参数优化等技术手段,我们优化了模型性能,确保其在实际应用中的有效性和可靠性。 最后,基于Django框架开发前端展示系统,实现天气预报的可视化。用户可以通过友好的界面查询实时天气信息和未来几天内的天气预测。系统还提供多种图表类型,包括折线图和柱状图,帮助用户直观理解天气变化趋势。 本研究的成果为天气预报领域提供了一种新的技术解决方案,不仅增强了数据获取和处理的效率,还提升了用户体验。未来,该系统能够扩展至其他气象相关的应用场景,为大众提供更加准确和及时的气象服务。
### Spring Boot 中基于线程池Server Socket NIO 和 BIO 实现 在 Spring Boot 应用程序中,可以通过配置线程池来管理服务器端套接字(Server Socket)的操作模式。以下是关于如何实现阻塞 I/O(BIO)和非阻塞 I/O(NIO)的方式及其对比。 #### 阻塞 I/O (BIO) 的实现 对于传统的 BIO 方式,每个客户端请求都需要分配一个新的线程来进行处理。这通常通过 `java.net.ServerSocket` 来完成,并结合 Spring 提供的任务执行器(Task Executor)。以下是一个简单的例子: ```java import org.springframework.scheduling.annotation.EnableAsync; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.io.*; import java.net.ServerSocket; import java.net.Socket; @Configuration @EnableAsync public class BioConfig { @Bean public Thread taskExecutor() { return new Thread(() -> { try (ServerSocket serverSocket = new ServerSocket(8080)) { while (true) { Socket clientSocket = serverSocket.accept(); handleClient(clientSocket); } } catch (IOException e) { throw new RuntimeException(e); } }); } private void handleClient(Socket socket) { new Thread(() -> { try ( BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); PrintWriter out = new PrintWriter(socket.getOutputStream(), true) ) { String inputLine; while ((inputLine = in.readLine()) != null) { System.out.println("Received: " + inputLine); out.println("Echo: " + inputLine); } } catch (IOException e) { throw new RuntimeException(e); } }).start(); } } ``` 上述代码展示了如何使用多线程模型来支持多个客户端连接[^1]。需要注意的是,在高并发场景下,这种方案可能会导致大量的线程开销以及资源浪费。 --- #### 非阻塞 I/O (NIO) 的实现 相比之下,NIO 使用单个或少量线程即可高效地处理大量并发连接。它依赖于 Java 的 `Selector` 类机制,允许在一个线程上监听多个通道的状态变化。下面提供了一个基本示例: ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Iterator; import java.util.Set; @Configuration public class NioConfig { @Bean public Thread nioServerThread() throws IOException { return new Thread(() -> { try (ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); Selector selector = Selector.open() ) { serverSocketChannel.bind(null /* Bind address */ ); serverSocketChannel.configureBlocking(false); serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); while (true) { int readyChannels = selector.select(); if (readyChannels == 0) continue; Set<SelectionKey> selectedKeys = selector.selectedKeys(); Iterator<SelectionKey> keyIterator = selectedKeys.iterator(); while (keyIterator.hasNext()) { SelectionKey key = keyIterator.next(); if (key.isAcceptable()) { acceptConnection(serverSocketChannel, selector); } if (key.isReadable()) { readData(key); } keyIterator.remove(); } } } catch (Exception ex) { throw new RuntimeException(ex); } }); } private void acceptConnection(ServerSocketChannel serverSocketChannel, Selector selector) throws IOException { SocketChannel client = serverSocketChannel.accept(); client.configureBlocking(false); client.register(selector, SelectionKey.OP_READ); } private void readData(SelectionKey key) throws IOException { SocketChannel channel = (SocketChannel) key.channel(); ByteBuffer buffer = ByteBuffer.allocate(1024); int bytesRead = channel.read(buffer); if (bytesRead > 0) { buffer.flip(); byte[] data = new byte[buffer.remaining()]; buffer.get(data); System.out.println("Message received: " + new String(data)); } } } ``` 此方法利用了 NIO 的特性,能够显著减少线程数量并提高系统的吞吐量[^2]。 --- #### 性能比较与适用场景分析 - **BIO** 更适合低并发的应用环境,因为它易于理解和维护。然而,在面对大规模并发访问时,其性能瓶颈明显。 - **NIO** 则更适合高负载的服务端应用开发,尽管其实现复杂度较高,但它提供了更优的时间效率和空间利用率。 为了进一步优化这两种方式下的表现,还可以引入诸如 Netty 这样的框架或者调整底层参数如缓冲区大小 (`SO_RCVBUF`) 等设置[^3][^4]。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值