相关疑难解决方法(0)

有没有办法让Java在内存不足之前做一些事情.例如,保留先前文档状态列表(用于撤消)并仅在内存即将耗尽时删除非常旧的状态？

我在LogCat中收到OutOfMemoryError消息,我的应用程序崩溃,因为错误未被捕获.

导致OutOfMemoryError的两件事:
1.将大文本文件读入字符串.
2.将该字符串发送到我的TextView.

简单地为这两件事添加一个catch不仅可以捕获OutOfMemoryError,而且可以完全解决内存不足的问题.
LogCat中没有更多崩溃,也没有更多错误消息.该应用程序运行完美.

这怎么可能？究竟发生了什么？

使用此代码,我收到错误消息和应用程序崩溃:

try
{
myString = new Scanner(new File(myFilePath)).useDelimiter("\\A").next();
} 
catch (FileNotFoundException e) 
{
e.printStackTrace();
}


myTextView.setText(myString);

只是通过"捕获" OutOfMemoryError,LogCat中没有更多的错误消息而且没有崩溃:

try
{
myString = new Scanner(new File(myFilePath)).useDelimiter("\\A").next();
} 
catch (FileNotFoundException e) 
{
e.printStackTrace();
}
catch(OutOfMemoryError e)
{
}


try 
{
myTextView.setText(myString);
} 
catch(OutOfMemoryError e)
{
}

所以今天在学习Java时,我终于遇到了这个特殊错误.似乎这个错误非常普遍,并试图从中恢复已经获得了混合反应.有些人认为它在某些情况下是有用的,因此它是一个很好的"知道",有些人在他们的项目中使用它,而另一些则强烈反对 捕获这个错误的想法,然后很多其他人就像我一样困惑.

编辑:哦顺便说一句,这是我遇到的错误.我希望捕获这些错误并将增量值的值减少1/10,直到找到另一个错误
(依此类推......直到我找到上限)

由于我在Java中采取了我的步骤,并且在这个主题上找不到任何具体的内容,我想请求您提供有关此特定示例的帮助:

public class SpeedDemoClass {
        static int iterations=0;
        static int incrementor=10000000;
    public static void main(String[] args) {
        while(incrementor>1){
            try{
              iterations=iterations+incrementor;
              iterator(iterations);
            }
            catch(Exception e){
                System.out.println("So this is the limiting error: "+e);
                iterations=iterations-incrementor;
                incrementor=incrementor/10;
                iterations=iterations+incrementor;
            }
        }
        System.out.println("The upper limit of iterations is: "+iterations);
    }

    public static void iterator(int a){
            long start_time= System.currentTimeMillis();
            StringBuilder sbuild= new StringBuilder("JAVA");
            for(int i=0;i<a;i++){
                sbuild.append("JAVA");
            }
            System.out.println("Performing "+a+" append operations;"
                    +"process completed …

我正在实现一个自定义 Kotlin CoroutineScope，用于处理通过 WebSocket 连接接收、处理和响应消息。该作用域的生命周期与 WebSocket 会话相关，因此只要 WebSocket 打开，它就处于活动状态。作为协程作用域上下文的一部分，我安装了一个自定义异常处理程序，如果存在未处理的错误，该处理程序将关闭 WebSocket 会话。是这样的：

val handler = CoroutineExceptionHandler { _, exception -> 
    log.error("Closing WebSocket session due to an unhandled error", exception)
    session.close(POLICY_VIOLATION)
}

我惊讶地发现异常处理程序不仅接收异常，而且实际上为所有未处理的可抛出对象（包括Error. 我不确定应该如何处理这些，因为我从Java API 文档Error中知道“一个Error[...] 表明合理的应用程序不应尝试捕获的严重问题”。

我最近遇到的一个特殊情况是OutOfMemoryError由于会话处理的数据量所致。OutOfMemoryErrormy 收到了，这CoroutineExceptionHandler意味着它已被记录并且 WebSocket 会话已关闭，但应用程序继续运行。这让我感到不舒服，因为我知道OutOfMemoryError在代码执行期间的任何时候都可以抛出 an ，从而导致应用程序处于不可恢复的状态。

我的第一个问题是：为什么 Kotlin API 选择将这些错误传递给CoroutineExceptionHandler我（程序员）来处理？

我的第二个问题是：我处理它的适当方法是什么？我至少可以想到三个选择：

1. 继续执行我现在正在执行的操作，即关闭引发错误的 WebSocket 会话，并希望应用程序的其余部分能够恢复。正如我所说，这让我感到不舒服，特别是当我阅读这样的答案时，这是针对有关OutOfMemoryError在 Java 中捕获的问题的回答，该问题强烈建议不要尝试从此类错误中恢复。
2. 重新抛出错误，让它传播到线程。这就是我在遇到Error正常（或框架）代码的任何其他情况下通常会做的事情，因为它最终会导致 …

它似乎应该如此.但有人可以肯定或否认吗？

相关的是:

捕获java.lang.OutOfMemoryError？

是否有可能在java中捕获内存不足？

当我运行下面的代码时,抛出OutOfMemoryError,但是没有被捕获,尽管有一些条款应该捕获它:

public class SomeClass {
    public static void main(String[] args) {
        try {
            //Allocate a huge amount of memory here
        } catch (OutOfMemoryError oome) {
            System.out.println("OutOfMemoryError=<" + oome + ">");
        } catch (Error err) {
            System.out.println("Error=<" + err + ">");
        } catch (Throwable t) {
            System.out.println("Throwable=<" + t + ">");
        } finally {
            System.out.println("'Finally' clause triggered");
        }
    }
}

输出如下:

'Finally' clause triggered
Exception in thread "main"
Exception: java.lang.OutOfMemoryError thrown from the UncaughtExceptionHandler in thread "main"

没有抓住异常这一事实对我来说毫无意义.该的OutOfMemoryError文档确认异常应该由任何Throwable的,错误或OutOfMemoryError异常捕获.(请注意,"java.lang."说明符不会影响行为.)

我在StackOverflow上看到的所有其他问题都是"为什么我的OutOfMemoryError异常没有被捕获？" …

一般的建议是你不应该捕获java.lang.Error,除非在特殊情况下,请参阅捕获Throwable是不好的做法？例如.

我的情况是我有一个程序有时耗尽内存并抛出java.lang.OutOfMemoryError.虽然没有从中恢复但我确实想知道它发生了,所以我希望在日志中看到一些东西和非零退出代码.那么这样的建议是什么？

public static void main(String[] args)
{
    try
    {
        ...
    }
    catch (Exception e)
    {
        e.printStackTrace();
        System.exit(1);
    }
    catch (OutOfMemoryError e)
    {
        e.printStackTrace();
        System.exit(1);
    }
}

另一个程序是类似的,除了它可能是消耗所有内存的一个特定线程.在这种情况下,如果该线程退出,则可以继续处理,我真正想要的只是查看日志并最终具有非零退出代码.那么我应该在那个线程运行方法中捕获OutOfMemoryError吗？

我的android应用程序连接使用Web服务执行外部数据库.在一种情况下,我有巨大的数据的数量,并且我得到了内存溢出异常:

09-09 20:05:59.441: ERROR/dalvikvm(4688): Out of memory: Heap Size=15751KB, Allocated=14962KB, Bitmap Size=687KB
09-09 20:05:59.451: WARN/dalvikvm(4688): threadid=23: thread exiting with uncaught exception (group=0x4001e390)
09-09 20:05:59.462: ERROR/AndroidRuntime(4688): Uncaught handler: thread AsyncTask #5 exiting due to uncaught exception
09-09 20:05:59.731: ERROR/AndroidRuntime(4688): java.lang.RuntimeException: An error occured while executing doInBackground()
09-09 20:05:59.731: ERROR/AndroidRuntime(4688):     at android.os.AsyncTask$3.done(AsyncTask.java:200)
09-09 20:05:59.731: ERROR/AndroidRuntime(4688):     at java.util.concurrent.FutureTask$Sync.innerSetException(FutureTask.java:273)
09-09 20:05:59.731: ERROR/AndroidRuntime(4688):     at java.util.concurrent.FutureTask.setException(FutureTask.java:124)
09-09 20:05:59.731: ERROR/AndroidRuntime(4688):     at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:307)
09-09 20:05:59.731: ERROR/AndroidRuntime(4688):     at java.util.concurrent.FutureTask.run(FutureTask.java:137)
09-09 20:05:59.731: ERROR/AndroidRuntime(4688):     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1068)
09-09 …

我正在创建一个应用程序,用户可能会得到一个OutOfMemoryError; 现在我想找到一种方法,可以通知用户程序遇到OutOfMemoryError,这样他/她就可以采取相应的行动.(例如,使用更大的堆空间重新启动程序等)

如何"捕获"错误,以便我可以通知用户？