java高階用法之JNA中的回呼問題怎麼解決

簡介

什麼是callback呢？簡單點說callback就是回呼通知，當我們需要在某個方法完成之後，或是某個事件觸發之後，來通知進行某些特定的任務就需要用到callback了。

最有可能看到callback的語言就是javascript了，基本上在javascript中，callback無所不在。為了解決callback導致的回調地獄的問題，ES6中特意引入了promise來解決這個問題。

為了方便和native方法進行交互，JNA中同樣提供了Callback用來進行回調。 JNA中回呼的本質是指向native函數的指針，透過這個指標可以呼叫native函數中的方法，一起來看看吧。

JNA中的Callback

先看下JNA中Callback的定義：

public interface Callback {
    interface UncaughtExceptionHandler {
        void uncaughtException(Callback c, Throwable e);
    }
    String METHOD_NAME = "callback";

    List<String> FORBIDDEN_NAMES = Collections.unmodifiableList(
            Arrays.asList("hashCode", "equals", "toString"));
}

所有的Callback方法都需要實作這個Callback介面。 Callback介面很簡單，裡面定義了一個interface和兩個屬性。

先來看這個interface,interface名字叫做UncaughtExceptionHandler,裡面有一個uncaughtException方法。這個interface主要用於處理JAVA的callback程式碼中沒有捕獲的異常。

注意，在uncaughtException方法中，不能拋出例外，任何從這個方法拋出的例外都會被忽略。

METHOD_NAME這個欄位指定了Callback要呼叫的方法。

如果Callback類別中只定義了一個public的方法，那麼預設callback方法就是這個方法。如果Callback類別中定義了多個public方法，那麼就會選擇METHOD_NAME = "callback"的這個方法作為callback。

最後一個屬性就是FORBIDDEN_NAMES。表示在這個清單裡面的名字是不能當作callback方法使用的。

目前看來是有三個方法名稱不能夠被使用，分別是：「hashCode」, “equals”, “toString”。

Callback還有一個同胞兄弟叫做DLLCallback，我們來看下DLLCallback的定義：

public interface DLLCallback extends Callback {
    @java.lang.annotation.Native
    int DLL_FPTRS = 16;
}

DLLCallback主要用在Windows API的存取中。

對於callback物件來說，需要我們自行負責對callback物件的釋放工作。如果native程式碼嘗試存取一個被回收的callback，那麼有可能會導致VM崩潰。

callback的應用

callback的定義

因為JNA中的callback實際上映射的是native中指向函數的指標。首先看一下在struct中定義的函數指針：

struct _functions {
  int (*open)(const char*,int);
  int (*close)(int);
};

在這個結構體中，定義了兩個函數指針，分別帶兩個參數和一個參數。

對應的JNA的callback定義如下：

public class Functions extends Structure {
  public static interface OpenFunc extends Callback {
    int invoke(String name, int options);
  }
  public static interface CloseFunc extends Callback {
    int invoke(int fd);
  }
  public OpenFunc open;
  public CloseFunc close;
}

我們在Structure裡面定義兩個介面繼承自Callback，對應的介面定義了對應的invoke方法。

接著看一下具體的呼叫方式：

Functions funcs = new Functions();
lib.init(funcs);
int fd = funcs.open.invoke("myfile", 0);
funcs.close.invoke(fd);

另外Callback還可以作為函數的回傳值，如下所示：

typedef void (*sig_t)(int);
sig_t signal(int signal, sig_t sigfunc);

對於這種單獨存在的函數指標，我們需要自訂一個Library,並在其中定義對應的Callback，如下所示：

public interface CLibrary extends Library {
    public interface SignalFunction extends Callback {
        void invoke(int signal);
    }
    SignalFunction signal(int signal, SignalFunction func);
}

callback的獲取和應用

如果callback是定義在Structure中的，那麼可以在Structure進行初始化的時候會自動實例化，然後只需要從Structure中存取對應的屬性即可。

如果callback定義是在一個普通的Library中的話，如下所示：

public static interface TestLibrary extends Library {
        interface VoidCallback extends Callback {
            void callback();
        }
        interface ByteCallback extends Callback {
            byte callback(byte arg, byte arg2);
        }
        void callVoidCallback(VoidCallback c);
        byte callInt8Callback(ByteCallback c, byte arg, byte arg2);
    }

上例中，我們在一個Library中定義了兩個callback，一個是無回傳值的callback，一個是回傳byte的callback。

JNA提供了一個簡單的工具類別來幫助我們取得Callback，這個工具類別就是CallbackReference，對應的方法是CallbackReference.getCallback,如下所示：

Pointer p = new Pointer("MultiplyMappedCallback".hashCode());
Callback cbV1 = CallbackReference.getCallback(TestLibrary.VoidCallback.class, p);
Callback cbB1 = CallbackReference.getCallback(TestLibrary.ByteCallback.class, p);
log.info("cbV1:{}",cbV1);
log.info("cbB1:{}",cbB1);

輸出結果如下：

INFO com.flydean.CallbackUsage - cbV1:Proxy interface to native function@0xffffffffc46eeefc (com.flydean.CallbackUsage$TestLibrary$VoidCallback)##INFO com.fly; native function@0xffffffffc46eeefc (com.flydean.CallbackUsage$TestLibrary$ByteCallback)

可以看出，這兩個Callback其實是對native方法的代理人。如果詳細看getCallback的實作邏輯：

private static Callback getCallback(Class<?> type, Pointer p, boolean direct) {
        if (p == null) {
            return null;
        }
        if (!type.isInterface())
            throw new IllegalArgumentException("Callback type must be an interface");
        Map<Callback, CallbackReference> map = direct ? directCallbackMap : callbackMap;
        synchronized(pointerCallbackMap) {
            Reference<Callback>[] array = pointerCallbackMap.get(p);
            Callback cb = getTypeAssignableCallback(type, array);
            if (cb != null) {
                return cb;
            }
            cb = createCallback(type, p);
            pointerCallbackMap.put(p, addCallbackToArray(cb,array));
            // No CallbackReference for this callback
            map.remove(cb);
            return cb;
        }
    }

可以看到它的實作邏輯是先判斷type是否是interface，如果不是interface則會報錯。然後判斷是否為direct mapping。實際上目前JNA的實作都是interface mapping，所以接下來的邏輯就是從pointerCallbackMap中取得函數指針對應的callback。然後按照傳入的類型來找出特定的Callback。

如果沒有查找到，則建立一個新的callback，最後將這個新建立的存入pointerCallbackMap中。

大家要注意， 這裡有一個關鍵的參數叫做Pointer，實際使用的時候，需要傳入指向真實naitve函數的指標。上面的例子中，為了簡單起見，我們是自訂了一個Pointer，而這個Pointer並沒有太大的實際意義。

如果真的要想在JNA中调用在TestLibrary中创建的两个call方法：callVoidCallback和callInt8Callback，首先需要加载对应的Library：

TestLibrary lib = Native.load("testlib", TestLibrary.class);

然后分别创建TestLibrary.VoidCallback和TestLibrary.ByteCallback的实例如下，首先看一下VoidCallback：

final boolean[] voidCalled = { false };
        TestLibrary.VoidCallback cb1 = new TestLibrary.VoidCallback() {
            @Override
            public void callback() {
                voidCalled[0] = true;
            }
        };
        lib.callVoidCallback(cb1);
        assertTrue("Callback not called", voidCalled[0]);

这里我们在callback中将voidCalled的值回写为true表示已经调用了callback方法。

再看看带返回值的ByteCallback:

final boolean[] int8Called = {false};
        final byte[] cbArgs = { 0, 0 };
        TestLibrary.ByteCallback cb2 = new TestLibrary.ByteCallback() {
            @Override
            public byte callback(byte arg, byte arg2) {
                int8Called[0] = true;
                cbArgs[0] = arg;
                cbArgs[1] = arg2;
                return (byte)(arg + arg2);
            }
        };

final byte MAGIC = 0x11;
byte value = lib.callInt8Callback(cb2, MAGIC, (byte)(MAGIC*2));

我们直接在callback方法中返回要返回的byte值即可。

在多线程环境中使用callback

默认情况下， callback方法是在当前的线程中执行的。如果希望callback方法是在另外的线程中执行，则可以创建一个CallbackThreadInitializer,指定daemon,detach,name,和threadGroup属性：

 final String tname = "VoidCallbackThreaded";
        ThreadGroup testGroup = new ThreadGroup("Thread group for callVoidCallbackThreaded");
        CallbackThreadInitializer init = new CallbackThreadInitializer(true, false, tname, testGroup);

然后创建callback的实例：

TestLibrary.VoidCallback cb = new TestLibrary.VoidCallback() {
            @Override
            public void callback() {
                Thread thread = Thread.currentThread();
                daemon[0] = thread.isDaemon();
                name[0] = thread.getName();
                group[0] = thread.getThreadGroup();
                t[0] = thread;
                if (thread.isAlive()) {
                    alive[0] = true;
                }
                ++called[0];
                if (THREAD_DETACH_BUG && called[0] == 2) {
                    Native.detach(true);
                }
            }
        };

然后调用:

Native.setCallbackThreadInitializer(cb, init);

将callback和CallbackThreadInitializer进行关联。

最后调用callback方法即可：

lib.callVoidCallbackThreaded(cb, 2, 2000, "callVoidCallbackThreaded", 0);

以上是java高階用法之JNA中的回呼問題怎麼解決的詳細內容。更多資訊請關注PHP中文網其他相關文章！