CODEWITHSUNDEEP
javaandroid
user1074896
user1074896

Reputation: 1025

Why I am getting OutOfMemory Exception?

I am getting OutOfMemory Exception. Why? I am using this code for logging. Does this approach correct? Exceptions and closing of streams are handled in parent methods.

private static void writeToFile(File file, FileWriter out, String message) throws IOException {
    if (file.exists() && file.isFile()) {
        if ((file.length() + message.getBytes().length) <= FILE_MAX_SIZE_B) {
            out.write(message);
        } else {
            int cutLenght = (int) (file.length() + message.getBytes().length - FILE_MAX_SIZE_B);

            FileInputStream fileInputStream = new FileInputStream(file);
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(fileInputStream));
            char[] buf = new char[1024];
            int numRead = 0;
            StringBuffer text = new StringBuffer(1000);
            while ((numRead=bufferedReader.read(buf)) != -1) {
                text.append(buf,0,numRead);
            }
            String result = new String(text).substring(cutLenght);
            result += message;
            FileWriter fileWriter = new FileWriter(file, appendToFile);
            writeToFile(file, fileWriter, result);
            bufferedReader.close();
        }
    }
}

EDIT:

I am using this method for writting my logs in file. So for example in one second I can call 10 logs. I am getting error on lines:

while ((numRead=bufferedReader.read(buf)) != -1) {
                text.append(buf,0,numRead);
            }

Upvotes: 0

Views: 181

Answers (4)

Jens
Jens

Reputation: 17087

Try something like this:

void appendToFile(File f, CharSequence message, Charset cs, long maximumSize) throws IOException {
    long available =  maximumSize - f.length();
    if (available > 0) {
        FileOutputStream fos = new FileOutputStream(f, true);
        try {
            CharBuffer chars = CharBuffer.wrap(message);
            ByteBuffer bytes = ByteBuffer.allocate(8 * 1024); // Re-used when encoding the string
            CharsetEncoder enc = cs.newEncoder();
            CoderResult res;
            do {
                res = enc.encode(chars, bytes, true);
                bytes.flip();
                long len = Math.min(available, bytes.remaining());
                available -= len;
                fos.write(bytes.array(), bytes.position(), (int) len);
                bytes.clear();
            } while (res == CoderResult.OVERFLOW && available > 0);
        } finally {
            fos.close();
        }
    }
}

Testable with this:

    File f = new File(getCacheDir(), "tmp.txt");
    f.delete();

    // Or whatever charset you want.
    Charset cs = Charset.forName("UTF-8");
    int maxlen = 2 * 1024; // For this test, 2kb
    try {
        for (int i = 0; i < maxlen / 20; i++) {
            // Write 30 characters for maxlen/20 times == guaranteed overflow
            appendToFile(f, "123456789012345678901234567890", cs, maxlen);
            System.out.println("Length=" + f.length());
        }
    } catch (Throwable t) {
        t.printStackTrace();
    }
    f.delete();

Upvotes: 1

Dave Costa
Dave Costa

Reputation: 48131

My guess is that you are getting the OutOfMemoryError because you are reading the entire contents of the log file back into memory once it has gotten too close to its maximum size.

You could instead read and write it in smaller chunks, but that could be tricky since you have to avoid overwriting something you haven't already read.

Overall, this technique seems like a very inefficient method of maintaining the log data. Some alternative approaches off the top of my head:

(1) maintain a set of n log files, each with maximum size FILE_MAX_SIZE_B/n. When the first log fills up, open the next one for writing, and so on; when the last one fills up, go back to the first one. In this way you are discarding some of the oldest log data each time you switch files, but not all of it, and still maintaining your overall size limit.

(2) rotate the data within a single file. After each write, add a marker that indicates this is the end of the log stream. When the file has reached its maximum size, just start again at the beginning, overwriting the data that is there. The marker will tell you where the latest message is.

Upvotes: 1

belgther
belgther

Reputation: 2534

you get OOME because you load the whole file, then get some part of the string. Instead, do a skip on your input stream and read.

Upvotes: 0

alf
alf

Reputation: 8523

Well, you're getting OOM because you're trying to load a huge file into memory.

Did you try opening it with append option instead?

Upvotes: 0

Related Questions