verhindern Java-Programm von der Öffnung Threads

Question

Ich versuche, eine Java-Anwendung auszuführen, genauer gesagt ein Glas ein zusammengestellt, mit execve() in c
etwas wie folgt aus:

char *cmd[] = {"a.jar"}; 
execve("a.jar",cmd,NULL); 

, die funktioniert OK, aber wenn ich versuche, die Anzahl der Threads zu begrenzen, die dieses Programm öffnen können so etwas mit:

struct rlimit rlp; 
rlp.rlim_cur = rlp.rlim_max = limit_nproc; 
setrlimit(RLIMIT_NPROC,&rlp); 

ich habe ein Problem mit der JVM, die Threads öffnen würde, und ich bin zu verhindern, dass so habe ich diesen Fehler:

Wie kann ich verhindern, dass die in der Java-Anwendung geöffneten Threads geöffnet werden, aber nicht die von der JVM geöffneten Threads? !

Bitte beachten Sie, ist die Frage, wie Benutzer-Threads zu verhindern, aber nicht System-Threads, ich brauche eine Beschränkung auf die Fahrumgebung wie das, was ich in meinem zweiten Code „RLIMIT_NPROC“ tat

und Dank!

Answer 1

Dies kann mit JVMTI Agent erreicht werden.

Die Idee ist es, native Thread.start0() Methode abzufangen und eine Ausnahme zu werfen, wann immer es aufgerufen wird.

Hier ist ein Beispielagenten in C++ geschrieben:

#include <jvmti.h> 

// Original native implementation of Thread.start0(), if you wish to call it 
extern "C" void JNICALL JVM_StartThread(JNIEnv* env, jthread thread); 

void JNICALL StartThreadHook(JNIEnv* env, jthread thread) { 
    env->ThrowNew(env->FindClass("java/lang/Error"), "Threads forbidden"); 
} 

void JNICALL VMInit(jvmtiEnv* jvmti, JNIEnv* env, jthread thread) { 
    // After VM is initialized, intercept Thread.start0() with our hook function 
    jclass thread_class = env->FindClass("java/lang/Thread"); 
    JNINativeMethod start0 = {(char*)"start0", (char*)"()V", (void*)StartThreadHook}; 
    env->RegisterNatives(thread_class, &start0, 1); 
} 

JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM* vm, char* options, void* reserved) { 
    jvmtiEnv* jvmti; 
    vm->GetEnv((void**)&jvmti, JVMTI_VERSION_1_0); 

    jvmtiEventCallbacks callbacks = {0}; 
    callbacks.VMInit = VMInit; 
    jvmti->SetEventCallbacks(&callbacks, sizeof(callbacks)); 
    jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, NULL); 

    return 0; 
} 

den Agenten Kompilieren:

g++ -fPIC -shared -olibnothreads.so -Wl,-soname,libnothreads.so nothreads.cpp 

Führen Sie die Anwendung mit dem Agenten:

java -agentpath:/path/to/libnothreads.so -jar app.jar 

Beachten Sie, dass Sie können auch Verwenden Sie JVMTI, um eine benutzerdefinierte Logik zu implementieren, um zu ermöglichen, wann neue Threads zugelassen oder abgelehnt werden. Zum Beispiel werden ThreadStart und ThreadEnd Ereignisse helfen, erstellte Threads zu zählen. GetStackTrace Funktion hilft zu finden, welche Klassen versuchen, einen Thread zu erstellen.

Answer 2

how can I prevent the threads opened in the java application but not those opened by the JVM ?

Ich bin nicht sicher, Sie können. Das Verhindern, dass die JVM Threads erstellt, ist so, als würde man die Anzahl der von ihr erstellten String s begrenzen. Wenn der Code einen Thread erstellt, können Sie nichts dagegen tun.

Über die einzige Sache, die helfen könnte, ist die Sicherheitsrichtlinie, aber wie ich es gelesen habe, Thread-Erstellung wird nicht gesteuert. Siehe Java's docs on the permissions under control.

java.lang.OutOfMemoryError: Cannot create GC thread. Out of system resources.

Wie Sie wahrscheinlich wissen, zusätzlich zu dem „main“ Thread startet Java eine Reihe von anderen JVM spezifischen Themen, die im Hintergrund arbeiten. Zum Beispiel startet ein einfaches main(String[] args) Programm "main" und weitere 5 Threads für mich, die die GC-Threads nicht enthalten, glaube ich. Die JVM-Threads werden für die Speicherverwaltung und andere wichtige Aufgaben benötigt. Wenn Sie Threads bis zu einem Punkt begrenzen, an dem die GC-Threads nicht starten können, wird die JVM überhaupt nicht ausgeführt werden können.

<HACK> Eine Sache, die Sie tun können, ist die Anzahl der Threads auf die genaue Anzahl zu begrenzen, um die System-Threads und "main" aufzunehmen. Innerhalb von main(), bevor der Benutzercode eine Möglichkeit hat, weitere Threads zu starten, können Sie die Anzahl der ausgeführten Threads unter Verwendung von Thread.getAllStackTraces().size() zählen und dann Ihre Betriebssystemgrenzwerte auf diese Zahl setzen. Wenn dies immer noch fehlschlägt, dann versuchen Sie 1 oder 2 zu size() hinzuzufügen, um andere Hintergrundthreads zu berücksichtigen, die in der Stack-Ablaufverfolgung nicht berücksichtigt wurden. </HACK>

All dies gesagt, die Frage, die ich habe, ist, was versuchst du zu erreichen? Wenn Sie sich Sorgen machen, dass ein Java-Prozess Ihren Server übernimmt, frage ich mich, ob es Betriebssystemeinstellungen gibt, die besser steuern, wie viele Systemressourcen dem Prozess zur Verfügung gestellt werden. Wie wäre es, die Nebenläufigkeit statt der Anzahl der Threads zu begrenzen? Vielleicht nach Thread-Affinitätseinstellungen suchen? Dies wäre jedoch sehr Betriebssystem abhängig.