Sicurezza thread nelle librerie Android

Question

Sto cercando di implementare una libreria nativa condivisa (.so) per il sistema Android. Naturalmente, ci sono alcuni blocchi di codice che devono essere thread-safe.

Ho scoperto here che pthreads blocchi, mutex o variabili di condizione non sono supportati.

Mi piacerebbe sapere cosa viene solitamente utilizzato a livello di libreria per ottenere la sicurezza del thread?

Answer 1

Il modo in cui questo può essere raggiunto dipende dal fatto che si desidera che sia thread-safe quando si accede da thread a livello Java oppure è necessario sincronizzare i thread nativi con i thread Java.

Ci sono due modi per sincronizzare solo le discussioni a livello di Java:

1. Il modo più semplice è quello di aggiungere il sincronizzato parola chiave ai metodi nativi che accessibili con filettatura multipla, vale a dire

public native synchronized int sharedAccess(); 

2.Synchronization dal lato origini:

(*env)->MonitorEnter(env, obj); 
...      /* synchronized block */ 
(*env)->MonitorExit(env, obj); 

Fare riferimento here su come sincronizzare le discussioni nativi con Java infila

Answer 2

c'è un video DevBytes here che discute filettatura nel NDK. Uno schema utile discusso nel video sta facendo le scritture atomiche usando __atomic_swap nel codice nativo.

Answer 3

È possibile utilizzare un singleton thread-safe. Anche se questo non è più un metodo molto popolare di operazioni atomiche thread safe, dal momento che tutte le cose singleton sono pessime, (quindi non mi aspetto molti voti). È veloce, leggero e funziona ancora, è stato pesantemente utilizzato in smalltalk e per un periodo in Java ed è stato considerato un modello di progettazione chiave.

public class ThreadSafeSingleton { 

    private static final Object instance = new Object(); 

    protected ThreadSafeSingleton() { 
    } 

    // Runtime initialization 

    public static Object getInstance() { 
     return instance; 
    } 
} 

Questa una versione caricata pigro ...

public class LazySingleton { 
    private Singleton() { 
    } 

    private static class LazyInstance { 
     private static final Singleton INSTANCE = new Singleton(); 
    } 
     // Automatically ThreadSafe 
    public static Singleton getInstance() { 
     return LazyInstance.INSTANCE; 
    } 
} 

È possibile controllare questo post su Thread Safe Singletons in Java per maggiori informazioni.