代码之家  ›  专栏  ›  技术社区  ›  Hakanai

有没有安全的方法可以使用Cleaner注销侦听器?

  •  0
  • Hakanai  · 技术社区  · 4 年前

    我有一个摇摆动作类,其工作原理如下:

    package org.trypticon.hex.gui.datatransfer;
    
    import java.awt.Toolkit;
    import java.awt.datatransfer.Clipboard;
    import java.awt.datatransfer.DataFlavor;
    import java.awt.datatransfer.FlavorListener;
    import java.awt.event.ActionEvent;
    import javax.annotation.Nonnull;
    import javax.swing.Action;
    import javax.swing.JComponent;
    import javax.swing.TransferHandler;
    
    import org.trypticon.hex.gui.Resources;
    import org.trypticon.hex.gui.util.FinalizeGuardian;
    import org.trypticon.hex.gui.util.FocusedComponentAction;
    
    public class PasteAction extends FocusedComponentAction {
        private final FlavorListener listener = (event) -> {
            // this method in the superclass calls back `shouldBeEnabled`
            updateEnabled();
        };
    
        @SuppressWarnings({"UnusedDeclaration"})
        private final Object finalizeGuardian = new FinalizeGuardian(() -> {
            Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
            clipboard.removeFlavorListener(listener);
        });
    
        public PasteAction() {
            Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
            clipboard.addFlavorListener(listener);
        }
    
        @Override
        protected boolean shouldBeEnabled(@Nonnull JComponent focusOwner) {
            TransferHandler transferHandler = focusOwner.getTransferHandler();
            if (transferHandler == null) {
                return false;
            }
    
            Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
            DataFlavor[] flavorsInClipboard = clipboard.getAvailableDataFlavors();
            return transferHandler.canImport(focusOwner, flavorsInClipboard);
        }
    
        @Override
        protected void doAction(@Nonnull JComponent focusOwner) throws Exception {
            Action action = TransferHandler.getPasteAction();
            action.actionPerformed(new ActionEvent(
                focusOwner, ActionEvent.ACTION_PERFORMED, (String) action.getValue(Action.NAME)));
        }
    }
    

    这个 FinalizeGuardian finalize() :

    package org.trypticon.hex.gui.util;
    
    public final class FinalizeGuardian {
        private final Runnable cleanupLogic;
    
        public FinalizeGuardian(Runnable cleanupLogic) {
            this.cleanupLogic = cleanupLogic;
        }
    
        @Override
        protected final void finalize() throws Throwable {
            try {
                cleanupLogic.run();
            } finally {
                super.finalize();
            }
        }
    }
    

    所以,出于显而易见的原因,我想改用 Cleaner 为了这个。

    第一次尝试是这样的:

    package org.trypticon.hex.gui.util;
    
    import java.lang.ref.Cleaner;
    
    public final class FinalizeGuardian {
        private static final Cleaner cleaner = Cleaner.create();
    
        public FinalizeGuardian(Runnable cleanupLogic) {
            cleaner.register(this, cleanupLogic);
        }
    }
    

    问题是,现在对象永远无法到达幻影,因为:

    • 清洁工 它本身就强烈地提到了 cleanupLogic
    • cleanupLogic listener 为了移除侦听器
    • 听众 保存对action类的引用,以便调用 updateEnabled 在上面
    • action类包含对 埃瓜迪亚人 这样它就不会过早地被收集

    因为 埃瓜迪亚人 它自己永远无法触及,清洁工也永远不会被叫来。

    所以我想知道的是,有没有一种方法来重组这个系统,以遵循制定规则的要求 清洁工 正确地工作 不 通过将听者转移到我的动作类之外来打破封装?

    0 回复  |  直到 4 年前
        1
  •  3
  •   Holger    4 年前

    只要 FlavorListener 如果在事件源中注册,它将永远不会变得不可访问(只要事件源仍然可访问)。这意味着 PasteAction 侦听器更新的实例也永远不会变得不可访问,因为侦听器对它有很强的引用。

    将它们的可达性解耦的唯一方法是更改侦听器,只保留对它更新的对象的弱引用。注意,当你使用 Cleaner 而不是 finalize() 这个 FinalizeGuardian 已经过时了。

    代码看起来像

    public class PasteAction extends FocusedComponentAction {
    
        static FlavorListener createListener(WeakReference<PasteAction> r) {
            return event -> {
                PasteAction pa = r.get();
                if(pa != null) pa.updateEnabled();
            };
        }
    
        private static final Cleaner CLEANER = Cleaner.create();
    
        static void prepareCleanup(
                           Object referent, Clipboard clipboard, FlavorListener listener) {
    
            CLEANER.register(referent, () -> clipboard.removeFlavorListener(listener));
        }
    
        public PasteAction() {
            Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
            FlavorListener listener = createListener(new WeakReference<>(this));
            clipboard.addFlavorListener(listener);
            prepareCleanup(this, clipboard, listener);
        }
    
    …
    

    请注意,关键部件已放置在 static 方法,意外捕获 this 参考资料不可能。这些方法得到了完成工作所需的最低限度, createListener 只收到对动作的弱引用 prepareCleanup 将引用对象作为 Object ,因为清理操作不能访问操作的任何成员,而是接收必要的值作为单独的参数。

    但在展示了更清洁的使用方式之后,我不得不强烈反对使用这种机制,尤其是作为唯一的清洁机制。在这里,它不仅影响内存消耗,还影响 因为,只要引用没有被清除,监听器就会不断得到通知并不断更新过时的对象。

    由于垃圾收集器只由内存需求触发,它很可能不运行或不关心这几个对象,因为有足够的空闲内存,而CPU负载很重,因为很多过时的侦听器正忙于更新过时的对象(我在实践中见过这种情况)。

    更糟糕的是,对于并发垃圾收集器,它们的收集周期甚至可能与实际过时的 updateEnabled() 由侦听器触发(因为引用尚未清除)。这将积极防止这些对象的垃圾回收,即使垃圾回收器运行时也会收集它们。

    简而言之,这种清理不应该依赖垃圾收集器。