试试写一个Android Handler的工具类

好的，以下是一个简单的Android Handler的工具类：

import android.os.Handler;
import android.os.Looper;

public class HandlerUtil {

    private static final Handler mainHandler = new Handler(Looper.getMainLooper());

    public static void runOnUiThread(Runnable runnable) {
        if (Looper.myLooper() == Looper.getMainLooper()) {
            runnable.run();
        } else {
            mainHandler.post(runnable);
        }
    }

}

这个工具类中有一个 `runOnUiThread()` 方法，可以在UI线程中执行一个任务。如果当前线程已经是UI线程，则直接执行；否则，将任务投递到主线程的Handler中执行。可以方便地在子线程中更新UI。

相关问题

试试用Android写一个handler弱引用的工具类

好的，下面是一个简单的 Android Handler 弱引用工具类：

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import java.lang.ref.WeakReference;

public class WeakHandler<T> extends Handler {
    private WeakReference<T> mRef;

    public WeakHandler(T ref) {
        mRef = new WeakReference<>(ref);
    }

    public WeakHandler(T ref, Looper looper) {
        super(looper);
        mRef = new WeakReference<>(ref);
    }

    @Override
    public void handleMessage(Message msg) {
        T ref = mRef.get();
        if (ref != null) {
            handleMessage(ref, msg);
        }
    }

    protected void handleMessage(T ref, Message msg) {
        // Override this method to handle messages
    }
}

使用方法：
1. 创建一个 Handler 弱引用对象

WeakHandler<MyActivity> handler = new WeakHandler<>(this);

2. 通过 handler 发送消息

handler.sendMessage(Message.obtain());

3. 在 `handleMessage` 方法中处理消息

@Override
protected void handleMessage(MyActivity ref, Message msg) {
    switch (msg.what) {
        // handle messages
    }
}

这样可以有效避免 Handler 引起的内存泄漏问题。

试试写一个handler弱引用的工具类

好的，这里是一个基于Python的弱引用工具类：

import weakref

class WeakMethod:
    def __init__(self, method):
        self.method = None
        self.set_method(method)

    def set_method(self, method):
        if method is None:
            self.method = None
            return

        if not callable(method):
            raise TypeError("Expected a callable")

        self.method = weakref.ref(method)

    def __call__(self, *args, **kwargs):
        if self.method is None:
            raise TypeError("Method is None")

        method = self.method()
        if method is None:
            raise TypeError("Method is None")

        return method(*args, **kwargs)

class WeakHandler:
    def __init__(self, handler):
        if not callable(handler):
            raise TypeError("Expected a callable")
        self.handler = weakref.ref(handler)

    def __call__(self, *args, **kwargs):
        handler = self.handler()
        if handler is None:
            return None

        return handler(*args, **kwargs)

    def clear(self):
        self.handler = None

这个工具类包括两个类：`WeakMethod` 和 `WeakHandler`。其中，`WeakMethod` 是用来存储一个弱引用的方法，而 `WeakHandler` 则是用来存储一个弱引用的回调函数。

使用这个工具类非常简单，只需要在需要存储回调函数的地方创建一个 `WeakHandler` 对象即可：

def on_event(self, event):
    pass

weak_handler = WeakHandler(self.on_event)

这样，`weak_handler` 对象就会存储一个弱引用的 `on_event` 方法。当需要调用回调函数时，只需要调用 `weak_handler` 对象即可：

event = ...
result = weak_handler(event)

如果 `on_event` 方法已经被销毁，那么 `weak_handler` 对象调用时会返回 `None`。如果需要清除 `WeakHandler` 对象中的弱引用，可以调用 `clear()` 方法：

weak_handler.clear()