多線程文件服務器Java

Question

我正在用Java實現並發文件服務器。

每個客戶端與服務器都有自己的通信通道。 服務器運行一個線程以偵聽所有連接請求，並運行另一個線程以偵聽和應答每個連接。 每個客戶端運行一個用於與服務器通信的線程，另一個運行一個用於偵聽服務器請求（其他客戶端所需的文件）的線程。

客戶

public class Cliente {
 private static String nombre;
 private InetAddress ip;
 private static Socket s;
 private static BufferedReader tCliente;
 private static PrintWriter fCliente;
 private static Usuario usr;
 private static String idCliente;

    public Cliente(){

    }

public static void main(String args[]){
        Cliente c=new Cliente();
        Scanner teclado=new Scanner(System.in);
        System.out.println("What´s your name?");
        nombre=teclado.nextLine();
        //construir cliente
        try {
            s= new Socket("ACER", 999);//¿Cómo obtengo la ip del Servidor?  192.168.1.101
            tCliente=new BufferedReader(new InputStreamReader(s.getInputStream()));
            fCliente=new PrintWriter(s.getOutputStream());
            MensajeConexion mConexion=
                    new MensajeConexion(InetAddress.getLocalHost().getHostName(), "ACER",nombre);
            fCliente.println(nombre);*/
            (new OyenteServidor(s,c)).start();

            while (true){
                System.out.println("Que deseas hacer?");
                System.out.println("1) Mostrar lista usuarios");
                System.out.println("2) Pedir fichero");
                System.out.println("3) Cerrar conexión");   
                int op = teclado.nextInt();
                switch (op) {
                case 1:
                break;
                case 2:
                    System.out.println("Que fichero quieres?");
                    String nombreFichero = teclado.nextLine();
                break;
                case 3:
                    s.close();
                break ;
                default:
                    System.err.println("Opción inválida");
                break;
                }
            }
        } 
        catch (IOException e) {

            e.printStackTrace();
        }


    teclado.close();
}
    public void print(String string) {
        System.out.println(string);
   }
}

服務器

public class Servidor {
private static InetAddress ipServer;
private static final int portServer=999;
private static ServerSocket listen;
private static BufferedReader fServer;
private static PrintWriter tServer;
private static Socket s;
private static Hashtable<String, Usuario> tUsuarios;
private static Hashtable<String, ObjectOutputStream> tCanales ;


public Servidor(){

}
public static void main(String args[]){
    Servidor ser=new Servidor();
    try {
        listen=new ServerSocket(portServer);
        ipServer=listen.getInetAddress();
        while(true){
            s=listen.accept();
            (new OyenteCliente(s,ser)).start();
        }
    } 
    catch (IOException e) {
        e.printStackTrace();
    }
}

public InetAddress getInetAdress(){
    return ipServer;
}

public synchronized void guardaFlujo(Usuario usr, ObjectOutputStream fOut) {
    tCanales.put(usr.getName(), fOut);

}
public synchronized void registra(Usuario usr) {
    tUsuarios.put(usr.getName(), usr);
}
}

偵聽服務器中每個客戶端的線程在名為OyenteCliente（ClientListener）的類中實現，每個客戶端中偵聽服務器Petitios的線程在OyenteServidor（ServerListener）中實現。

ClientListener

public class OyenteCliente extends Thread {
    private Servidor servidor;
    private Socket s;   private ObjectInputStream fIn;
    private ObjectOutputStream fOut;
    private Usuario infoCliente;
    public OyenteCliente(Socket so,Servidor ser) {
       servidor=ser;
       s=so;
       try {
          fIn=new ObjectInputStream(s.getInputStream());//<---Server thread stops here
          fOut=new ObjectOutputStream(s.getOutputStream());
       } 
       catch (IOException e) {
          e.printStackTrace();
       }
    }


   @Override
   public void run() {
       while (true){
           try {
               Mensaje m= (Mensaje) fIn.readObject();
               TipoMensaje type = m.getTipo();
               switch (type) {
               case Conexion:
                   Usuario usr= new Usuario(((MensajeConexion) m).getUserName());
                servidor.registra(usr);
                servidor.guardaFlujo(usr,fOut);
                MensajeConfirmacion confirmacion = new MensajeConfirmacion(m.getDestino(),m.getOrigen());
                fOut.writeObject(confirmacion);
               break;
               case ListaUsuarios:
                /*
                 * -buscar info en tUsuarios
                 * -mandar msge conf lista usuarios
                 * */
               break;
               case EmitirFichero:
                /*
                 * -obtener info usuario que tiene fichero
                 * -mandar mensaje peticion fichero
                 * 
                 * */
               break;
               case PrepComCS:
                /*
                 * mandar mensaje preparar comunicacion SC
                 * */
               break;
               default:
                   System.err.println(m);
               break;
               }    
           }  
           catch (ClassNotFoundException e) {
               e.printStackTrace();
           }
           catch (IOException e) {  
               e.printStackTrace();
           }
       }
   }
}

服務器監聽器

public class OyenteServidor extends Thread{
private Socket myS;
private ObjectInputStream fIn;
private ObjectOutputStream fOut;
private Cliente client;

public OyenteServidor(Socket s,Cliente clie) {
    client=clie;
    try {
        myS=s;
        fIn=new ObjectInputStream(myS.getInputStream());//<---Client thread stops here
        fOut=new ObjectOutputStream(myS.getOutputStream());
    } 
    catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
@Override
public void run(){
    while (true){
        try {
            Mensaje m = (Mensaje) fIn.readObject();
            TipoMensaje type=m.getTipo();
            switch (type) {
            case ConfConexion:
                client.print("Conexión confirmada");
            break;
            case ConfListaUsuarios:
            break;
            case PetFichero:
            break;
            case PrepComCS:
            break;
            default:
            break;
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

我必須通過傳遞消息（“ ConectionRequest”，“ FileRequest” ..）來實現通信，因此當我創建每個Socket時，我會嘗試在每個偵聽器中使用ObjectInputStream和ObjectOutputStream。

調試（Cliente和Servidor）我剛剛發現，當兩個進程使用Socket.getInputStream（）初始化ObjectInputStream時，它們都會永遠暫停。

誰能告訴我我怎么了？

非常感謝你！

Answer 1

您需要在ObjectInputStream之前構造ObjectOutputStream 。

您還需要在兩端構造相同的流。 您當前的流混合將無法正常工作。

如果希望與多個線程一起使用，則還需要從整體上刪除關鍵字static 。

Answer 2

感謝您的兩個答案。 足以讓我繼續我的項目。 那就是我解決的方式。 我將我的解決方案分享給任何有興趣或想教我其他知識的人。

ClientListener：

public class OyenteCliente extends Thread {
private Servidor servidor;
private Socket s;   
private ObjectInputStream fIn;
private ObjectOutputStream fOut;
public OyenteCliente(Socket so,Servidor ser) {
    servidor=ser;
    s=so;
    try {
        fOut=new ObjectOutputStream(s.getOutputStream());
        fIn=new ObjectInputStream(s.getInputStream());
    } 
    catch (IOException e) {
        e.printStackTrace();
    }
}


@Override
public void run() {
    while (true){
        try {
            Mensaje m= (Mensaje) fIn.readObject();
            TipoMensaje type = m.getTipo();
            switch (type) {
            case Conexion:
                Usuario usr= new Usuario(((MensajeConexion) m).getUserName());
                //-Guardar en tUsuarios info nuevo usuario
                servidor.registra(usr);
                /* -Guardar en tCanales flujo de comunicacion   * */
                servidor.guardaFlujo(usr,fOut);
                MensajeConfirmacion confirmacion = new MensajeConfirmacion(m.getDestino(),m.getOrigen());
                fOut.writeObject(confirmacion);
            break;
            case ListaUsuarios:
                /*
                 * -buscar info en tUsuarios
                 * -mandar msge conf lista usuarios
                 * */
            break;
            case EmitirFichero:
                /*
                 * -obtener info usuario que tiene fichero
                 * -mandar mensaje peticion fichero
                 * 
                 * */
            break;
            case PrepComCS:
                /*
                 * mandar mensaje preparar comunicacion SC
                 * */
            break;
            default:
                System.err.println(m);
            break;
            }   
        } 
        catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        catch (IOException e) { 
            e.printStackTrace();
        }
    }
}

}

ServerListener：

public class OyenteServidor extends Thread{
private Socket myS;
private ObjectInputStream fIn;
private ObjectOutputStream fOut;
private Cliente client;

public OyenteServidor(Socket s,Cliente clie) {
    client=clie;
    myS=s;
    try {
        fOut=new ObjectOutputStream(myS.getOutputStream());
        fIn=new ObjectInputStream(myS.getInputStream());
        fOut.writeObject(new MensajeConexion(clie.getIp(), 
                myS.getInetAddress().getHostAddress(), client.getName()));
    } 
    catch (IOException e) {
        e.printStackTrace();
    }
}
@Override
public void run(){
    while (true){
        try {
            Mensaje m = (Mensaje) fIn.readObject();
            TipoMensaje type=m.getTipo();
            switch (type) {
            case ConfConexion:
                client.print("Conexión confirmada");
            break;
            case ConfListaUsuarios:
            break;
            case PetFichero:
            break;
            case PrepComCS:
            break;
            default:
            break;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 }
}

Answer 3

發生這種情況是因為ObjectInputStream的ctor阻塞了。 看一下docs 。 也許您應該使用另一個Inputstream，例如BufferedInputStream 。