Java基础(网络编程)

精神病研究院王主任

已于 2024-03-22 16:11:04 修改

阅读量1.6k

点赞数 42

文章标签：网络

于 2024-03-06 17:20:00 首次发布

本文链接：https://blog.csdn.net/shane12396/article/details/136503387

版权

网络编程概述

在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换

网络编程三要素

IP地址

要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。

端口

网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区分这些应用程序呢？如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序了。也就是应用程序的标识。

协议

通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。常见的协议有UDP协议和TCP协议

InetAddress的使用

为了方便我们对IP地址的获取和操作，Java提供了一个类InetAddress供我们使用

InetAddress:此类表示Internet协议(IP)地址

InetAddress addresses =InetAddress.getByName("192.178.1.13");
String hostName=addresses.getHostName();
String address=addresses.getHostAddress();
sout(host);    //jinli
sout(address); //192.178.1.13

端口

端口：设备上应用程序的唯一标识

端口号：用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败

协议

协议：计算机网络中，连接和通信的规则被称为网络通信协议

UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频，视频和普通数据的传输，例如视频会议通常采用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议

TCP协议

TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后在传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过"三次握手"

三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠

第1次握手，客户端向服务器端发出连接请求，等待服务器确认

第2次握手，服务器端向客户端回送一个相应，通知客户端接收到了连接请求

第3次握手，客户端再次向服务器端发送确认信息，确认连接

完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等

UDP通信原理

UDP协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送，接收数据的对象，因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念

Java提供了DatagramSocket类作为基于UDP协议的Socket

UDP发送数据步骤

1.创建发送端的Socket对象(DatagramSocket)

DatagramSocket()

2.创建数据，并把数据打包

DatagramPacket(byte[] buf,int length,InetAddress address,int port)

3.调用DatagramSocket对象的方法发送数据

void send(DatagramPacket p)

4.关闭发送端

void close()

//创建发送端的Socket对象(DatagramSocket)
//DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口
DatagramSocket ds=new DatagramSocket();
//创建数据，并把数据打包
//DatagramPacket(byte[] buf,int length,InetAddress address,int port)
//构造一个数据报，发送长度为length的数据包到指定主机上的指定端口号
byte [] bys="hello我来了".getBytes();
int length=bys.length;
InetAddress address=InetAddress.getByName("192.168.1.11");
int port=10086;
DatagramPacket dp=new DatagramPacket(bys,length,address,port);
//调用DatagramSocket对象的方法发送数据
//void send(DatagramPacket p) 从此套接字发送数据报包
ds.send(dp);
//关闭发送端
//void close() 关闭此数据报套接字
ds.close();

UDP接收数据步骤

接收数据的步骤

1.创建接收端的Socket对象(DatagramSocket)

DatagramSocket(int port)

2.创建一个数据包，用于接收数据

DatagramPacket(byte[] buf,int length)

3.调用DatagramSocket对象的方法接收数据

void receive(DatagramPacket p)

4.解析数据包，并把数据在控制台显示

byte[] getData()

int getLength()

5.关闭接收端

void close()

psvm{
//创建接收端的Socket对象(DatagramSocket)
//DatagramSocket(int port)构造数据报套接字并将其绑定到本地主机上的指定端口
DatagramSocket ds =new DatagramSocket(10086);
//创建一个数据包，用于接收数据
//DatagramPacket(byte[] buf,int length)构造一个DatagramPacket用于接收长度为length数据包
byte[] bys=new byte[1024];
DatagramPacket dp=new DatagramPacket(bys,bys.length);
//调用DatagramSocket对象的方法接收数据
ds.receive(dp);
//解析数据包，并把数据在控制台显示
//byte[] getData()返回数据缓冲区
byte[] datas=dp.getData();
String dataString=new String(datas);
sout("数据是:"+dataString);
//关闭接收端
ds.close();
}

//调用DatagramSocket对象的方法接收数据
ds.receive(dp);
//解析数据包，并把数据在控制台显示
//byte[] getData()返回数据缓冲区
byte[] datas=dp.getData();
//int getLength()返回要发送的数据的长度或接收到的数据的长度
int len =dp.getLength();
String dataString =new String(datas,0,len);
sout("数据是"+dataString);

UDP通信程序练习

UDP发送数据：数据来自于键盘录入，直到输入的数据是886，发送数据结束

UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收

psvm{
   //创建发送端的Socket对象(DatagramSocket)
   DatagramSocket ds =new DatagramSocket();
   //自己封装键盘录入数据
   BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
   String line;
   while((line=br.readLine())!=null)
   {  //输入的数据是886，发送数据结束
      if("886".equals(line)){break;}
      //创建数据，并把数据打包
    byte[] bys=line.getBytes();
    DatagramPacket dp=new DatagramPacket(bys,bys.length,InetAddress.getByName("192.172.11.11")，12345);
     //调用DatagramSocket对象的方法发送数据
    ds.send(dp);
    }
ds.close();
   }

public class ReceiveDemo{
  public static void main(){
  //创建接收端的Socket对象(DatagramSocket)
  DatagramSocket ds =new DatagramSocket(12345);
  while(true){
    //创建一个数据包，用于接收数据
    byte[] bys=new byte[1024];
    DatagramPacket dp=new DatagramPacket(bys,bys.length);
   //调用DatagramSocket对象的方法接收数据
   ds.receive(dp);
   //解析数据包，并把数据在控制台显示
   sout("数据是"+new String(dp.getData(),0,dp.getLength()))
}}}

TCP通信原理

TCP通信协议是一种可靠的网络协议，它在通信的两端各建立一个Socket对象，从而在通信的两端形成网络虚拟链路，一旦建立了虚拟的网络链路，两端的程序就可以通过虚拟链路进行通信

Java对基于TCP协议的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信

java为客户端提供了Socket类，为服务器端提供了ServerSocket类

public class ClientDemo{
  psvm{
     //创建客户端的Socket对象(Socket)
     //Socket(InetAddress address,int port)创建流套接字并将其连接到指定的IP地址的指定端口号
     //SOcket s=new Socket(InetAddress.getByName("192.168.11.16"),1000);
     //Socket(String host,int port)创建流套接字并将其连接到指定主机上的指定端口号
   Socket s=new Socket("192.168.11.16",10000);
  //获取输出流，写数据
  //OutputStream getOutputStream() 返回此套接字的输出流
  OutputStream os =s.getOutputStream();
  os.write("hello,tcp,我来了",getBytes());
  //释放资源
  s.close();
}}

TCP发送数据

发送数据的步骤

1.创建客户端的Socket对象(Socket)

Socket(String host,int port)

2.获取输出流，写数据

OutputStream getOutputStream()

3.释放资源

void close();

TCP接收数据

接收数据的步骤

1.创建服务器端的Socket对象(ServerSocket)

2.获取输入流，读数据，并把数据显示在控制台

3.释放资源

public class ServerDemo{
  psvm{
  //创建服务器端的Socket对象(ServerSocket)
  //ServerSocket (int port)创建绑定到指定端口的服务器套接字
  ServerSocket ss=new ServerSocket(10000);
  //Socket accept() 侦听要连接到此套接字并接受它
  Socket s=ss.accept();
 //获取输入流，读数据，并把数据显示在控制台
InputStream is=s.getInputStream();
byte[] bys=new byte[1024];
int len=is.read(bys);
String data=new String(bys,0,len);
sout("数据是："+data);
//释放资源
s.close();
ss.close();
}}

接收数据的步骤

1. 创建服务器端的Socket对象(ServerSocket)

ServerSocket(int port)

2.监听客户端连接，返回一个Socket对象

Socket accept()

3.获取输入流，读数据，并把数据显示在控制台

InputStream getInputStream()

//服务端：接收到的数据写入文本文件
public class ServerDemo{
   psvm{
     //创建服务器Socket对象
   ServerSocket ss=new ServerSocket(10000);
   //监听客户端连接，返回一个对应的Socket对象
   Socket s=ss.accept();
   //接收数据
   BufferedReader br =new BufferedReader(new InputStreamReader(s.getInputStream()));
   //把数据写入文本文件
   BufferedWriter bw =new BufferedWrite(new FileWriter("myDemo\\Copy.java"));
   String line;
   while((line=br.readLine())!=null){
    bw.write(line);
    bw.newLine();
    bw.flush();
} }
}

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象（Socket）
        Socket s = new Socket("192.168.1.13", 10000);
        //获取输出流，写数据
        OutputStream os = s.getOutputStream();
        os.write("hello，我来了".getBytes());
        //接收服务端反馈
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("客户端" + data);

        //释放资源
        s.close();
    }
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器的Socket对象（ServerSocket）
        ServerSocket ss =new ServerSocket(10000);
        //监听客户端链接，返回一个Socket对象
        Socket s=ss.accept();
        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] byts=new byte[1024];
        int len=is.read(byts);
        String data=new String(byts,0,len);
        System.out.println("服务器："+data);
        //给出反馈
        OutputStream os=s.getOutputStream();
        os.write("数据已经接收到".getBytes());
        //释放资源
        //s.close();
        ss.close();

    }

TCP通信程序练习

public class ServerDemo{
  psvm{
 ServerSocket ss =new ServerSocket(10000);
 Socket accept=ss.accept();
 InputStream is =accept.getInputStream();//读
 int b;
/* while((b=is.read())!=-1){//执行时会在这个循环中死循环
    Sout((char)b);
 }*/读取中文乱码
//用转换流进行转换  把字节流转换程字符流
BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line;
while((line=br.readLine())!=null){
   sout(line);
}
  br.close();
 /* OutputStream os=accept.getOutputStream();//给客户端一个回写数据
  os.write("你谁啊？.getBytes()");*/
BufferedWriter bw =new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
  bw.write("你谁啊");
  bw.newLine();
  bw.flush();
  bw.close();
  is.close();
  accept.close();
  ss.close();
}}

public class ClientDemo{
   psvm{
   Socket socket =new Socket("127.0.0.1",10000);
   OutputStream os =socket.getOutputStream();//写
   os.write("hello".getBytes());
  //读
   socket.shutdownOutput();//仅仅关闭输出流，并写一个结束标记，对socket没有任何影响
   InputStream is=socket.getInputStream();
   int b;
   while((b=is.read())!=-1){
     sout((char)b);
 }
 
     is.close();
     os.close();
     socket.close();
 }}

public class ServerDemo{
  psvm{
  //创建服务器对象Socket
  ServerSocket ss=new ServerSocket(10000);
  //监听客户端的连接，返回对应的Socket对象
  Socket s= ss.accept();
  //获取输入流
  /*InputStream is =s.getInputStream();
    InputStreamReader isr=new InputStreamRead(is);
     BufferedReader br=new BufferedReader(isr);*/
  BufferedReader br =new BufferedReader(new InputStreamReader(s.getInputStream()));
 String line;
  while((line=br.readLine())!=null){
     sout(line);
 }
//释放资源
 ss.close();
}}

public class ClientDemo{
 public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.13", 10000);
        //数据来自于键盘录入，直到输入的数据是886，发送数据结束
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //封装输出流对象
        //s.getOutputStream(),把字节输出流转换为字符流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            if ("886".equals(line)) {
                break;
            }
            //获取输出流对象
            /*OutputStream os = s.getOutputStream();
            os.write(line.getBytes());*/
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        s.close();
  }
}

练习

练习3

客户端：数据来自于键盘录入，直到输入的数据是886，发送数据结束

服务端：接收到的数据写入文本文件

public class ServerDemo{
  psvm{
   //创建服务器Socket对象
   ServerSocket ss =new ServerSocket(10000);
   //监听客户端连接，返回一个对应的Socket对象
   Socket s=ss.accept();
   //接收数据
   BufferedReader br =new BufferedReader(new InputStreamReader(s.getInputStream()));
   //把数据写入文本文件
   BufferedWriter bw =new BufferedWriter(new FileWriter(myDemo\\a.txt));
   String line;
   while((line=br.readLine())!=null){
   bw.write(line);
   bw.newLine();
   bw.flush();
}//释放资源
  bw.close();
  ss.close();}}

练习4

客户端：数据来自于文本文件

服务器：接收到的数据写入文本文件

public class ServerDemo{
  psvm{
    //创建服务器Socket对象
   ServerSocket ss = new ServerSocket(10000);
    //监听客户端连接，返回一个对应的Socket对象
   Socket s=ss.accept();
   //接收数据
   BufferedReader br=new BufferedReader(new InputSreamReader(s.getInputStream()));
   //把数据写入文本文件
   BufferedWriter  bw =new BufferedWriter(new FileWriter("myDemo\\Copy.java"));
   String line ;
   while((line=br.readLine())!=null){
      bw.write(line);
      bw.newLine();
      bw.flush();
   }
   //释放资源
   bw.close();
   ss.close();
  }
}

public class ClinetDemo{
   psvm{
    //创建客户端Socket对象
   Socket s=new Socket("192.168.1.66",10000);
   //封装文本文件的数据
    BufferedReader br =new BufferedReader(new FileReader("MyDemo\\Copy.java"));
   //封装输出流写数据
    BufferedWriter bw=new BufferedWriter(new OutputStreamWrite(s.getOutputStream()));
    String line;
    while((line=br.readLine())!=null){
     bw.write(line);
     bw.newLine();
     bw.flush(); 
   }
//释放资源   
br.close();
s.close();
}}

练习5

客户端：数据来自于文本文件，接收服务器反馈

服务器：接收到的数据写入文本文件，给出反馈

出现问题：程序一直等待

原因：读数据的方法是阻塞式的

解决办法：自定义结束标记；使用shutdownOutput()方法（推荐）

pulic class ServerDemo{
  psvm{
   //创建服务器Socket对象
  ServerSocket ss =new ServerSocket(10000);
   //监听客户端连接，返回一个对应的Socket对象
  Socket s=ss.accept();
  //接收数据
   BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
  //把数据写入文本文件
   BufferedWrite bw=new BufferedWrite(new FileWrite("myDemo\\Copy.java"));
  String line;
  while((line=br.readLine())!=null){//等待读取数据
     /* if("886".equals(line)){
     break;
     }*/

      bw.write(line);
      bw.newLine();
      bw.flush();
 }
   //给出反馈
   BufferedWriter bwServer=new BufferedWriter(new OutputStreamWrite(s.getOutputStream()));
   //释放资源
   bw.close();
   bw.close();
}}

public class ClinetDemo{
   psvm{
   //创建客户端Socket对象
   Socket s=new Socket("192.168.1.77",10000);
   //封装文本文件的数据
   BufferedReader br=new BufferedReader(new FileReader("myDemo\\Copy.java"));
   //封装输出流写数据
   BufferedWriter bw =new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
   String line;
   while((line=br.readLine())!=null){
      bw.write(line);
      bw.newLine();
      bw.flush();
 }
/*自定义结束标记
 bw.write("886");
 bw.newLine();
 bw.flush();*/
 s.shutdownOutput();
//接收反馈
    BufferedReader brClinet=new BufferedReader(new InputStreamReader(s.getInputStream()));
    String data=brClinet.readLine();//等待读取数据
    sout("服务器的反馈："+data);
  //释放资源
   br.close();
   s.close();
}}

练习6

客户端：数据来自于文本文件，接收服务器反馈（和练习5一样）

服务器：接收到的数据写入文本文件，给出反馈，代码用线程进行封装，为每一个客户端开启一个线程

public class ServerDemo{
  psvm{
   //创建服务器Socket对象
  ServerSocket ss=new ServerSocket(10000);
  //监听客户端连接，返回一个对应的Socket对象
  while(true){
  Socket s=ss.accept();
   //为每一个客户端开启一个线程
   new Thread(new ServerThread(s)).start();
 }
ss.close();
  
}}



public class ServerThread implements Runnable{
   private Socket s;
   public ServerThread(Socket s){
    this.s=s;
  }
  @Override
  public void run()
  {
   try{
     //接收数据写到文本文件
     BufferedReader  br =new BufferedReader(new InputStreamReader(s.getInputStream()));
     //BuffereWriter   bw =new BufferedWriter(new FileWriter("myDemo\\Copy.java"));
     //解决冲突问题
     int Count=0;
     File file=new File("myDemo\\Copy["+Count+"].java"));
     while(file.exists())
      { Count++;
        file=new File("myDemo\\Copy["+Count+"].java"));
      }
     BufferedWriter bw=new BufferedWriter(new FileWriter(file));

     String line;
     while((line=br.readLine())!=null){
     bw.write(line);
     bw.newLine();
     bw.flush();

    }
   //给出反馈
    BufferedWrite bwServer=new BufferedWriter(new 
        OutputStreamWriter(s.getOutputStream()));
    bwServer.write("文件上传成功");
    bwServer.newLine();
    bwServer.flush();
    //释放资源
    s.close();
   }catch(IOException e){
      e.printStackTrace();
   }
  }
}

四次挥手

TCP通信程序练习

客户端：将本地文件上传到服务器，接收服务器的反馈

服务器：接收客户端上传的文件，上传完毕之后给出反馈

public class ClientDemo{
   psvm{
  Socket socket=new Socket("127.0.0.1",10000);
  //字节缓冲流读
  //是本地的流，用来读取本地文件的
   BufferedInputStream bis=new BufferedInputStream(new FileInputStream("socketmodle\\ClientDir\\1.jpg"));
   //写到服务器---必须是网络中的流
   OutputStream os=socket.getOutputStream();//是字节流比较慢
   BufferedOutputStream bos=new BufferedOutputStream(os);
   int b;
   while((b=bis.read())!=-1){
      bos.write(b);//通过网络写到服务器中
  }  //给服务器一个结束标记，告诉服务器文件已经传输完毕
   socket.shutdownOutput();
   BufferedReader br =new BufferedReader(new InputStreamReader(socket.getInputStream()));
   String line;
   while((line=br.readLine())!=null){
      sout(line);
  } bis.close();
    socket.close();
}}

public class ServerDemo{
  psvm{
   ServerSocket ss =new ServerSocket(10000);
   while(true){
   Socket accept=ss.accept();//等待客户端连接
   //网络中的流，从客户端读取数据的
   BufferedInputStream bis=new BufferedInputStream(accept.getInputStream());//从网络中读
   //本地的IO流，把数据写到本地中，实现永久化存储
   BufferedOutputStream bos=new BufferedOutputStream(new 
   FileOutputStream("MyDemo\\+UUID.randomUUID().toString()+".jpg));//往外写
   int b;
   while((b=bis.read())!=-1){
       bos.write(b);
   }
  BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
  bw.write("上传成功");
  bw.newLine();
  bw.flush();
  bos.close();
  accept.close();
}
  //ss.close();
 }}

服务端优化

上面代码第一个弊端：服务器只能处理一个客户端请求，接收完一个图片之后，服务器就关闭了

改进方式：循环 while（true）{ }

第二个弊端：第二次上传文件的时候，会把第一次的文件给覆盖

改进方式：UUID.randomUUID()方法生成随机的文件名

第三个弊端：加入循环以后又引发一个问题：

使用循环虽然可以让服务器处理多个客户端请求，但是还是无法同时跟多个客户端进行通信

改进方式：开启多线程处理

UUID类

public class UUIDDemo {
    public static void main(String[] args) {
        UUID uuid=UUID.randomUUID();
        String s=uuid.toString().replace("-","");
        System.out.println(s);
    }
}

public class ServerDemo{
  psvm{
   ServerSocket ss =new ServerSocket(10000);
   while(true){
   Socket accept=ss.accept();//等待客户端连接
   ThreadSocket ts=new ThreadSocket(accept);
   new Thread(ts).start();  
}
  //ss.close();
 }}



public class ThreadSocket implements Runnable{
   private Socket acceptSocket;
   public ThreadSocket(Socket accept)
   { 
     this.acceptSocket=accept;
   }
  BufferedOutputStream bos=null;
  @Override
  try{
  public void run(){
    //网络中的流，从客户端读取数据的
   BufferedInputStream bis=new BufferedInputStream(acceptSocket.getInputStream());//从网络中读
   //本地的IO流，把数据写到本地中，实现永久化存储
   bos=new BufferedOutputStream(new 
   FileOutputStream("MyDemo\\+UUID.randomUUID().toString()+".jpg));//往外写
   int b;
   while((b=bis.read())!=-1){
       bos.write(b);
   }
  BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(acceptSocket.getOutputStream()));
  bw.write("上传成功");
  bw.newLine();
  bw.flush();
   
}catch(IOException e){
     e.printStackTrace();  
}finally{
   if(bos!=null)
  { try{
    bos.close();
  }catch(IOException e){
     e.printStackTrace();
  }
}
    if(acceptSocket!=null)
  { try{
      acceptSocket.close();
  }catch(IOException e){
     e.printStackTrace();
  }}}}

加入多线程以后又引发一个问题：使用多线程虽然可以让服务器同时处理多个客户端请求，但是

资源消耗太大

改进方式：

加入线程池

public class ServerDemo{
  psvm{
   ServerSocket ss=new ServerSocket(10000);
   ThreadPoolExecutor pool =new ThreadPoolExecutor(
   3,//核心线程数量
   10，//线程池的总数量
   60，//临时线程空闲时间
   TimeUnit.SECONDS,//临时线程空闲时间的单位
   new ArrayBlockingQueue<>(5),//阻塞队列
   Executors.defaultThreadFactory(),//创建线程的方式
   new ThreadPoolExecutor.AbortPolicy()//任务拒绝策略
); 
  while(true){
   Socket accept =ss.accept();
   ThreadSocket ts =new ThreadSocket(accept);
   pool.submit(ts);
   
 }}}