Je confirme ce que j'ai dit sur les threads Java :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
start0();
if (stopBeforeStart) {
stop0(throwableFromStop);
}
} |
La méthode stop0 est native.
{"start0", "()V", (void *)&JVM_StartThread},
Le code de JVM_StartThread :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
JVMWrapper("JVM_StartThread");
JavaThread *native_thread = NULL;
// We cannot hold the Threads_lock when we throw an exception,
// due to rank ordering issues. Example: we might need to grab the
// Heap_lock while we construct the exception.
bool throw_illegal_thread_state = false;
// We must release the Threads_lock before we can post a jvmti event
// in Thread::start.
{
// Ensure that the C++ Thread and OSThread structures aren't freed before
// we operate.
MutexLocker mu(Threads_lock);
// Check to see if we're running a thread that's already exited or was
// stopped (is_stillborn) or is still active (thread is not NULL).
if (java_lang_Thread::is_stillborn(JNIHandles::resolve_non_null(jthread)) ||
java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) {
throw_illegal_thread_state = true;
} else {
jlong size =
java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));
// Allocate the C++ Thread structure and create the native thread. The
// stack size retrieved from java is signed, but the constructor takes
// size_t (an unsigned type), so avoid passing negative values which would
// result in really large stacks.
size_t sz = size > 0 ? (size_t) size : 0;
native_thread = new JavaThread(&thread_entry, sz);
// At this point it may be possible that no osthread was created for the
// JavaThread due to lack of memory. Check for this situation and throw
// an exception if necessary. Eventually we may want to change this so
// that we only grab the lock if the thread was created successfully -
// then we can also do this check and throw the exception in the
// JavaThread constructor.
if (native_thread->osthread() != NULL) {
// Note: the current thread is not being used within "prepare".
native_thread->prepare(jthread);
}
}
}
... |
Dans la ligne : native_thread = new JavaThread(&thread_entry, sz);
on a le démarrage du thread :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) : Thread() {
if (TraceThreadEvents) {
tty->print_cr("creating thread %p", this);
}
initialize();
_is_attaching = false;
set_entry_point(entry_point);
// Create the native thread itself.
// %note runtime_23
os::ThreadType thr_type = os::java_thread;
thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
os::java_thread;
os::create_thread(this, thr_type, stack_sz); |
Et os::create_threade qui est dépendant de l'OS, par exemple sous Linux :
1
2
3
4
5
6
7
|
bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
pthread_t tid;
int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);
} |
Simple appel système qui ne permet pas de choisir le processeur.
Utilisation d'un quadCore grace au threads?
Répondre avec citation
Avant de poster, pensez à regarder 
Envoyé par CyberChouan
"java openMP" ou "java MPI" devrait t'aider à avancer, je l'espère.
Partager