TCP可以用多线程实现吗？具体应该怎么实现？
这是我的代码！运行不了~~

import java.net.*;
import java.io.*;
public class SocketDemo1 {
        public static void main(String[] args) throws Exception {
                Socket s = new Socket("192.168.1.1",10011);
                ServerSocket ss = new ServerSocket(10011);
               
                new Thread(new TcpServer(ss)).start();
                new Thread(new TcpSocket(s)).start();
        }
}

class TcpSocket implements Runnable{
        private Socket s;
        TcpSocket(Socket s){
                this.s = s;
        }
        public void run(){
                OutputStream out;
                try {
                        s.wait(80);----------------------------------------尝试用wait让服务端先开启也不行！
                        out = s.getOutputStream();
                        out.write("我来了".getBytes());
                        InputStream in = s.getInputStream();
                        byte[]buf = new byte[1024];
                        int len = in.read(buf);
                        System.out.println(new String(buf,0,len));
                        s.close();
                } catch (IOException e) {
                        throw new RuntimeException();
                } catch (InterruptedException e) {--------------------------catch  wait的异常
                        e.printStackTrace();
                }        
        }
}

class TcpServer implements Runnable{
        private ServerSocket ss;
        TcpServer(ServerSocket ss){
                this.ss = ss;
        }
        public void run(){
                Socket s;
                try {
                        s = ss.accept();
                        String ip = s.getInetAddress().getHostAddress();
                        InputStream in = s.getInputStream();
                        byte[] buf = new byte[1024];
                        int len = in.read(buf);
                        System.out.println(ip+"````"+new String(buf,0,len));
                        OutputStream out = s.getOutputStream();
                        out.write("收到了".getBytes());
                        ss.close();
                } catch (IOException e) {
                        throw new RuntimeException();
                }
        }
}

  public void run(){
                 Socket s;
                 try {
                         s = ss.accept();
                         String ip = s.getInetAddress().getHostAddress();
                         InputStream in = s.getInputStream();//线程执行到这儿时候就等待客户端的输出流
                         byte[] buf = new byte[1024];
                         int len = in.read(buf);
                         System.out.println(ip+"````"+new String(buf,0,len));
                         OutputStream out = s.getOutputStream();
                         out.write("收到了".getBytes());
                         ss.close();
                 } catch (IOException e) {
                         throw new RuntimeException();
                 }

s.wait(80);----------------------------------------尝试用wait让服务端先开启也不行！
          wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
当前线程必须拥有此对象监视器//这个需要唤醒，你可以试试sleep（）

还有建议您看看毕老师的24天的视频，那里面讲tcp多线程很详细。

1. import java.net.*;
   
2. import java.io.*;
   
3. public class TcpTest {
   
4.                  public static void main(String[] args) throws Exception {
   
5.                      ServerSocket ss = new ServerSocket(10011);//必须让ServerSocket先定义，然后才能监视10011端口，当有数据传到该端口时，ServerSocket就能连接上
   
6.                                  Socket s = new Socket("127.0.0.1",10011);//
   
7.                         new Thread(new TcpServers(ss)).start();
   
8.                          new Thread(new TcpSocket(s)).start();
   
9.                  }
   
10.          }
    
11.          
    
12.         class TcpSocket implements Runnable{
    
13.                  private Socket s;
    
14.                  TcpSocket(Socket s){
    
15.                          this.s = s;
    
16.                  }
    
17.                  public void run(){
    
18.                          OutputStream out;
    
19.                          try
    
20.                          {
    
21.                                 // s.wait(80);//----------------------------------------尝试用wait让服务端先开启也不行！
    
22. //调用wait()之后，还需要notify()或notifyAll()唤醒，在synchronized语句内使用，用于让线程等待并让出锁！
    
23.                                  out = s.getOutputStream();
    
24.                                  out.write("我来了".getBytes());
    
25.                                  InputStream in = s.getInputStream();
    
26.                                  byte[]buf = new byte[1024];
    
27.                                  int len = in.read(buf);
    
28.                                  System.out.println(new String(buf,0,len));
    
29.                                  s.close();
    
30.                          } catch (IOException e) {
    
31.                                  throw new RuntimeException();
    
32.                          }
    
33. //                         catch (InterruptedException e) //--------------------------catch  wait的异常
    
34. //                         {
    
35. //                                 e.printStackTrace();
    
36. //                         }        
    
37.                  }
    
38.          }
    
39.          
    
40.         class TcpServers implements Runnable{
    
41.                  private ServerSocket ss;
    
42.                  private Socket s;
    
43.                  TcpServers(ServerSocket ss){
    
44.                          this.ss = ss;
    
45.                  }
    
46.                  public void run(){
    
47.                        //  Socket s;
    
48.                          try {
    
49.                                  s = ss.accept();
    
50.                                  String ip = s.getInetAddress().getHostAddress();
    
51.                                  InputStream in = s.getInputStream();
    
52.                                  byte[] buf = new byte[1024];
    
53.                                  int len = in.read(buf);
    
54.                                  System.out.println(ip+"````"+new String(buf,0,len));
    
55.                                  OutputStream out = s.getOutputStream();
    
56.                                  out.write("收到了".getBytes());
    
57.                                  ss.close();
    
58.                          } catch (IOException e) {
    
59.                                  throw new RuntimeException();
    
60.                          }
    
61.                  }
    
62.          }

复制代码

首先,我说下个人理解,就是一个服务器可以同时和多个客户端进行数据的交互,注意,只有一个服务器.
服务端实现多线线程的方式,将进行数据交互部分进行单独封装,放在一个实现了Runnable接口的类的run()中;

我认为你的代码中有问题的部分:
Socket s = new Socket("192.168.1.1",10011);
                ServerSocket ss = new ServerSocket(10011);
               
                new Thread(new TcpServer(ss)).start();//我觉得是一个服务器中有多个线程,帮它处理与客户端的数据交互,线程应该是包含在服务器中的.你这样写,我觉得怪怪的,但也说不清楚到底哪里不好,


下面是我改动后的代码:
import java.net.*;
import java.io.*;
public class SocketDemo2 {
         public static void main(String[] args) throws Exception
        {                        
              Socket s = new Socket("192.168.1.111",10011);
              Socket s2 = new Socket("192.168.1.111",10011);
              Socket s3 = new Socket("192.168.1.111",10011);

              new Thread(new Client(s)).start();//-------多个客户端访问服务器
              new Thread(new Client(s2)).start();
              new Thread(new Client(s3)).start();   
         }
}
class Client implements Runnable//定义客户端,这部分我没有改动,就是你的TcpSocket部分
{
         private Socket s;
         Client(Socket s)
        {
                this.s = s;
        }
        public void run()
        {
               try
              {
                        Thread.sleep(80);  //----------------------------------------尝试用wait让服务端先开启也不行！
                        OutputStream out = s.getOutputStream();
                        out.write("我来了".getBytes());
                        InputStream in = s.getInputStream();
                        byte[]buf = new byte[1024];
                        int len = in.read(buf);
                        System.out.println(new String(buf,0,len));
                        s.close();
              }
              catch (IOException e)
              {
                       throw new RuntimeException();
              }
             catch (InterruptedException e)
             {//--------------------------catch  wait的异常
                       e.printStackTrace();
             }
       }
}
class TcpServer
{
            public static void main(String[] args)throws Exception
           {
                  show();
           }
           public static void show()throws Exception
           {
                   ServerSocket ss = new ServerSocket(10011);   //--------创建好一个服务器
                   while (true)
                   {
                                                 //----每有一个客户端来访问,就会创建一个线程与其进行数据交互,
                             Socket s=ss.accept();
                             new Thread(new TcpThread(s)).start();                    
                   }
           }
}
class  TcpThread implements Runnable//------将服务器中的数据交互部分进行封装
{
         private Socket s;
         TcpThread(Socket s)
         {
                 this.s=s;
         }
         public void run()
         {
                  String ip=s.getInetAddress().getHostAddress();
                   try
                   {   
                           System.out.println(ip+"...connected");
                           InputStream in = s.getInputStream();
                           byte[] buf = new byte[1024];
                           int len = in.read(buf);
                           System.out.println(ip+"````"+new String(buf,0,len));
                           OutputStream out = s.getOutputStream();
                           out.write("收到了".getBytes());
                           s.close();
                  }
                  catch (Exception e)
                  {
                           throw new RuntimeException();
                   }
         }
}
这样改动后,我试了是有用的,



注:我用的是命令行,编译可以在一起,运行是在两个命令行页面上进行的,先"java TcpServer",再到另一个页面上"java SocketDemo2",
还有将IP改下,我用的是我自己的

不知道我这样理解是不是对的,如果要是错了,烦请楼主回复,提醒我,谢谢!