Les Threads Java vs OS Threads

On dirait que j'ai foiré avec les Threads Java/OS Threads et langage Interprété.

Avant de commencer, je ne comprends que le Fils Verts sont les Threads Java où le filetage est pris en charge par la JVM et l'ensemble du processus Java ne fonctionne que comme un OS unique Thread. Ainsi, sur un multi-processeur, système, il est inutile.

Maintenant mes questions est. J'ai deux Fils A et B. Chacune avec 100 de milliers de lignes de code indépendant. - Je exécuter ces threads dans mon Programme Java sur un système multiprocesseur. Chaque Thread va être donné un système d'exploitation natif Thread à EXÉCUTER qui peut s'exécuter sur un PROCESSEUR différent, mais depuis Java est interprété ces fils aura besoin pour interagir avec la JVM encore et encore pour convertir des octets de code pour les instructions machine ? Suis-je le droit ? Si oui, que pour les petits programmes Java Threads ne sera pas un gros avantage ?

Une fois le Hotspot compile à la fois ces chemins d'exécution à la fois peut être aussi bon en tant que natif des Threads ? Suis-je le droit ?

[EDIT] : Une autre question peut être, supposons que vous disposez d'un seul Fil de Java, dont le code n'est pas JIT compilé, vous devez créer ce Thread et start() il ? Comment fonctionne le système d'exploitation Fil et de la JVM interagissent pour exécuter le Bytecode ?

grâce

InformationsquelleAutor Geek | 2010-12-13
  1. 25

    Chaque Thread va être donné un système d'exploitation natif
    Thread à EXÉCUTER, et qui peut fonctionner sur un
    PROCESSEUR différent mais depuis Java est
    interprété ces threads requièrent
    pour interagir avec la JVM de nouveau et
    nouveau pour convertir le code d'octets à
    instructions machine ? Suis-je le droit ?

    Vous mélangez deux choses différentes; JIT fait par la machine virtuelle et le filetage de soutien offerts par la VM. Au plus profond, tout ce que vous faites se traduit par une sorte de code natif. Un byte-code d'instruction qui utilise des threads est pas différente de celle d'un JIT ed code qui accède à des threads.

    Si oui, que pour les petits programmes Java
    Les Threads ne sera pas un gros avantage ?

    Définir petite ici. Pour de courte durée des processus, oui, le filetage ne pas faire un gros écart depuis votre exécution séquentielle est assez rapide. Notez que cela dépend encore une fois sur le problème étant résolu. Pour les boîtes à outils d'INTERFACE utilisateur, peu importe la taille de l'application, une sorte de filetage/asynchrone, il est nécessaire de garder l'INTERFACE utilisateur réactive.

    Threading de sens que si vous avez des choses qui peut être exécutées en parallèle. Un exemple typique serait ce lourd IO sur le fil et le calcul dans l'autre. Vous ne voulez pas bloquer votre traitement juste parce que votre thread principal est bloqué en faisant IO.

    Une fois le Hotspot compile à la fois de ces
    les chemins d'exécution à la fois peut être aussi bon que
    natif des Threads ? Suis-je le droit ?

    Voir mon premier point.

    Threading n'est vraiment pas une solution miracle, esp quand il s'agit de l'idée répandue de "utiliser des threads pour faire de ce code d'aller plus vite". Un peu de lecture et d'expérience sera votre meilleur pari. Puis-je recommande d'obtenir une copie de ce livre génial? 🙂

    @Xavier: Enfaite maintenant je peux reformuler ma
    question. Si j'ai un Thread dont l'
    le code n'a pas été JIT serais comment le
    OS Fil de l'exécuter ?

    Encore une fois je vais le dire, le filetage est un tout autre concept de JIT. Essayons de regarder à l'exécution d'un programme en termes simples:

    java pkg.MyClass -> VM localise méthode
    à exécuter -> Début de l'exécution de la
    byte-code pour la méthode ligne par ligne ->
    convertir chaque byte-code d'instruction à
    ses natif de contrepartie -> instruction
    exécuté par OS -> instruction exécutée
    par la machine

    Lorsque le JIT a donné le coup:

    java pkg.MyClass -> VM localise méthode
    pour être exécuté qui a été JIT ed ->
    localiser les associés natif code
    pour cette méthode -> instruction
    exécuté par OS -> instruction exécutée
    par la machine

    Comme vous pouvez le voir, quelle que soit la voie que vous suivez, les VM instruction doit être mappé à son natif de contrepartie à un certain point dans le temps. Si ce code natif est stocké pour plus de ré-utiliser ou les jeter si une chose différente (optimisation, vous vous souvenez?).

    Donc pour répondre à votre question, à chaque fois que vous écrivez le filetage code, il est traduit en code natif et exécuter par l'OS. Si cette traduction est effectuée à la volée ou regardé jusqu'à ce point dans le temps, c'est une autre question.

    • Désolé pour le coup de gueule, cette réponse a obtenu beaucoup plus de temps que prévu. 😉
    • Si je comprends bien JIT sera fait avant même que le Thread s'exécute pour la première fois ? Essesntially la JVM ne le JIT pour les deux threads Indépendants et que les attaquants de l'OS de Fils pour l'exécution ?
    • Comme déjà mentionné, le JIT et l'exécution du thread sont deux orthogonaux questions. Oui, il est tout à fait possible que le morceau de code dans un Thread est sur le point d'exécuter aurait déjà été JIT ed par la VM. Aussi, il n'y a pas de redirection de l'exécution. Lorsqu'un start() méthode est appelée sur un objet Thread, un nouveau système d'exploitation natif thread est créé, il n'y a pas de transmission entre "le fil de Java" et "OS du fil". Aussi, JIT n'est pas obligatoire. Il peut donc arriver que votre fil serait actuellement de l'exécution du code qui n'a pas été JIT ed. JIT est une performance spécifique d'optimisation.
    • Comme vous l'avez dit ", Il pourrait donc arriver que votre fil serait actuellement de l'exécution du code qui n'a PAS été JIT ed." Donc, si c'est le cas, Comment fonctionne le système d'exploitation Fil interpréter le pseudo-code ? Il doit aller à la JVM de nouveau ? Donc, si à la fois le Fils A, B avez à faire cela, comment est-ce même à distance Filetée ? il est plus comme un ordre séquentiel. Ai-je raté quelque chose ?
    • Enfaite maintenant je peux reformuler ma question. Si j'ai un Fil dont le code n'a pas été JIT avait comment fonctionne le système d'exploitation Fil de l'exécuter ?
    • J'ai mis à jour ma principale réponse à résoudre votre requête.
    • Excellente réponse mate, je dois dire que j'ai appris quelque chose. Merci pour votre patience, je vais choisir cette réponse est la bonne réponse si je ne recoit aucune meilleure réponse 🙂

    InformationsquelleAutor Sanjay T. Sharma
  2. 11

    et l'ensemble du processus Java ne fonctionne que comme un OS unique Thread

    Ce n'est pas vrai. Donc pas spécifié, nous voyons souvent, que les threads Java sont en fait de système d'exploitation natif des threads et que multithread applications Java vraiment utiliser des processeurs multi-core ou multi-processeur plates-formes.

    Une recommandation commune est à l'aide d'un pool de threads où le nombre de threads est proportionnelle au nombre de noyaux (facteur de 1-1.5). C'est un autre indice, la JVM n'est pas limité à un seul OS thread /processus.

    De wkipedia:

    En Java 1.1, fils verts étaient le seul modèle de thread utilisé par la JVM,[4], au moins sur Solaris. En tant que fils verts ont quelques limitations par rapport aux threads natifs, ultérieure versions de Java abandonné en faveur de threads natifs.

    Maintenant, de retour en 2010 avec Java 7 sous-développement et de Java 8 prévu - sommes-nous vraiment toujours intéressé dans l'historique "fils verts"??

    • Je parlais uniquement sur certains Threads avant JDK j'.2 connu comme Fils Verts.
    • vous "mentionné" fils Verts, mais votre question était (regardant le titre) sur les threads Java en général. Merci d'éditer votre question, si vous êtes intéressé seulement par les fils verts et Java 1.1/1.2
    • Assurez-vous. En fait encas de Fils Verts, il est facile de comprendre comment Octet code de conversion est gérée par la JVM lors de l'exécution de deux threads parce que la JVM a le contrôle total. Je ne suis pas en mesure de le saisir en cas les deux threads s'exécutent comme des OS de Threads.
    • ce qui change ici en Java 7? Merci, seulement si vous avez le temps de répondre.
    InformationsquelleAutor Andreas_D
  3. 3
    1. Certaines Java-les mises en œuvre peuvent créer
      fils verts comme vous le décrire
      (planification faite par la JVM sur un
      seul thread natif), mais c'est normal
      les implémentations de Java sur l'utilisation de l'ordinateur
      plusieurs cœurs.
    2. La JVM elle-même peut déjà utiliser des threads différents pour le travail à faire (collecte des ordures, de chargement de classe, byte-code de vérification, JIT Compiler).
    3. Le système d'exploitation exécute un programme appelé JVM. La JVM qui exécute la Java Bytecode. Si tous les Java-Fil est associé à un thread natif (qui fait sens et qui semble être le cas sur PC-les implémentations), puis la JVM de code dans ce thread exécute la Java-code - JITed ou interprété comme sur un single-thread-programme. Pas de différence ici, à travers le multithreading.
    InformationsquelleAutor Mnementh
  4. 2

    Threading et l'exécution d'un octet de code sont des questions distinctes. Fils verts sont utilisés par la JVM sur les plates-formes qui n'ont pas de support natif des threads. (À mon humble avis, je ne sais pas quelle plate-forme ne prend pas en charge les threads).

    Byte code est interprété en temps réel et exécuté sur la plate-forme native par la JVM. JVM décide quels sont les plus populaires des fragments de code et effectue donc appelé tout à l'heure de la compilation de ces fragments, afin de ne pas avoir à les compiler, encore et encore. Ceci est indépendant sur le filetage. Si par exemple vous avez un thread qui exécute la même fragment de code dans la boucle de vous ce fragment sera mis en cache par le juste à temps compilateur.

    Bas de ligne: ne vous inquiétez pas au sujet de la performance et les threads. Java est assez forte pour exécuter tout ce que vous êtes de codage.

    • Java 1.0 sur Solaris utilisés fils verts. Pas sûr que quelqu'un a depuis, mais il est permis, dans la conception.
    • Donc comme vous l'avez dit, si j'ai tout le code par JIT ou par l'intermédiaire du point d'accès, je peux exécuter deux threads Java que deux Threads OS, juste assez. Mais je pense que la compilation JIT qui se passe sur le premier passage du code pour la première fois lorsque j'exécute le code qui lance deux threads les deux fils doivent être interprétés ? Donc JVM seront impliqués par le système d'exploitation de Threads.
    • Autant que je sache JVM crée un wrapper fin sur un thread natif. Tous les threads dans une application partagent la même mémoire, donc le code compilé en code natif sera partagé entre les threads.
    • Très près "du code compilé en natif.." quand est-ce possible pour tous les Threads liés à EXÉCUTER des Fonctions ? Il arrive même avant de l'EXÉCUTER méthodes sont appelées ? Si c'est le cas, je crois que j'ai compris le Puzzle 🙂
    • Je n'ai toujours pas complètement. Si le fil de java Un est mappé à l'OS thread B et B est planifiée pour s'exécuter sur le PROCESSEUR, comment est-ce que B obtenir code natif à partir d'Un? Ne JVM compiler du code octet et place du code natif à un endroit commun où B lit en permanence en code natif et qui sait instruction doit être exécutée suivant à chaque fois que B se fait de temps CPU?
    InformationsquelleAutor AlexR