Java开发服务器的线程怎么处理？

在进行服务器处理的过程中，需要保证数据的正确处理，那么最重要的就是使用不同的数据处理模式进行运算。在整个过程中，可能很多人对服务器的知识并不了解，那么应该如何进行Java开发服务器的线程处理呢，关于线程处理有哪些知识？下面昌平镇北大青鸟为大家介绍关键服务器线程处理的简单知识。

1、BIO线程模型

在JDK14中引入JavaNIO之前，所有基于Java的Socket通信都使用了同步阻塞模式（BIO）。这种请求-响应通信模型简化了上层的应用程序开发上，但在具有性能和可靠性的情况下，存在一个巨大的瓶颈。在一段时间里面，大型应用程序服务器主要是用C或C++开发的，因为它们可以直接使用 *** 作系统提供的异步I/O或AIO功能。

当流量增加且响应时间延迟增加时，JavaBIO开发的服务器软件只能通过硬件的不断扩展来满足并发性和低延迟的情况，这极大地增加了企业的成本和群集大小。系统的不断扩展，系统的可维护性也面临着巨大的挑战，只能通过购买性能更高的硬件服务器来解决问题，这将导致恶性循环的产生。

2、异步非阻塞线程模型

从JDK10到JDK13，Java的I/O类库非常原始。UNIX网络编程中的许多概念或接口未反映在I/O类库中，例如Pipe、Channel、Buffer和Selector等。在发布JDK14的时候，NIO正式发布JDK作为JSR-51。并且它还添加了一个javanio包，为异步I/O开发提供了许多API和库。

3、RPC性能三原则

影响RPC的性能主要有三大元素，其中主要为I/O模型、协议及线程。

I/O模型：使用什么样的通道传递给另一方，BIO，NIO或AIO发送数据，IO模型在很大程度上能够决定框架的性能。

协议：应该使用什么样的通信协议，Rest+JSON或基于TCP的专用二进制协议。参加电脑培训的过程中发现，协议的选择不同，性能模型也不同。内部专用二进制协议的性能通常可以比公共协议更好地设计。

线程：如何读取数据报？在执行读取后的编解码器的哪个线程中，如何分发编码消息，通信线程模型是不同的，并且对性能的影响也非常大。

建议采用缓存处理，按照你说的这种数据量，基于redis的缓存完全可以满足，存取速度可以10W+的，另外，拟采用的hashMap 是ConcurrentHashMap还是其他，页面展示是增量查询还是直接所有的再查询一次，socket数据接收你是用的netty还是mina，这都需要经过仔细的斟酌考虑设计的。有这么大的并发的需求，完全可以考虑做分布式集群的，估计这只是领导想要的目标吧

客服端：
package MyKeFudaun;
import javaioBufferedReader;
import javaioBufferedWriter;
import javaioIOException;
import javaioInputStreamReader;
import javaioOutputStreamWriter;
import javanetSocket;
import javanetUnknownHostException;
public class KeFuDuan {
public static void main(String[] args) {
KeFuDuan kf = new KeFuDuan();
kfstart();
}
public void start(){
Socket sco;
String ss= "";
try {
sco = new Socket("127001",8866);
KeFuduanJie kf = new KeFuduanJie(sco);
KeFuWuFasong kfs = new KeFuWuFasong(sco);
kfstart();
kfsstart();

//scoclose();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
eprintStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
eprintStackTrace();
}
}
}
class KeFuduanJie extends Thread{

Socket soc;
String ss;
BufferedReader br;
public KeFuduanJie(Socket soc){
try {
thissoc = soc;
br = new BufferedReader(new InputStreamReader(socgetInputStream()));

} catch (IOException e) {
eprintStackTrace();
}

}

//负责接受服务端来的信息
public void run(){
while(true){
//接受服务器端来的信息
try {
ss = brreadLine();
Systemoutprintln("服务器---->客服端： "+ss);
} catch (IOException e) {
// TODO Auto-generated catch block
eprintStackTrace();
}
}

}
}
//向服务器发送东西
class KeFuWuFasong extends Thread{

Socket soc;
BufferedWriter bw;
BufferedReader brr;
public KeFuWuFasong(Socket soc){

thissoc = soc;

try {
brr =new BufferedReader(new InputStreamReader(Systemin));
bw = new BufferedWriter(new OutputStreamWriter(socgetOutputStream()));
} catch (IOException e) {
// TODO Auto-generated catch block
eprintStackTrace();
}
}

public void run(){
while(true){
//向服务器发送请求
try {
bwwrite(brrreadLine());
bwnewLine();
bwflush();// 或者用bwclose()
} catch (IOException e) {
// TODO Auto-generated catch block
eprintStackTrace();
}
}
}
}
服务器端：
package MyKeFudaun;
import javaioBufferedReader;
import javaioBufferedWriter;
import javaioIOException;
import javaioInputStreamReader;
import javaioOutputStreamWriter;
import javanetServerSocket;
import javanetSocket;
public class Server {
public static void main(String[] args) {
Server server = new Server();
serverstart();
}

public void start(){

try { //服务器端打开端口
ServerSocket server = new ServerSocket(4499);
Socket socket = null;
ServerToClientThread stct = null;

while(true){
socket = serveraccept(); //迎接（接收）客户端的Socket访问
stct = new ServerToClientThread(socket); //分配一个新线程负责和信赖的Socket沟通
stctstart();
}

} catch (IOException e) {
eprintStackTrace();
}
}
}
package MyKeFudaun;
import javaioBufferedReader;
import javaioIOException;
import javaioInputStreamReader;
import javanetSocket;
public class ServerReceiveFromClient extends Thread{
Socket socket;
BufferedReader br;
String s;

public ServerReceiveFromClient(Socket socket){
thissocket = socket;
try {
br = new BufferedReader(new InputStreamReader(socketgetInputStream()));
} catch (IOException e) {
eprintStackTrace();
}
}

public void run(){

while(true){
try {
s = brreadLine();
Systemoutprintln(socketgetInetAddress()getHostAddress()+"发送了:"+s);

} catch (Exception e) {
eprintStackTrace();
}

}
}
}
package MyKeFudaun;
import javaioBufferedReader;
import javaioBufferedWriter;
import javaioIOException;
import javaioInputStreamReader;
import javaioOutputStreamWriter;
import javanetSocket;
public class ServerToClientThread extends Thread{
Socket socket;
BufferedReader br;
BufferedWriter bw;
String s;

//建立的同时，和客户端的Socket建立输入、输出流
public ServerToClientThread(Socket socket){
thissocket = socket;
try {
bw = new BufferedWriter(new OutputStreamWriter(socketgetOutputStream()));
} catch (IOException e) {
eprintStackTrace();
}

}

public void run(){
ServerReceiveFromClient srfc = new ServerReceiveFromClient(socket);
srfcstart();

while(true){
try {
bwwrite("欢迎光临。");
bwnewLine();
bwflush();
Threadsleep(101000);
} catch (IOException e) {
eprintStackTrace();
} catch (InterruptedException e) {
eprintStackTrace();
}
}
}
}

Tomcat 默认是 150，也就是说同时支持 150 个并发，当然了，也可以将其改大，理论是想多大就多大。
具体能承载多少并发，需要看硬件的配置，CPU 越多性能越高，分配给 JVM 的内存越多性能也就越高，但也会加重 GC 的负担。
当某个应用拥有 250 个以上并发的时候，应考虑应用服务器的集群。
并发和同时在线用户数是不一样的，因为不同的用户 *** 作是有间隔的。如果逻辑复杂，请求执行时间过长，就会占用过多的性能，导致同时在线用户数下降，但是对并发没有影响。
*** 作系统对于进程中的线程数有一定的限制：
Windows 每个进程中的线程数不允许超过 2000；
Linux 每个进程中的线程数不允许超过 1000；
另外，在 Java 中每开启一个线程需要耗用 1MB 的 JVM 内存空间用于作为线程栈之用。

100万并发连接服务器之类的都是噱头，因为一个服务器只有65535个端口，顶多就只能处理6万多个socket连接，>