Maison > Article > Java > Introduction à l'utilisation de quelques méthodes de base du multithreading en Java (avec exemples)

Introduction à l'utilisation de quelques méthodes de base du multithreading en Java (avec exemples)

不言avant: 2018-10-08 15:12:342531parcourir

Ce que cet article vous apporte est une introduction à l'utilisation de certaines méthodes de base en multi-threading en Java (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. à vous.

Thread sleep sleep()

Thread.sleep(milliseconds); Nous pouvons mettre le thread en veille via la méthode sleep. Vous pouvez voir que sleep est une méthode statique

public static native void sleep(long var0) throws InterruptedException;

    try {
        System.out.println(new Date().getSeconds());
        Thread.sleep(5000);
        System.out.println(new Date().getSeconds());
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

thread démon setDaemon

Le thread non-démon s'arrête, puis le thread démon se ferme automatiquement

    public static void main(String[] args) {
        Thread thread1 = new Thread() {
            @Override
            public void run() {
                super.run();
                for(int i = 0; i < 5; i ++) {
                    System.out.println("非守护线程");
                }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    System.out.println("守护线程");
                }
            }
        };

        thread2.setDaemon(true);
        thread1.start();
        thread2.start();
    }

Il est évident que j'ai vu que thread2 aurait dû exécuter 200 sorties, mais seules quelques lignes ont été sorties ici. Parce que lorsque thread1 termine son exécution, thread2 s'arrête automatiquement en tant que thread démon.
Introduction à l'utilisation de quelques méthodes de base du multithreading en Java (avec exemples)

Jion multithread

Si la méthode jion est exécutée, arrêtez le thread actuel et exécutez le thread qui a exécuté jion() en premier. Cela équivaut à sauter dans la file d’attente pour l’exécution. Comme suit, lors de l'exécution du thread thread2, si i==20, laissez thread1 sauter dans la file d'attente et exécuter la méthode

    public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println("thread1---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    if (i == 20) {
                        try {
                            //插队执行
                            thread1.join();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(i);
                }
            }
        };
        thread1.start();
        thread2.start();
    }

join(). Vous pouvez également passer le paramètre long millisecond join (millisecond).
pour exprimer Laissez le thread qui exécute join sauter dans la file d'attente et exécuter pour 🎜>

   public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println("thread1---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    if (i == 20) {
                        try {
                            //插队执行１毫秒
                            thread1.join(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(i);
                }
            }
        };
        thread1.start();
        thread2.start();
    }

setPriority définit la priorité du thread

La priorité par défaut est 5, minimum 1 , maximum 10

Plus la valeur est grande, plus la priorité est élevée

    public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println( getName() + "---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    if (i % 5 == 0) {
                        Thread.yield();
                    }
                    System.out.println(getName() + "---" + i);
                }
            }
        };
        thread1.start();
        thread2.start();
    }

synchronisé

Bloc de code synchronisé

Lorsque plusieurs threads sont simultanés et multiples des morceaux de code sont exécutés en même temps. J'espère que lors de l'exécution du code, le CPU ne changera pas de thread

    public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println( getName() + "---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 500; i ++) {

                    System.out.println(getName() + "---" + i);
                }
            }
        };
        //设置最大的线程优先级最大为10
        thread1.setPriority(Thread.MIN_PRIORITY);
        //设置最小的线程优先级，最小为１
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
        thread2.start();
    }

Situation sans synchronisation

Regardons ce qui se passera sans synchronisation

Nous avons constaté que certaines sorties n'étaient pas entièrement imprimées. Lors de l'exécution du thread thread1, le processeur a été préempté par le thread2. Dans ce cas, cela n’est définitivement pas conforme à notre logique métier. Nous devons donc nous assurer que le CPU sera préempté par d'autres threads seulement après que le thread ait exécuté une méthode complète

public class ThreadSynchronied {

    public static void main(String[] args) {
        final Say say = new Say();

         Thread thread1 = new Thread() {
            @Override
            public void run() {
                for (int i = 0 ; i < 10000 ; i ++) {
                    say.say();
                }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0 ; i < 10000 ; i ++) {
                    say.say1();
                }
            }
        };
        //设置最大的线程优先级最大为10
        thread1.setPriority(Thread.MIN_PRIORITY);
        //设置最小的线程优先级，最小为１
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
        thread2.start();
    }
}

class Say {
    void say() {
        System.out.print("s ");
        System.out.print("a ");
        System.out.print("y ");
        System.out.print("h ");
        System.out.print("e ");
        System.out.print("l ");
        System.out.print("l ");
        System.out.println("o");
    }

    void say1() {
        System.out.print("1 ");
        System.out.print("2 ");
        System.out.print("3 ");
        System.out.print("4 ");
        System.out.print("5 ");
        System.out.print("6 ");
        System.out.print("7 ");
        System.out.println("8");
    }
}

Utiliser synchronisé

Introduction à l'utilisation de quelques méthodes de base du multithreading en Java (avec exemples)

Utiliser synchronisé code de synchronisation Après le blocage, vous constaterez que la situation ci-dessus ne se produira pas

public class ThreadSynchronied {

    public static void main(String[] args) {
        final Say say = new Say();

         Thread thread1 = new Thread() {
            @Override
            public void run() {
                for (int i = 0 ; i < 10000 ; i ++) {
                    say.say();
                }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0 ; i < 10000 ; i ++) {
                    say.say1();
                }
            }
        };
        //设置最大的线程优先级最大为10
        thread1.setPriority(Thread.MIN_PRIORITY);
        //设置最小的线程优先级，最小为１
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
        thread2.start();
    }
}

class Say {
    String s = "hahaah";

    void say() {
        synchronized (s) {
            System.out.print("s ");
            System.out.print("a ");
            System.out.print("y ");
            System.out.print("h ");
            System.out.print("e ");
            System.out.print("l ");
            System.out.print("l ");
            System.out.println("o");
        }
    }

    void say1() {
        synchronized (s) {
            System.out.print("1 ");
            System.out.print("2 ");
            System.out.print("3 ");
            System.out.print("4 ");
            System.out.print("5 ");
            System.out.print("6 ");
            System.out.print("7 ");
            System.out.println("8");
        }
    }
}

Méthode de synchronisation

Introduction à l'utilisation de quelques méthodes de base du multithreading en Java (avec exemples)

La méthode de synchronisation fait référence au verrouillage de la méthode

L'objet du statique méthode de synchronisation C'est l'objet bytecode de cette classe

L'objet de verrouillage de la méthode de synchronisation non statique est-ce

public class ThreadSynchroniedMethod {

    public static void main(String[] args) {
        final Say say = new Say();

         Thread thread1 = new Thread() {
            @Override
            public void run() {
                for (int i = 0 ; i < 10000 ; i ++) {
                    say.say();
                }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0 ; i < 10000 ; i ++) {
                    say.say1();
                }
            }
        };
        //设置最大的线程优先级最大为10
        thread1.setPriority(Thread.MIN_PRIORITY);
        //设置最小的线程优先级，最小为１
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
        thread2.start();
    }
}

class Say {
    //在方法上加锁
    static synchronized void say() {
            System.out.print("s ");
            System.out.print("a ");
            System.out.print("y ");
            System.out.print("h ");
            System.out.print("e ");
            System.out.print("l ");
            System.out.print("l ");
            System.out.println("o");

    }

     static void say1() {
        synchronized (Say.class) {
            System.out.print("1 ");
            System.out.print("2 ");
            System.out.print("3 ");
            System.out.print("4 ");
            System.out.print("5 ");
            System.out.print("6 ");
            System.out.print("7 ");
            System.out.println("8");
        }
    }
}

Plusieurs threads utilisant le même verrou de ressource peuvent facilement provoquer un blocage

Qu'est-ce qu'un blocage ?

L'impasse fait référence à un phénomène de blocage provoqué par deux ou plusieurs processus en compétition pour les ressources ou communiquant entre eux pendant l'exécution, sans force externe, ils ne pourront pas avancer. À ce moment-là, on dit que le système est dans un état de blocage ou que le système est dans une impasse. Ces processus qui s'attendent toujours les uns les autres sont appelés processus de blocage.

Classe Thread-safe

Vector

StringBuffer
HashTable

Thread-unsafe

ArrayList
StringBuilder
HashSet

java.util.Collections a des méthodes telles que SynchronizedList, qui nous permettent de convertir des collections non sécurisées pour les threads en collections sécurisées pour les threads

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Java 线程多线程 Thread 并发对象 this

Déclaration：

Cet article est reproduit dans:. en cas de violation, veuillez contacter admin@php.cn Supprimer

Article précédent：Comment convertir Java Bean et Map entre eux ? (code)Article suivant：Comment convertir Java Bean et Map entre eux ? (code)

Articles Liés

Voir plus