java n'importe quoi mémo 2

Un mémo pour mon étude.

Zone mémoire

Une zone qui stocke la valeur des variables, des instances générées, l'historique des méthodes appelées, etc. L'endroit où ils sont stockés est géré par la JVM. Il existe deux types de zone mémoire

--Empiler --Tas

Il y a.

empiler

L'historique des appels de la méthode, la valeur de la variable (variable locale) déclarée dans la méthode. Lorsque la méthode termine le traitement, ces informations sont supprimées de la pile.

tas

Une instance générée à partir d'une classe. Lorsque l'instance n'est plus référencée par aucune variable (modifier la référence, affecter null) De plus, il est automatiquement libéré par le garbage collection de JVM.

fil

Il existe les deux types suivants.

Créer du multithreading

Il existe deux méthodes

--Créez une nouvelle classe qui hérite de la classe Thread --Créez une nouvelle classe qui implémente l'interface Runnable.

Faire avec la classe Thread

Créer une instance d'une classe qui hérite de la classe Thread Appelez la méthode de démarrage de cette instance.

C'est la méthode de démarrage qui s'exécute, Dans la sous-classe qui hérite de la classe Thread, Remplacez la méthode d'exécution de la classe Thread.

La méthode run est exécutée via la méthode start. Les résultats ne sont pas toujours les mêmes et changent à chaque fois qu'ils sont exécutés (parfois non)

class MyTread extends Thread{
    //REMARQUE: le niveau ne peut pas être abaissé en dessous du modificateur d'accès défini dans la superclasse.
    //Vous ne pouvez pas réduire la visibilité des méthodes héritées de Thread
    public void run() {
        for(int i = 0; i < 5; i++) {
            System.out.println("MyTread.run:"+i);
        }
    }
}

public class SampleProgram{
    public static void main(String[] args) {
        MyTread mt = new MyTread();
        mt.start();

        for(int i = 0; i < 5; i++) {
            System.out.println("main:"+i);
        }
    }
}

//résultat
main:0
main:1
main:2
MyTread.run:0
MyTread.run:1
MyTread.run:2
MyTread.run:3
main:3
MyTread.run:4
main:4

Créer avec l'interface exécutable

Ce n'est pas très différent de l'époque où il a été hérité et fabriqué.

class MyTread implements Runnable{
    public void run() {
        for(int i = 0; i < 5; i++) {
            System.out.println("MyTread.run:"+i);
        }
    }
}

public class SampleProgram{
    public static void main(String[] args) {
        MyTread mt = new MyTread();
        Thread t = new Thread(mt);
        t.start();

        for(int i = 0; i < 5; i++) {
            System.out.println("main:"+i);
        }
    }
}

Thread.sleep (milliseconde (= 1/1000 seconde))

Arrêtez le traitement des threads pendant un certain temps. L'unité est la milliseconde. 1000: 1 seconde 2000: 2 secondes

En micro secondes 1000000: 1 seconde

La méthode Thread.sleep peut lever une exception de type InterruptedException. Je dois l'attraper.

public class SampleProgram{
    public static void main(String[] args) {

        for(int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            }catch(InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("main:"+i);
        }
    }
}

//Je l'ai essayé avec celui qui implémentait l'interface Runnable
class MyTread implements Runnable {
    public void run() {
        for(int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                //Bloc de capture généré automatiquement TODO
                e.printStackTrace();
            }
            System.out.println("MyTread.run:"+i);
        }
    }
}

public class SampleProgram{
    public static void main(String[] args) {
        MyTread mt = new MyTread();
        Thread t = new Thread(mt);
        t.start();

        for(int i = 0; i < 5; i++) {
            System.out.println("main:"+i);
        }
    }
}

join()

Vous pouvez attendre le traitement du thread.

Parce que la méthode de jointure peut lever une exception de type InterruptedException Je dois l'attraper.

Une fois que tout le traitement de la classe MyTread est terminé, le traitement principal est exécuté.

class MyTread implements Runnable {
    public void run() {
        for(int i = 0; i < 5; i++) {
            System.out.println("MyTread.run:"+i);
        }
    }
}

public class SampleProgram{
    //Maintenant jetons.
    public static void main(String[] args) throws InterruptedException {
        MyTread mt = new MyTread();
        Thread t = new Thread(mt);
        t.start();

        t.join();
        for(int i = 0; i < 5; i++) {
            System.out.println("main:"+i);
        }
    }
}

Arrêtez le fil

Lorsque le traitement de la méthode d'exécution est terminé, le traitement de ce thread est terminé. Hmm ... laissons ça pour le moment.

Synchroniser.

Lors de l'exécution dans plusieurs threads, si plusieurs threads partagent la même valeur de variable Des incohérences peuvent survenir.

Ce qui suit est un programme dont le montant total sera de 1000000 yens

class Bank{
    static int money = 0;
    static void addOneYen() {
        money++;
    }
}
class Customer extends Thread{
    public void run() {
        for(int i = 0; i < 10000; i++) {
            Bank.addOneYen();
        }
    }
}
public class MultiThreadEx {
    public static void main(String[] args) {
        Customer[] customers = new Customer[100];
        for(int i = 0; i < 100; i++) {
            customers[i] = new Customer();
            customers[i].start();
        }

        for(int i = 0; i < 100; i++) {
            try {
                customers[i].join();
            }catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Bank.money["+Bank.money+"]");
    }
}

//résultat
Bank.money[628887]

Parce qu'il n'y a pas de cohérence entre chaque menace au moment du référencement / de la mise à jour du montant actuel. Le montant total tourne mal. Dans un tel cas, ajoutez "synchronized" avant la méthode addOneYen.

    static synchronized void addOneYen() {
        money++;
    }

Si vous préfixez la méthode avec synchronized, vous ne pouvez exécuter qu'un seul thread à la fois. Lorsqu'une menace est en cours de traitement, l'autre menace attend son tour.

Recommended Posts

java quoi que ce soit mémo
java n'importe quoi mémo 2
Mémo Java
Mémo Java Silver
java, mémo maven
Remarque sur Java SE 7
Mémo de spécification Java
Mémo de modèle Java
mémo de connaissances de base java
Mémo d'apprentissage Java (méthode)
java se 8 programmeur Ⅰ mémo
Mémo privé payant Java
Mémo d'apprentissage Java (basique)
mémo d'expression java lambda
(Mémo) Java pour instruction
expression lambda java [écriture de notes]
Mémo d'apprentissage Java (interface)
[Java] Mémo d'héritage implicite
Mémo d'apprentissage Java (héritage)
mémo de programmation du concours java
[Mémo] Liste liée Java
Remarque sur Java (WebSphere Application Server) [1]
[Java] Mémo de nom du nom de variable
Sous-chaîne de mémo Java (classe standard)
Mémo d'apprentissage Java (type de données)
Longueur du mémo Java (classe standard)
Mémo de la méthode d'étude Java Silver
Créer une méthode java [Memo] [java11]
Mémo de préparation à l'examen Java Silver
Mémo d'apprentissage Java (opérateur logique)
Java
Mémo d'apprentissage Java (classe abstraite)
[Java] Date Termes associés mémo
Mémo d'étude Java 2 avec Progate
Java
Que sont les métriques Java? _Memo_20200818
Java HashMap, entrySet [Mémo personnel]
[Eclipse Java] Mémo des paramètres de l'environnement de développement
Mémo d'apprentissage Java (création d'un tableau)
Mémo personnel: métaprogrammation avec réflexion Java
Mémo d'utilisation de JCA (Java Encryption Architecture)
[Mémo de la session d'étude] Java Day Tokyo 2017
Mémo d'apprentissage Java (instruction while, instruction do-while)
De Java à VB.NET - Écriture de notes de contraste
Trébuchement de java débutant [rédaction de mémos]
[Java] Mémo de méthode de mesure du temps de traitement
J'ai essayé d'utiliser le mémo Java LocalDate
Mémo entier
Apprendre Java (0)
Étudier Java ―― 3
[Java] tableau
[Java] Annotation
Module [Java]
Tableau Java
Astuces Java, astuces
(Mémo d'apprentissage) Mesures Java Niveau 2: Plage de questions
Méthodes Java
Méthode Java