标签: garbage-collection

我们看到了一些TimeoutExceptionsin GcWatcher.finalize, BinderProxy.finalize,and PlainSocketImpl.finalize.其中90%以上发生在Android 4.3上.我们从现场用户那里获得了Crittercism的报告.

该错误是以下变体:" com.android.internal.BinderInternal$GcWatcher.finalize() timed out after 10 seconds"

java.util.concurrent.TimeoutException: android.os.BinderProxy.finalize() timed out after 10 seconds
at android.os.BinderProxy.destroy(Native Method)
at android.os.BinderProxy.finalize(Binder.java:459)
at java.lang.Daemons$FinalizerDaemon.doFinalize(Daemons.java:187)
at java.lang.Daemons$FinalizerDaemon.run(Daemons.java:170)
at java.lang.Thread.run(Thread.java:841)

到目前为止,我们没有任何运气在内部复制问题或找出可能导致问题的原因.

有什么想法可以导致这个？知道如何调试这个并找出应用程序的哪个部分导致这个？任何能够揭示这个问题的东西都有帮助.

更多Stacktraces:

1   android.os.BinderProxy.destroy  
2   android.os.BinderProxy.finalize Binder.java, line 482
3   java.lang.Daemons$FinalizerDaemon.doFinalize    Daemons.java, line 187
4   java.lang.Daemons$FinalizerDaemon.run   Daemons.java, line 170
5   java.lang.Thread.run    Thread.java, line 841  

2

1   java.lang.Object.wait   
2   java.lang.Object.wait   Object.java, line 401
3   java.lang.ref.ReferenceQueue.remove ReferenceQueue.java, line 102
4   java.lang.ref.ReferenceQueue.remove ReferenceQueue.java, line 73
5   java.lang.Daemons$FinalizerDaemon.run …

根据我的理解,如果没有其他东西"指向"该对象,Java中的垃圾收集会清除一些对象.

我的问题是,如果我们有这样的事情会发生什么:

class Node {
    public object value;
    public Node next;
    public Node(object o, Node n) { value = 0; next = n;}
}

//...some code
{
    Node a = new Node("a", null), 
         b = new Node("b", a), 
         c = new Node("c", b);
    a.next = c;
} //end of scope
//...other code

a,b和c应该是垃圾收集,但它们都被其他对象引用.

Java垃圾收集如何处理这个问题？(或者它只是一个内存消耗？)

在Python中,如果您在未调用的情况下打开文件close(),或者关闭文件但未使用try- finally或" with"语句,这是一个问题吗？或者它是否足以作为编码实践依赖Python垃圾收集来关闭所有文件？例如,如果有人这样做:

for line in open("filename"):
    # ... do stuff ...

...这是一个问题,因为文件永远不会被关闭,并且可能发生一个阻止它被关闭的异常？或者它肯定会在for声明结束时关闭,因为文件超出了范围？

从这些简单的类开始......

假设我有一组这样简单的类:

class Bus
{
    Driver busDriver = new Driver();
}

class Driver
{
    Shoe[] shoes = { new Shoe(), new Shoe() };
}

class Shoe
{
    Shoelace lace = new Shoelace();
}

class Shoelace
{
    bool tied = false;
}

A Bus有一个Driver,Driver有两个Shoe,每个Shoe有一个Shoelace.一切都很傻.

将一个IDisposable对象添加到Shoelace

后来我决定对它进行一些操作Shoelace可能是多线程的,所以我添加了一个EventWaitHandle用于与之通信的线程.所以Shoelace现在看起来像这样:

class Shoelace
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;
    // ... other stuff .. …

有没有办法在Java中释放内存,类似于C的free()功能？或者将对象设置为null并依赖GC是唯一的选择？

在我的类中,我实现IDisposable如下:

public class User : IDisposable
{
    public int id { get; protected set; }
    public string name { get; protected set; }
    public string pass { get; protected set; }

    public User(int UserID)
    {
        id = UserID;
    }
    public User(string Username, string Password)
    {
        name = Username;
        pass = Password;
    }

    // Other functions go here...

    public void Dispose()
    {
        // Clear all property values that maybe have been set
        // when the class was instantiated
        id = 0; …

我正在寻找详细描述python垃圾收集如何工作的文档.

我很感兴趣在哪一步做了什么.这三个系列中有哪些对象？每个步骤中删除了哪些对象？什么算法用于参考循环发现？

背景:我正在实施一些必须在很短的时间内完成的搜索.当垃圾收集器开始收集最老的一代时,它比其他情况"慢得多".花了比搜索更多的时间.我正在寻找如何预测它将收集最老一代的时间以及需要多长时间.

这是很容易预测它什么时候会收集最古老的一代与get_count()和get_threshold().这也可以用set_threshold().但是,我不认为collect()通过武力或等待预定的收集更好地决定是否更好.

我们正在开发一个程序,它接收和转发"消息",同时保留这些消息的临时历史记录,以便它可以告诉您消息历史记录(如果请求).消息以数字方式标识,通常大小约为1千字节,我们需要保留数十万条这些消息.

我们希望优化此程序的延迟:发送和接收消息之间的时间必须低于10毫秒.

该程序是用Haskell编写的,并用GHC编译.但是,我们发现垃圾收集暂停对于我们的延迟要求来说太长了:在我们的实际程序中超过100毫秒.

以下程序是我们的应用程序的简化版本.它使用a Data.Map.Strict来存储消息.消息ByteString由a标识Int.以递增的数字顺序插入1,000,000条消息,并且不断删除最旧的消息以使历史记录最多保留200,000条消息.

module Main (main) where

import qualified Control.Exception as Exception
import qualified Control.Monad as Monad
import qualified Data.ByteString as ByteString
import qualified Data.Map.Strict as Map

data Msg = Msg !Int !ByteString.ByteString

type Chan = Map.Map Int ByteString.ByteString

message :: Int -> Msg
message n = Msg n (ByteString.replicate 1024 (fromIntegral n))

pushMsg :: Chan -> Msg -> IO Chan
pushMsg chan (Msg msgId msgContent) =
  Exception.evaluate $
    let
      inserted = Map.insert …

根据我的经验,似乎大多数人会告诉你强制垃圾收集是不明智的,但在某些情况下,你正在使用大型对象,这些对象并不总是在0代收集,但内存是一个问题,是它可以强制收集？这样做有最好的做法吗？

我有一个提供一些活动的课程.该类在全局声明但未在该全局声明上实例化 - 它根据需要在需要它的方法中实例化.

每次在方法中需要该类时,都会对其进行实例化并注册事件处理程序.是否有必要在方法超出范围之前显式删除事件处理程序？

当方法超出范围时,类的实例也是如此.是否在超出范围的情况下向该实例注册的事件处理程序是否存在内存占用意义？(我想知道事件处理程序是否使GC看不到类实例不再被引用.)