Java-OutofMemory客户机/服务器应用程序

我正在构建一个可以在远程计算机上运行的备份服务器。我想现在的问题是我的内存泄漏了。传输大文件时，一段时间后会出现以下错误：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.lang.StringCoding$StringDecoder.decode(StringCoding.java:149)
    at java.lang.StringCoding.decode(StringCoding.java:193)
    at java.lang.StringCoding.decode(StringCoding.java:254)
    at java.lang.String.<init>(String.java:536)
    at java.lang.String.<init>(String.java:556)
    at Server.run(Server.java:61)
    at Server.main(Server.java:107)

线程“main”java.lang.OutOfMemoryError中的异常：java堆空间 在java.lang.StringCoding$StringDecoder.decode（StringCoding.java:149） 在java.lang.StringCoding.decode（StringCoding.java:193） 在java.lang.StringCoding.decode（StringCoding.java:254） 位于java.lang.String。（String.java:536） 位于java.lang.String。（String.java:556） 运行（Server.java:61） 位于Server.main（Server.java:107） 我已经读了一些关于这方面的文章，但没有一篇真正给了我解决这个问题的答案。代码在下面。提前谢谢

服务器：

private ServerSocket server;
private Socket acceptingSocket;

public Server(int port){
    try {
        server = new ServerSocket(port);
    } catch (IOException e) {
        System.out.println("Try again");
    }
}

/**
 * Reads all files and puts them in the back-up folder. Also creates the appropriate dirs.
 */
public void run(){
    BufferedInputStream buffer = null;
    DataInputStream reader = null;
    BufferedOutputStream out = null;
    DataOutputStream writer = null;
    int size = 0;
    try {
        acceptingSocket = server.accept();
        buffer = new BufferedInputStream(acceptingSocket.getInputStream());
        reader = new DataInputStream(buffer);
        out = new BufferedOutputStream(acceptingSocket.getOutputStream());
        writer = new DataOutputStream(out);
        size = reader.readInt();
    } catch (IOException e1) {
    }
    System.out.println("Size: " + size);
            //Variables I need later on, I thought this would help
    byte[] name;
    int fileNameLength = 0;
    long length=0;
    boolean dir  = false;
    int t = 0;
    String dirs = "";
    File direcs;
    File file;
    byte[] b;
    int bytes=0;
    for(int j = 0; j < size; j++){
        try {
            fileNameLength = reader.readInt();
            name = new byte[fileNameLength];
            reader.read(name, 0,fileNameLength);
            String path = new String(name);
            System.out.println("Path: " + path);
            length = reader.readLong();
            dir = reader.readBoolean();
            path = "/backup" + path;
            file = new File(path);
            if(!dir){
                t = file.getAbsolutePath().lastIndexOf("/");
                dirs = file.getAbsolutePath().substring(0, t);
                direcs = new File(dirs);
                System.out.println(direcs.mkdirs());
                FileOutputStream fos = new FileOutputStream(file);
                BufferedOutputStream bos = new BufferedOutputStream(fos);
                b = new byte[(int) length];
                bytes = reader.read(b, 0, (int)length);
                if(bytes != -1)
                    bos.write(b,0,(int)length);                 

                writer.writeUTF("File " + file.getAbsolutePath() + " is created!");
                writer.flush();
                bos.flush();
                fos.flush();
                bos.close();
                fos.close();
                out.flush();

            } else file.mkdirs();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    try {
        buffer.close();
        reader.close();
        out.close();
        writer.close();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

public static void main(String[] args){
    int port = Integer.parseInt(args[0]);
    Server server = new Server(port);
    while(true)
        server.run();
}

私有服务器套接字服务器；
专用套接字接受套接字；
公共服务器（int端口）{
试一试{
服务器=新的服务器套接字（端口）；
}捕获（IOE异常）{
System.out.println（“重试”）；
}
}
/**
*读取所有文件并将其放入备份文件夹。还创建适当的目录。
*/
公开募捐{
BufferedInputStream buffer=null；
DataInputStream读取器=空；
BufferedOutputStream out=null；
DataOutputStream编写器=null；
int size=0；
试一试{
acceptingSocket=server.accept（）；
buffer=新的BufferedInputStream（acceptingSocket.getInputStream（））；
读卡器=新数据输入流（缓冲区）；
out=新的BufferedOutputStream（acceptingSocket.getOutputStream（））；
writer=新数据输出流（out）；
size=reader.readInt（）；
}捕获（IOE1异常）{
}
System.out.println（“尺寸：+尺寸”）；
//我以后需要的变量，我想这会有帮助
字节[]名称；
int fileNameLength=0；
长长度=0；
布尔dir=false；
int t=0；
字符串dirs=“”；
文件目录；
文件；
字节[]b；
int字节=0；
对于（int j=0；j

客户：

private DataInputStream serverToClient;
private Socket client;
private DataOutputStream clientToServer;
private String name;

public Client(String name, int port){
    try {
        client = new Socket(name, port);
        //receive response server
        serverToClient = new DataInputStream(client.getInputStream());
        //send message to server
        clientToServer = new DataOutputStream(client.getOutputStream());
        this.name = name;
    }
    catch (IOException e) {
    }
}

/**
 * Closes all connections
 */
public void stop(){

    try {
        client.close();
        serverToClient.close();
        clientToServer.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

/**
 * Sends all files and content of the files to the back-up server
 * @param filePath
 */
public void backUp(String filePath){
    ArrayList<File> files = new ArrayList<File>();
    boolean dir = false;
    long length = 0;
    byte[] buffer;
    try{
        listf(filePath, files, 0);
        System.out.println(files.toString());
        clientToServer.writeInt(files.size());

        for(File fi : files){
            dir = false;
            if(fi.isDirectory()) dir = true;
            clientToServer.writeInt(fi.getAbsolutePath().length());
            System.out.println(fi.getAbsolutePath().length());
            clientToServer.writeBytes(fi.getAbsolutePath());
            System.out.println(fi.getAbsolutePath());
            length = fi.length();
            clientToServer.writeLong(length);
            clientToServer.writeBoolean(dir);
            System.out.println("Dir? " + dir);
            System.out.println(length);
            if(!dir){
                FileInputStream fis = new FileInputStream(fi);
                BufferedInputStream bis = new BufferedInputStream(fis);

                buffer = new byte[(int)length];

                bis.read(buffer, 0, (int)length);
                clientToServer.write(buffer);
                System.out.println(serverToClient.readUTF());
                bis.close();
                fis.close();
                clientToServer.flush();
            }
        }

    } catch(IOException e){
        e.printStackTrace();
    }
}

/**
 * Get all files, folders and subfolders in the file specified by directoryName, recursively.
 * @param directoryName
 * @param files
 * @param size
 */
private void listf(String directoryName, ArrayList<File> files, int size) {
    File directory = new File(directoryName);
    size = files.size();
    if(size > 100){
        System.out.println(size);
        size += 100;
    }
    if(directory.isFile()) files.add(directory);
    else{
        File[] fList = directory.listFiles();
        for (File file : fList) {
            if(file.isDirectory() && file.listFiles().length == 0) files.add(file);
            else{
                if (file.isFile()) {
                    files.add(file);
                } else if (file.isDirectory()) {
                    listf(file.getAbsolutePath(), files, size);
                }
            }
        }
    }
}

public static void main(String[] args){
    String name = args[0];
    int port = Integer.parseInt(args[1]);
    System.out.println("Name: " + name + " Port: " + port);
    Client client = new Client(name, port);
    File file = new File(args[2]);
    if(file.exists())client.backUp(args[2]);
    else System.out.println("File doesn't exist");
    client.stop();

}

私有数据输入流服务器到客户端；
专用套接字客户端；
专用DataOutputStream客户端到服务器；
私有字符串名称；
公共客户端（字符串名称，int端口）{
试一试{
客户端=新套接字（名称、端口）；
//接收响应服务器
serverToClient=newDataInputStream（client.getInputStream（））；
//向服务器发送消息
clientToServer=newdataoutputstream（client.getOutputStream（））；
this.name=名称；
}
捕获（IOE异常）{
}
}
/**
*关闭所有连接
*/
公共停车场（）{
试一试{
client.close（）；
serverToClient.close（）；
clientToServer.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
/**
*将所有文件和文件内容发送到备份服务器
*@param文件路径
*/
公共无效备份（字符串文件路径）{
ArrayList files=新的ArrayList（）；
布尔dir=false；
长长度=0；
字节[]缓冲区；
试一试{
listf（文件路径，文件，0）；
System.out.println（files.toString（））；
clientToServer.writeInt（files.size（））；
用于（文件fi:文件）{
dir=false；
如果（fi.isDirectory（））dir=true；
clientToServer.writeInt（fi.getAbsolutePath（）.length（））；
System.out.println（fi.getAbsolutePath（）.length（））；
clientToServer.writeBytes（fi.getAbsolutePath（））；
System.out.println（fi.getAbsolutePath（））；
长度=fi.length（）；
clientToServer.writeLong（长度）；
clientToServer.writebolean（dir）；
System.out.println（“Dir？”+Dir）；
系统输出打印长度；
如果（！dir）{
FileInputStream fis=新的FileInputStream（fi）；
BufferedInputStream bis=新的BufferedInputStream（fis）；
缓冲区=新字节[（int）长度]；
二读（缓冲区，0，（int）长度）；
clientToServer.write（缓冲区）；
System.out.println（serverToClient.readUTF（））；
二、关闭（）；
fis.close（）；
clientToServer.flush（）；
}
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
while (total < length && (count = in.read(buffer, 0, length-total > buffer.length ? buffer.length : (int)(length-total))) > 0)