当前位置:网站首页>(obligatoire pour les grandes usines) Le Directeur de l'usine reste debout tard pour faire exploser le foie avec la programmation juc Multi - threaded High (1) La jeune fille de l'école a été collectée

(obligatoire pour les grandes usines) Le Directeur de l'usine reste debout tard pour faire exploser le foie avec la programmation juc Multi - threaded High (1) La jeune fille de l'école a été collectée

2021-10-14 05:05:23 Directeur d'usine Java

(Un must - have pour une grande usine)Le Directeur de l'usine est resté debout tard, le foie a explosé, le Multithreading est élevé et la concurrence estJUCProgrammation(Un.)La sœur cadette a collecté

️‍ Bonjour tout le monde,Je suisjavaDirecteur d'usine,Aujourd'hui, faites l'expérience d'une haute fréquence d'entrevue multithreadée et simultanée!️‍

À propos de l'auteur

  • Présentation de l'auteur

Page d'accueil du blog:Page d'accueil de l'auteur

Introduction:JAVADomaine créateur de haute qualité、Un étudiant de troisième année、Participer à diverses compétitions provinciales pendant l'école、National race,Une série d'honneurs.

Concentre - toi sur moi.:Suivez mon matériel d'apprentissage、Tous les téléchargements de documents sont disponibles,Mise à jour quotidienne des articles,Inspirez - vous en tant queJAVASenior Program singe.

JUCApprendre

1、Qu'est - ce queJUC

image-20211009154114352
Code source+Documents officiels

JUC- Oui. java util concurrent

Entrevue Questions fréquentes JUC~!

image-20210905132518254

java.util - Oui.Java Un kit pour

Les affaires: Code de fil normal Thread

Runnable: Aucune valeur de retour、 Efficacité comparée à Callable Relativement faible!

image-20210905132651962

2、Fils et processus

Processus:Un programme, Autoriser un java Le processus de réunion du programme aura un java.exe;Données+Code+pcb

Un processus peut contenir plusieurs threads, Contient au moins un thread !

Java Il y a plusieurs Threads par défaut ?2Threads! mainThread、GCThread

Thread: Un processus a été lancé qq, Chat dactylographié ,Message prompt( Thread est responsable de )

PourJavaEn termes:Thread、Runable、Callable Pour ouvrir le fil .

JAVA Est - ce vraiment possible d'activer le thread ? Ça ne marche pas !
RaisonsJava Pas de permission d'ouvrir le thread 、 Pour faire fonctionner le matériel ,C'est unnative Une méthode locale pour , Il appelle le C++Code.

Concurrence、Parallèle

Concurrence: Plusieurs Threads manipulent la même ressource .

  • CPU Il n'y a qu'un seul noyau , Simuler plusieurs fils ,Alors nous pouvons utiliserCPU Alternance rapide , Pour simuler le Multithreading .

Parallèle: Plusieurs personnes et rangées .

  • CPUMulticentrique,Plusieurs Threads peuvent être exécutés simultanément.
public class Test {
    
    public static void main(String[] args) {
    
        //AccèscpuNombre de noyaux
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

La nature de la programmation simultanée :Tirer le meilleur parti deCPURessources!

Threaded6Statut

public enum State {
    
    	//Création
        NEW,

    	//Exécution
        RUNNABLE,
    
    	//Blocage
        BLOCKED,
    
    	//Attendez.
        WAITING,
    
    	//Délai d'attente
        TIMED_WAITING,

    	//Résiliation
        TERMINATED;
    }

Questions d'entrevue:Un mot.waitEtsleepLa différence?

La différence wait sleep
Classe d'opération Object Thread
Libération de la serrure Ça libère la serrure. Dormir avec une serrure
Champ d'application Synchroniser le bloc de code N'importe où.
Capture d'exception Aucune exception n'est requise Exception à saisir

3、LockVerrouillage(Points saillants)

synchronizedProblème de verrouillage

package com.zmz.day01;
/** * @ProjectName: Juc * @Package: com.zmz.day01 * @ClassName: TicketTest * @Author: Zhang shengrui * @Date: 2021/9/5 14:01 * @Version: 1.0 */
//Catégorie de ressources Propriétés + Méthodes oop
class Ticket{
    
    private int num = 50;
    // Mode de vente des billets  synchronized Nature:File d'attente Verrouillage
    public synchronized void sale(){
    
        if(num > 0){
    
            System.out.println(Thread.currentThread().getName()+ " Vendu par"+ num +" Un billet.,Reste:"+ --num +" Un billet.");
        }
    }
}


public class TicketTest {
    
    public static void main(String[] args) {
    
        // Opération multiligne 
        //Concurrence:Plusieurs Threads manipulent la même ressourceticket
        Ticket ticket = new Ticket();
        //@FunctionalInterface Interface fonctionnelle jdk1.8Après lambdaExpression
        new Thread(()->{
    
            for (int i = 0; i < 60; i++) {
    
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
    
            for (int i = 0; i < 60; i++) {
    
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
    
            for (int i = 0; i < 60; i++) {
    
                ticket.sale();
            }
        },"C").start();
    }
}

LockInterface

image-20210905160728862

image-20210905161116623

image-20210905161329587

Verrouillage équitable: L'équité, Tu dois venir avant. ~;

Serrure injuste: C'est pas juste.,On peut faire la queue.;(Par défaut à une serrure injuste)

UtiliserLockExécution des opérations

package com.zmz.day01;/** * @ProjectName: Juc * @Package: com.zmz.day01 * @ClassName: TicketTest2 * @Author: Zhang shengrui * @Date: 2021/9/5 16:15 * @Version: 1.0 */

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/** *@ClassName TicketTest2 *@Description *@Author Zhang shengrui *@Date 2021/9/5 **/

class Ticket2{
    
    /* *  Trois étapes pour verrouiller  * 1.InstanciationlockObjet * 2.lockVerrouillage * 3.unlockDéverrouiller * */
    Lock l = new ReentrantLock();
    private int num = 50;
    // Mode de vente des billets  synchronized Nature:File d'attente Verrouillage
    public  void sale(){
    
        //Verrouillage
        l.lock();
        try {
    
            //Code d'entreprise
            if(num > 0){
    
                System.out.println(Thread.currentThread().getName()+ " Vendu par"+ num +" Un billet.,Reste:"+ --num +" Un billet.");
            }
        } catch (Exception e) {
    
            e.printStackTrace();
        } finally {
    
            //Déverrouiller
            l.unlock();
        }
    }
}


public class TicketTest2 {
    
    public static void main(String[] args) {
    
        // Opération multiligne 
        //Concurrence:Plusieurs Threads manipulent la même ressourceticket
        Ticket ticket = new Ticket();
        //@FunctionalInterface Interface fonctionnelle jdk1.8Après lambdaExpression
        new Thread(()->{
    
            for (int i = 0; i < 60; i++) {
    
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
    
            for (int i = 0; i < 60; i++) {
    
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
    
            for (int i = 0; i < 60; i++) {
    
                ticket.sale();
            }
        },"C").start();
    }
}
La différence synchronized lock
Nom Appartient au mot - clé Appartient à l'objet
Statut Impossible d'obtenir l'état de la serrure L'état de la serrure peut être obtenu
Gestion des serrures Verrouillage automatique Verrouillage manuel et déverrouillage requis
Thread Tenir la serrure Attendez.
Verrouillage réinscriptible, Non interruptible , Injuste Rechargeable ,On peut juger la serrure, Vous pouvez régler vous - même les serrures justes et injustes
Synchronisation des codes Convient pour une petite synchronisation de code Idéal pour une grande synchronisation de code

4、Questions relatives aux producteurs et aux consommateurs

synchronizedÉdition

package com.zmz.day01;
/** * @ProjectName: Juc * @Package: com.zmz.day01 * @ClassName: TicketTest3 * @Author: Zhang shengrui * @Date: 2021/9/5 16:35 * @Version: 1.0 */

/** *@ClassName TicketTest3 *@Description *@Author Zhang shengrui *@Date 2021/9/5 **/
public class TicketTest3 {
    
    public static void main(String[] args) {
    
        Data data = new Data();
        new Thread(()->{
    
            for (int i = 0; i < 10; i++) {
    
                try {
    
                    data.increment();
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
    
            for (int i = 0; i < 10; i++) {
    
                try {
    
                    data.decrement();
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}


// Le jugement attend  Les affaires Réveillez - vous.
class Data{
    
    private int number = 0;
    // +1Fonctionnement
    public synchronized void increment() throws InterruptedException {
    
        if(number != 0 ){
    
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
    // -1Fonctionnement
    public synchronized void decrement() throws InterruptedException{
    
        if (number == 0){
    
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
}

Le problème existe ,AThreadBThread, Si j'avais quatre fils A B C D! Comment résoudre le problème

image-20210905165744242

if Le jugement est remplacé par While Le jugement peut résoudre le problème du faux réveil .

package com.zmz.day01;
/** * @ProjectName: Juc * @Package: com.zmz.day01 * @ClassName: TicketTest3 * @Author: Zhang shengrui * @Date: 2021/9/5 16:35 * @Version: 1.0 */

/** *@ClassName TicketTest3 *@Description *@Author Zhang shengrui *@Date 2021/9/5 **/
// Problèmes de communication entre les fils : Problèmes des producteurs et des consommateurs ! Attendez de vous réveiller, Alerte au réveil 
// Les fils alternent  A B Utiliser la même ressource 
public class TicketTest3 {
    
    public static void main(String[] args) {
    
        Data data = new Data();
        new Thread(()->{
    
            for (int i = 0; i < 10; i++) {
    
                try {
    
                    data.increment();
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
    
            for (int i = 0; i < 10; i++) {
    
                try {
    
                    data.decrement();
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
    
            for (int i = 0; i < 10; i++) {
    
                try {
    
                    data.decrement();
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
    
            for (int i = 0; i < 10; i++) {
    
                try {
    
                    data.decrement();
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}


// Le jugement attend  Les affaires Réveillez - vous.
class Data{
    
    private int number = 0;
    // +1Fonctionnement
    public synchronized void increment() throws InterruptedException {
    
        while(number != 0 ){
    
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
    // -1Fonctionnement
    public synchronized void decrement() throws InterruptedException{
    
        while (number == 0){
    
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
}

JUC Version de la résolution A B C DProblèmes multithreadés

image-20210905193408839

package com.zmz.day01;
/** * @ProjectName: Juc * @Package: com.zmz.day01 * @ClassName: JucTest1 * @Author: Zhang shengrui * @Date: 2021/9/5 19:34 * @Version: 1.0 */

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/** *@ClassName JucTest1 *@Description *@Author Zhang shengrui *@Date 2021/9/5 **/
public class JucTest1 {
    
    public static void main(String[] args) {
    
        Data2 data = new Data2();

        new Thread(()->{
    for(int i=0;i<10;i++) {
    
            data.increment();
        }
        },"A").start();
        new Thread(()->{
    for(int i=0;i<10;i++) {
    
            data.decrement();
        }},"B").start();
        new Thread(()->{
    for(int i=0;i<10;i++) {
    
            data.increment();
        }
        },"C").start();
        new Thread(()->{
    for(int i=0;i<10;i++) {
    
            data.decrement();
        }
        },"D").start();
    }
}


class Data2{
    
    private int number = 0;
    //lockVerrouillage
    Lock l = new ReentrantLock();
    Condition condition = l.newCondition();

    public void increment() {
    
        l.lock();
        try {
    
            //Les affaires
            while (number!=0){
    
                // Attendez l'opération 
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            // Aviser les autres fils  - moi.+1Terminé.
            condition.signalAll();
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        } finally {
    
            l.unlock();
        }
    }

    public void decrement()  {
    
        l.lock();
        try {
    
            //Les affaires
            while (number==0){
    
                // Attendez l'opération 
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            // Aviser les autres fils  - moi.-1Terminé.
            condition.signalAll();
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        } finally {
    
            l.unlock();
        }
    }
}

ConditionAvantages: Notification précise 、 Fils réveillés

package com.zmz.day01;
/**
 * @ProjectName: Juc
 * @Package: com.zmz.day01
 * @ClassName: JucTest2
 * @Author: Zhang shengrui
 * @Date: 2021/9/5 19:52
 * @Version: 1.0
 */

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 *@ClassName JucTest2
 *@Description
 *@Author Zhang shengrui
 *@Date 2021/9/5
 **/
public class JucTest2 {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printC();
            }
        },"C").start();
    }
}


class Data3{
    private Lock l = new ReentrantLock();
    Condition condition1 = l.newCondition();
    Condition condition2 = l.newCondition();
    Condition condition3 = l.newCondition();

    private int flag = 1;
    public void printA(){
        l.lock();
        //Jugement -> Mise en œuvre -> Notification
        try {
            while(flag != 1){
                //Attendez.
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "->A" );
            flag = 2;
            // Réveiller le thread spécifié 
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            l.unlock();
        }
    }

    public void printB(){
        l.lock();
        //Jugement -> Mise en œuvre -> Notification
        try {
            while(flag != 2){
                //Attendez.
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "->BB" );
            flag = 3;
            // Réveiller le thread spécifié 
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            l.unlock();
        }
    }

    public void printC(){
        l.lock();
        //Jugement -> Mise en œuvre -> Notification
        try {
            while(flag != 3){
                //Attendez.
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "->CCC" );
            flag = 1;
            // Réveiller le thread spécifié 
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            l.unlock();
        }
    }
}

5、8Phénomène de verrouillage

1-2Verrouillage

package com.zmz.lock8;/** * @ProjectName: Juc * @Package: com.zmz.lock8 * @ClassName: Test1 * @Author: Zhang shengrui * @Date: 2021/9/5 21:18 * @Version: 1.0 */

import java.util.concurrent.TimeUnit;

/** *@ClassName Test1 *@Description *@Author Zhang shengrui *@Date 2021/9/5 **/
/* * 8Verrouillage, C'est à propos de la serrure 8Questions * 1、 Dans des circonstances normales , Les deux fils impriment d'abord   Envoyer un SMS ou téléphoner ? Envoyer un SMS * 2、sendSms Retard de la méthode 4s, Les deux fils impriment d'abord   Envoyer un SMS ou téléphoner ? Envoyer un SMS * */
public class Test1 {
    
    public static void main(String[] args) {
    
        Phone phone = new Phone();

        // La serrure existe 
        new Thread(()->{
    
            phone.sendSms();
        },"A").start();

        try {
    
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }

        new Thread(()->{
    
            phone.call();
        },"B").start();
    }
}


class Phone{
    

    //synchronized L'objet de la serrure est l'appelant de la méthode !
    // Les deux méthodes utilisent phoneVerrouillage de l'objet!
    // Celui qui l'a eu en premier, celui qui l'a exécuté !
    public synchronized void sendSms(){
    
        try {
    
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
        System.out.println("Envoyer un SMS");
    }
    public synchronized void call(){
    
        System.out.println("Appelle");
    }
}

image-20210906195336972

3-4Verrouillage

package com.zmz.lock8;/** * @ProjectName: Juc * @Package: com.zmz.lock8 * @ClassName: Test2 * @Author: Zhang shengrui * @Date: 2021/9/5 21:26 * @Version: 1.0 */

import java.util.concurrent.TimeUnit;

/** *@ClassName Test2 *@Description *@Author Zhang shengrui *@Date 2021/9/5 **/
//3、 Après l'ajout d'une méthode commune !  Envoyer un SMS ou Hello,Envoyer un SMS hello
//4、Deux objets,Deux méthodes de synchronisation, Envoyer un SMS ou téléphoner  Appelle
public class Test2 {
    
    public static void main(String[] args) {
    
        //Deux objets,Deux serrures
        Phone2 phone = new Phone2();
        Phone2 phone2 = new Phone2();

        // La serrure existe 
        new Thread(()->{
    
            phone.sendSms();
        },"A").start();

        try {
    
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }

        new Thread(()->{
    
            phone2.call();
        },"B").start();


    }
}
class Phone2{
    

    //synchronized L'objet de la serrure est l'appelant de la méthode !

    public synchronized void sendSms(){
    
        try {
    
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
        System.out.println("Envoyer un SMS");
    }
    public synchronized void call(){
    
        System.out.println("Appelle");
    }

    // Il n'y a pas de serrure ici !bubu Pas de méthode de synchronisation , Non affecté par la serrure 
  public void hello(){
    
        System.out.println("hello");
    }
}

image-20210906195522569

image-20210906195548823

5-6Verrouillage

package com.zmz.lock8;/** * @ProjectName: Juc * @Package: com.zmz.lock8 * @ClassName: Test3 * @Author: Zhang shengrui * @Date: 2021/9/6 12:35 * @Version: 1.0 */

import java.util.concurrent.TimeUnit;

/** *@ClassName Test3 *@Description *@Author Zhang shengrui *@Date 2021/9/6 **/
/* * 5、 Ajouter deux méthodes de synchronisation statique , Il n'y a qu'un seul objet , Imprimez d'abord un SMS ou appelez ? Envoyer un SMS * 6、Deux objets! Ajouter deux méthodes de synchronisation statique , Il n'y a qu'un seul objet , Imprimez d'abord un SMS ou appelez  Envoyer un SMS * */
public class Test3 {
    
    public static void main(String[] args) {
    
        //Deux objets, Deux appelants ,Deux serrures!
        //Deux objetsclass Il n'y a qu'un seul modèle de classe ,static,La serrure estClass
        Phone3 phone = new Phone3();
        Phone3 phone2 = new Phone3();
        // La serrure existe 
        new Thread(()->{
    
            phone.sendSms();
        },"A").start();

        try {
    
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }

        new Thread(()->{
    
            phone2.call();
        },"B").start();


    }
}
//Phone3Le seulClassObjet
class Phone3{
    

    //synchronized L'objet de la serrure est l'appelant de la méthode !
    //static Méthode statique
    // Une fois la classe chargée !Class Modèle La serrure estClass
    public static synchronized void sendSms(){
    
        try {
    
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
        System.out.println("Envoyer un SMS");
    }
    public static synchronized void call(){
    
        System.out.println("Appelle");
    }
}

image-20210906195751643

7-8Verrouillage

package com.zmz.lock8;/** * @ProjectName: Juc * @Package: com.zmz.lock8 * @ClassName: Test4 * @Author: Zhang shengrui * @Date: 2021/9/6 13:07 * @Version: 1.0 */

import java.util.concurrent.TimeUnit;

/** *@ClassName Test4 *@Description *@Author Zhang shengrui *@Date 2021/9/6 **/
/* * 1 Méthodes de synchronisation statique ,1 Méthodes de synchronisation ,1Objets  Imprimez d'abord un SMS ou appelez ? Appelle * 1 Méthodes de synchronisation statique ,1 Méthodes de synchronisation ,2Objets  Imprimez d'abord un SMS ou appelez ? Envoyer un SMS * */
public class Test4 {
    
    public static void main(String[] args) {
    
        //Deux objets, Deux appelants ,Deux serrures!
        //Deux objetsclass Il n'y a qu'un seul modèle de classe ,static,La serrure estClass
        Phone4 phone = new Phone4();
        // La serrure existe 
        new Thread(()->{
    
            phone.sendSms();
        },"A").start();

        try {
    
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }

        new Thread(()->{
    
            phone.call();
        },"B").start();


    }
}
//Phone4Le seulClassObjet
class Phone4{
    

    //synchronized L'objet de la serrure est l'appelant de la méthode !
    //La serrure estClassModèle de classe
    public static synchronized void sendSms(){
    
        try {
    
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
        System.out.println("Envoyer un SMS");
    }
    // C'est l'appelant 
    public synchronized void call(){
    
        System.out.println("Appelle");
    }


}

image-20210906200040197

6、La collection n'est pas sécurisée

1、ArrayListLa collection n'est pas sécurisée

package com;/** * @ProjectName: Juc * @Package: com * @ClassName: unsafe * @Author: Zhang shengrui * @Date: 2021/9/6 19:37 * @Version: 1.0 */

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

/** *@ClassName unsafe *@Description *@Author Zhang shengrui *@Date 2021/9/6 **/
public class unsafe {
    
    public static void main(String[] args) {
    
        // Haut et haut ArrayList Est - ce vraiment sûr ?
        /** * Solutions * 1、List<String> list = new Vector<String>(); * 2、List<String> list = Collections.synchronizedList(new ArrayList<>()); * 3、List<String> list = new CopyOnWriteArrayList<>(); * */
        List<String> list = new CopyOnWriteArrayList<>();
        //Démarrage10 Multithreads 
        for (int i = 1; i < 10; i++) {
    
            new Thread(() -> {
    
                list.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

CopyOnWriteArrayListAnalyse des sources

image-20210906201711960

2、SetC'est dangereux.

package com.zmz.unsafe;/** * @ProjectName: Juc * @Package: com.zmz.unsafe * @ClassName: SetSafe * @Author: Zhang shengrui * @Date: 2021/9/6 21:20 * @Version: 1.0 */

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

/** *@ClassName SetSafe *@Description *@Author Zhang shengrui *@Date 2021/9/6 **/
public class SetSafe {
    
    public static void main(String[] args) {
    
        //Set<String> set = new HashSet<>();
        //Set<String> set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 1; i < 60; i++) {
    
            new Thread(() -> {
    
                set.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(set);
            }, String.valueOf(i)).start();
        }
    }
}

HashSetCode source

    public HashSet() {
    
        map = new HashMap<>();
    }

  //HashSetL'essence estMapEnsemble
  public boolean add(E e) {
    
        return map.put(e, PRESENT)==null;
    }

private static final Object PRESENT = new Object();//Valeur constante

3、HashMapC'est dangereux.

package com.zmz.unsafe;/** * @ProjectName: Juc * @Package: com.zmz.unsafe * @ClassName: MapSafe * @Author: Zhang shengrui * @Date: 2021/9/6 21:27 * @Version: 1.0 */

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

/** *@ClassName MapSafe *@Description *@Author Zhang shengrui *@Date 2021/9/6 **/
public class MapSafe {
    
    public static void main(String[] args) {
    
        //Map<String,String> map = new HashMap<>();
        //Map<String, Object> map = Collections.synchronizedMap(new HashMap<>());
        Map<String, Object> map = new ConcurrentHashMap<>();

        for (int i = 1; i <= 30; i++) {
    
            new Thread(()->{
    
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

7、Callable

image-20211003164617870

  1. Peut avoir une valeur de retour
  2. Peut lancer une exception
  3. Différentes méthodes,run()/call()

callableCode source

image-20211003171412542

image-20211003172936108

image-20211003173013110

image-20211004170058503

Test de code

package com.zmz.callable;/** * @ProjectName: Juc * @Package: com.zmz.callable * @ClassName: CallableTest * @Author: Zhang shengrui * @Date: 2021/10/3 16:52 * @Version: 1.0 */

import com.sun.org.apache.bcel.internal.generic.NEW;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/** *@ClassName CallableTest *@Description *@Author Zhang shengrui *@Date 2021/10/3 **/
public class CallableTest {
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
    
        // new Thread(new Runnable()).start();
        // new Thread(new FutureTask<V>()).start();
        // new Thread(new FutureTask<V>( Callable )).start();

        new Thread().start();

        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask(myThread);//Adaptateur

        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start(); // Il en résulte une efficacité de soumission du cache 
        Integer o = (Integer) futureTask.get();// Obtenir les résultats retournés 
        //C'estget La méthode peut causer un blocage ! Solutions  Sur la dernière ligne ou la communication asynchrone 
        System.out.println(o);
    }
}
class MyThread implements Callable<Integer>{
    

    @Override
    public Integer call() throws Exception {
    
        System.out.println("call()Méthodes");
        //Opérations longues
        return 1024;
    }
}
/* 1、Cache 2、 Les résultats peuvent attendre ,Blocage */

8、Classe auxiliaire commune

1) CountDownLatch— Compteur de soustraction

package com.zmz.assist;/** * @ProjectName: Juc * @Package: com.zmz.assist * @ClassName: CountDownLatchDemo * @Author: Zhang shengrui * @Date: 2021/10/3 18:00 * @Version: 1.0 */

import java.util.concurrent.CountDownLatch;

/** *@ClassName CountDownLatchDemo *@Description *@Author Zhang shengrui *@Date 2021/10/3 **/
public class CountDownLatchDemo {
    
    public static void main(String[] args) throws InterruptedException {
    
        CountDownLatch count = new CountDownLatch(10);
        for (int i = 1; i <= 10; i++) {
    
            new Thread(()->{
    
                System.out.println(Thread.currentThread().getName() + "Go out");
                count.countDown();//Nombre-1
            },String.valueOf(i)).start();

        }
        count.await();// Attendez que le compteur soit à zéro , Et puis on descend 
        System.out.println("Close Door");
    }
}

Principes:

  • count.countDown();//Nombre-1
  • count.await();//Attendez que le compteur soit à zéro.Et puis on descend

Pour chaque fil countDown()Nombre-1, Si la calculatrice devient 0C'est,Et puiscount.await() Se réveiller , Poursuivre l'exécution ci - dessous !

2) CyclicBarrier— Compteur d'addition

package com.zmz.assist;/** * @ProjectName: Juc * @Package: com.zmz.assist * @ClassName: CycilcBarrierDemo * @Author: Zhang shengrui * @Date: 2021/10/3 18:23 * @Version: 1.0 */

import com.sun.org.apache.bcel.internal.generic.NEW;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/** *@ClassName CycilcBarrierDemo *@Description *@Author Zhang shengrui *@Date 2021/10/3 **/
public class CycilcBarrierDemo {
    
    public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
    
        CyclicBarrier barrier = new CyclicBarrier(7,()->{
    
            System.out.println(" Tu as rassemblé sept perles de dragon ! Peut se transformer ");
        });

        for (int i = 1; i <= 7; i++) {
    
            final int temp = i;
            new Thread(()->{
    
                System.out.println(Thread.currentThread().getName()+ "Collecte" +(temp) +" Une perle de dragon ");
                try {
    
                    barrier.await();//Attendez.
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
    
                    e.printStackTrace();
                }
            }).start();
        }

    }
}

3) Semaphore

Semaphore:Sémaphore, Souvent utilisé pour gérer une forte concurrence .

image-20211003192250711

package com.zmz.assist;/** * @ProjectName: Juc * @Package: com.zmz.assist * @ClassName: SemaphoreDemo * @Author: Zhang shengrui * @Date: 2021/10/3 19:32 * @Version: 1.0 */

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/** *@ClassName SemaphoreDemo *@Description *@Author Zhang shengrui *@Date 2021/10/3 **/
public class SemaphoreDemo {
    
    public static void main(String[] args) {
    
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {
    
            new Thread(()->{
    
                try {
    
                    semaphore.acquire();//Obtenir
                    System.out.println(Thread.currentThread().getName()+" Obtenir une place de parking ");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"Quitter le parking");
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }   finally {
    
                    semaphore.release();//Release
                }

            },String.valueOf(i)).start();
        }

    }
}

Principes:

  • acquire():Obtenir, Supposons que le Groupe soit plein et qu'il ait besoin d'attendre , Jusqu'à ce qu'il soit libéré

  • release():Release, Libère le sémaphore actuel +1, Puis Réveillez le fil d'attente !

    Action: Plusieurs ressources partagées sont mutuellement exclusives ! Nombre maximum de fils pour le contrôle simultané des limites de courant !

9、Lire et écrire la serrureReadwriteLock

image-20211003195425532

package com.zmz.lock;/** * @ProjectName: Juc * @Package: com.zmz.lock * @ClassName: ReadwritelockDemo * @Author: Zhang shengrui * @Date: 2021/10/3 20:48 * @Version: 1.0 */

import java.util.HashMap;
import java.util.Map;

/** *@ClassName ReadwritelockDemo *@Description *@Author Zhang shengrui *@Date 2021/10/3 **/
public class ReadwritelockDemo {
    
    public static void main(String[] args) {
    
        Mycache mycache = new Mycache();
        //Écrire
        for (int i = 1; i < 6; i++) {
    
            final int temp = i;
            new Thread(()->{
    
                mycache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        //Lire
        for (int i = 1; i < 6; i++) {
    
            final int temp = i;
            new Thread(()->{
    
                mycache.get(temp+"");
            },String.valueOf(i)).start();
        }
    }
}

class Mycache{
    
    private volatile Map<String , Object> map = new HashMap<>();
    public void put(String key, Object value){
    
        System.out.println(Thread.currentThread().getName() + "Écrire" + key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName() + "Écrire terminé");
    }

    public void get(String key){
    
        System.out.println(Thread.currentThread().getName() + "Lire" + key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName() + "Lecture terminée");
    }
}

/* 1Écrire1 5Écrire5 5Écrire terminé 4Écrire4 4Écrire terminé 3Écrire3 2Écrire2 1Lire1 3Écrire terminé 1Écrire terminé 2Lire2 2Lecture terminée 3Lire3 3Lecture terminée 1Lecture terminée 2Écrire terminé 5Lire5 5Lecture terminée 4Lire4 4Lecture terminée */

Nous pouvons voir qu'il y a de sérieux problèmes d'alignement ! Comment résoudre la capsule ? Nous utilisons des serrures de lecture et d'écriture pour résoudre les problèmes de files d'attente .

Opération modifiée

package com.zmz.lock;/** * @ProjectName: Juc * @Package: com.zmz.lock * @ClassName: ReadwritelockDemo * @Author: Zhang shengrui * @Date: 2021/10/3 20:48 * @Version: 1.0 */

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/** * @ClassName ReadwritelockDemo * @Description * @Author Zhang shengrui * @Date 2021/10/3 **/

/* *Serrure exclusive (Écris la serrure.) Un seul thread à la fois  *Serrure partagée (Lisez la serrure.) Plusieurs fils peuvent occuper simultanément  * ReadWriteLock * Lire-Lire Peut coexister * Lire-Écris.  On ne peut pas coexister  * Écris.-Écris.  On ne peut pas coexister  * */
public class ReadwritelockDemo {
    
    public static void main(String[] args) {
    
        MycacheLock mycache = new MycacheLock();
        //Écrire
        for (int i = 1; i < 6; i++) {
    
            final int temp = i;
            new Thread(() -> {
    
                mycache.put(temp + "", temp + "");
            }, String.valueOf(i)).start();
        }
        //Lire
        for (int i = 1; i < 6; i++) {
    
            final int temp = i;
            new Thread(() -> {
    
                mycache.get(temp + "");
            }, String.valueOf(i)).start();
        }
    }
}
//Verrouillage
class MycacheLock {
    
    private volatile Map<String, Object> map = new HashMap<>();
    //Lire et écrire la serrure:Contrôle plus fin
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    //Dépôt、 Quand j'ai écrit ,Je veux juste qu'un seul thread écrive en même temps
    public void put(String key, Object value) {
    
        readWriteLock.writeLock().lock();

        try {
    
            System.out.println(Thread.currentThread().getName() + "Écrire" + key);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "Écrire terminé");
        } catch (Exception e) {
    
            e.printStackTrace();
        } finally {
    
            readWriteLock.writeLock().unlock();
        }

    }

    //Prends - le.、 Lire que tout le monde peut agir 
    public void get(String key) {
    
        readWriteLock.readLock().lock();

        try {
    
            System.out.println(Thread.currentThread().getName() + "Lire" + key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName() + "Lecture terminée");
        } catch (Exception e) {
    
            e.printStackTrace();
        } finally {
    
            readWriteLock.readLock().unlock();
        }

    }
}

class Mycache {
    
    private volatile Map<String, Object> map = new HashMap<>();

    public void put(String key, Object value) {
    
        System.out.println(Thread.currentThread().getName() + "Écrire" + key);
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "Écrire terminé");
    }

    public void get(String key) {
    
        System.out.println(Thread.currentThread().getName() + "Lire" + key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName() + "Lecture terminée");
    }
}

/* 1Écrire1 1Écrire terminé 2Écrire2 2Écrire terminé 3Écrire3 3Écrire terminé 4Écrire4 4Écrire terminé 5Écrire5 5Écrire terminé 1Lire1 1Lecture terminée 5Lire5 3Lire3 3Lecture terminée 4Lire4 4Lecture terminée 5Lecture terminée 2Lire2 2Lecture terminée */

Nous pouvons voir les résultats de la sortie se dérouler de façon ordonnée au moment de l'écriture , Les opérations de lecture peuvent être effectuées de façon désordonnée , Vous pouvez voir que l'effet que nous attendions a été atteint

10、 Bloquer la file d'attente

Colmatage

image-20211004171202278

image-20211004171549940

image-20211004172520422

image-20211004172737902

Quelles sont les circonstances dans lesquelles nous utilisons des files d'attente bloquées : Traitement simultané multithreadé ,Pool de Threads!

10.1 Apprendre à utiliser les files d'attente

Ajouter、Supprimer l'élément, Il y a quatre groupes API

1) Quatre groupes API

Méthodes Lancer une exception Ne lance pas d'exception,Avec valeur de retour Bloquez l'attente Délai d'attente
Ajouter add() offer() put() offer(E e, long timeout, TimeUnit unit)
Supprimer remove() poll() take() poll(long timeout, TimeUnit unit)
Juger la tête element() peek() - -
/* * Lancer une exception * */
    public static void test1(){
    
        //Taille de la file d'attente3
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        //IllegalState ExceptionQueue full Lancer une exception
        //System.out.println(blockingQueue.add("d"));

        // Élément de tête de l'équipe d'essai 
        System.out.println(blockingQueue.element());								                                 System.out.println("================================================");
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        //java.util.NoSuchElementException Lancer une exception
        //System.out.println(blockingQueue.remove());

    }
/* * Ne pas lancer d'exception,Avec valeur de retour * */
    public static void test2(){
    
        //Taille de la file d'attente3
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        //false
        System.out.println(blockingQueue.offer("d"));

        // Élément de tête de l'équipe d'essai 
        System.out.println(blockingQueue.peek());
        System.out.println("================================================");
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        //null
        System.out.println(blockingQueue.poll());

    }
/* *  Bloquer l'attente * L'attente de la mort  * */
    public static void test3() throws InterruptedException {
    
        //Taille de la file d'attente3
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
        //blockingQueue.put("d");

        // Aucun élément de tête d'équipe d'essai 
        System.out.println("================================================");
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
      //System.out.println(blockingQueue.take());

    }
/* * Attendez le blocage(Temps mort) * */
    public static void test4() throws InterruptedException {
    
        //Taille de la file d'attente3
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        blockingQueue.offer("a");
        blockingQueue.offer("b");
        blockingQueue.offer("c");
        blockingQueue.offer("d",2, TimeUnit.SECONDS);

        // Aucun élément de tête d'équipe d'essai 
        System.out.println("================================================");
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        blockingQueue.poll(2,TimeUnit.SECONDS);
    }

2) SynchronizedQueue Synchroniser la file d'attente

Pas de capacité, Entrez dans un élément , Il faut attendre que ça sorte , Pour y mettre un autre élément

put take

package com.zmz.queue;

/** * @ProjectName: Juc * @Package: com.zmz.queue * @ClassName: SyncQueue * @Author: Zhang shengrui * @Date: 2021/10/8 14:18 * @Version: 1.0 */

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/** * Synchroniser la file d'attente * Et les autreslockQueue C'est différent, SynchronousQueue Ne pas stocker les éléments */
public class SyncQueue {
    

    public static void main(String[] args) {
    
        SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>(); //Synchroniser la file d'attente

        new Thread(()->{
    

            try {
    
                System.out.println(Thread.currentThread().getName() + "put 1");
                synchronousQueue.put("1");
                System.out.println(Thread.currentThread().getName() + "put 2");
                synchronousQueue.put("2");
                System.out.println(Thread.currentThread().getName() + "put 3");
                synchronousQueue.put("3");
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
        },"Thread1").start();

        new Thread(()->{
    
            try {
    
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "=>" + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "=>" + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "=>" + synchronousQueue.take());
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            } finally {
    
            }
        },"Thread2").start();
    }
}

/* Thread1put 1 Thread2=>1 Thread1put 2 Thread2=>2 Thread1put 3 Thread2=>3 */

11、Pool de Threads

Il y a trois façons principales de pool de Threads ,Sept paramètres,Quatre stratégies de rejet

Fonctionnement du programme,Nature: Utiliser les ressources du système ! OptimisationCPUUtilisation des ressources ===>Technologie de mise en commun

Pool de Threads, Pool de connexion, Pool de mémoire, Pool d'objets///…

Technologie de mise en commun: La mise en oeuvre est prête pour quelques ressources , Quelqu'un a besoin de , Viens me chercher , Rends - moi quand tu auras fini

1) Avantages du pool de threads:

  1. Réduire la consommation de ressources
  2. Augmenter la vitesse de réponse
  3. Gestion facile

Réutilisation des fils, Peut contrôler le nombre maximum de concurrence ,Gérer les fils

2) Pool de Threads: Trois approches principales

  • ExecutorService service = Executors.newSingleThreadExecutor();//Un seul thread
  • ExecutorService service = Executors.newFixedThreadPool(5);//Créer une taille fixe de pool de Threads
  • ExecutorService service = Executors.newCachedThreadPool();//Rétractable,
package com.zmz.Pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/** * @ProjectName: Juc * @Package: com.zmz.ThreadPool * @ClassName: ThreadPool * @Author: Zhang shengrui * @Date: 2021/10/8 16:44 * @Version: 1.0 */
public class ThreadPool {
    
    public static void main(String[] args) {
    

        ExecutorService threadPool = Executors.newSingleThreadExecutor();//Un seul thread
        ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //Créer une taille fixe de pool de Threads
        ExecutorService threadPool3 = Executors.newCachedThreadPool(); //Rétractable

        // Le pool de Threads doit être fermé avant qu'il ne soit épuisé 
        try {
    

            for (int i = 1; i <=100 ; i++) {
    
                // Créer un thread à partir d'un pool de Threads 
                threadPool3.execute(()->{
    
                    System.out.println(Thread.currentThread().getName()+ " ok");
                });
            }
        } catch (Exception e) {
    
            e.printStackTrace();
        } finally {
    
            threadPool3.shutdown();
        }
    }
}

3) Sept paramètres

public ThreadPoolExecutor(int corePoolSize,  //Taille du pool de Threads de base
                          int maximumPoolSize, // Taille maximale du pool de Threads 
                          long keepAliveTime,  //Quand le temps s'est écoulé, personne n'a appelé et il est sorti
                          TimeUnit unit, //Unit é de temporisation
                          BlockingQueue<Runnable> workQueue, //Bloquer la file d'attente
                          ThreadFactory threadFactory, //Thread Factory Créer un thread Pas besoin de bouger.
                          RejectedExecutionHandler handler //Politique de rejet
                         ) {
    
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

image-20211008170223781

image-20211008165650913

package com.zmz.Pool;

import java.util.concurrent.*;

/** * @ProjectName: Juc * @Package: com.zmz.Pool * @ClassName: ThreadPoolExecutorTest * @Author: Zhang shengrui * @Date: 2021/10/8 16:59 * @Version: 1.0 */
public class ThreadPoolExecutorTest {
    
    public static void main(String[] args) {
    
        // Accèscpu Nombre de noyaux
        int max = Runtime.getRuntime().availableProcessors();
        ExecutorService service =new ThreadPoolExecutor(
                2,//Taille du pool de Threads de base
                max,// Taille maximale du pool de Threads 
                3,//Quand le temps s'est écoulé, personne n'a appelé et il est sorti
                TimeUnit.SECONDS,//Unit é de temporisation
                new LinkedBlockingDeque<>(3),//Bloquer la file d'attente
                Executors.defaultThreadFactory(),//Thread Factory Créer un thread
                new ThreadPoolExecutor.AbortPolicy()//Politique de rejet
        );
        try {
    
            for (int i = 1; i <= 5; i++) {
    
                service.execute(() -> {
    
                    System.out.println(Thread.currentThread().getName() + "Exécution réussie");
                });
            }
        }catch (Exception e) {
    
            e.printStackTrace();
        }
        finally {
    
            service.shutdown();
        }
    }
}

4) Politique de rejet

image-20211008170459374

  • new ThreadPoolExecutor.AbortPolicy() Exception lancée par un Thread de traitement supérieur au maximum
  • new ThreadPoolExecutor.CallerRunsPolicy() Le thread à partir duquel la création est effectuée par ce thread
  • new ThreadPoolExecutor.DiscardPolicy() Une file d'attente pleine ne lancera pas d'exception
  • new ThreadPoolExecutor.DiscardOldestPolicy() Essayez de rivaliser avec le premier ,Et ne lance pas d'exception

12、 Quatre interfaces fonctionnelles

Les programmeurs de la nouvelle ère :lambdaExpression、Programmation en chaîne、Interface fonctionnelle、StreamCalcul du débit

image-20200812143713392

1) FunctionInterface fonctionnelle

image-20211008172106100

package com.zmz.FourFunction;

import java.util.function.Function;

/** * @ProjectName: Juc * @Package: com.zmz.FourFunction * @ClassName: functionDemo * @Author: Zhang shengrui * @Date: 2021/10/8 17:15 * @Version: 1.0 */
public class functionDemo {
    
    public static void main(String[] args) {
    
        Function<String, String> function = (str) -> {
    
            return str;
        };
        System.out.println(function.apply("Hello,zmz!"));
    }
}

2) Predicate Interface déterministe

image-20211008172509531

package com.zmz.FourFunction;

import java.util.function.Predicate;

/** * @ProjectName: Juc * @Package: com.zmz.FourFunction * @ClassName: PredicateDemo * @Author: Zhang shengrui * @Date: 2021/10/8 17:18 * @Version: 1.0 */
public class PredicateDemo {
    
    public static void main(String[] args) {
    
        Predicate<String> predicate = (str) -> {
    return str.isEmpty();};
        // false
        System.out.println(predicate.test("zmz"));
        // true
        System.out.println(predicate.test(""));
    }
}

3) Suppier Interface d'alimentation

image-20211008172617885

package com.zmz.FourFunction;

import java.util.function.Supplier;

/** * @ProjectName: Juc * @Package: com.zmz.FourFunction * @ClassName: SuppierDemo * @Author: Zhang shengrui * @Date: 2021/10/8 17:21 * @Version: 1.0 */
public class SuppierDemo {
    
    public static void main(String[] args) {
    
        Supplier<String> supplier = ()->{
    return "1024";};
        System.out.println(supplier.get());
    }
}

4) Consummer Interface de consommation

image-20211008173825192

package com.zmz.FourFunction;

import java.util.function.Consumer;

/** * @ProjectName: Juc * @Package: com.zmz.FourFunction * @ClassName: ConsummerDemo * @Author: Zhang shengrui * @Date: 2021/10/8 17:21 * @Version: 1.0 */
public class ConsummerDemo {
    
    public static void main(String[] args) {
    
        Consumer<String> consumer = (str)->{
    
            System.out.println(str);
        };
        consumer.accept("zmz");
    }
}

13、Stream Calcul du débit

package com.zmz.Stream;

/** * @ProjectName: Juc * @Package: com.zmz.Stream * @ClassName: User * @Author: Zhang shengrui * @Date: 2021/10/8 18:01 * @Version: 1.0 */
public class User {
    
    private int id;
    private String name;
    private int age;

    public User(int id, String name, int age) {
    
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
    
        return id;
    }

    public void setId(int id) {
    
        this.id = id;
    }

    public String getName() {
    
        return name;
    }

    public void setName(String name) {
    
        this.name = name;
    }

    public int getAge() {
    
        return age;
    }

    public void setAge(int age) {
    
        this.age = age;
    }
}
package com.zmz.Stream;

/** * @ProjectName: Juc * @Package: com.zmz.Stream * @ClassName: StreamDemo * @Author: Zhang shengrui * @Date: 2021/10/8 18:00 * @Version: 1.0 * * * Exigences relatives au titre:  Mise en œuvre en une seule ligne de code  * * 1. Id  Doit être pair  * * 2. L'âge doit être supérieur à 23 * * 3.  Nom d'utilisateur en majuscules  * * 4.  Nom d'utilisateur dans l'ordre inverse  * * 5.  Un seul utilisateur peut être exporté  */

import java.util.Arrays;
import java.util.List;


public class StreamDemo {
    
    public static void main(String[] args) {
    
        User u1 = new User(1, "a", 23);
        User u2 = new User(2, "b", 23);
        User u3 = new User(3, "c", 23);
        User u4 = new User(6, "d", 24);
        User u5 = new User(4, "e", 25);

        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
        // lambda、Programmation en chaîne、Interface fonctionnelle、Calcul du débit
        list.stream()
                .filter(user -> {
    return user.getId()%2 == 0;})
                .filter(user -> {
    return user.getAge() > 20;})
                .map(user -> {
    return user.getName().toUpperCase();})
                .sorted((user1, user2) -> {
    return user2.compareTo(user1);})
                .limit(1)
                .forEach(System.out::println);
    }
}


14、ForkJoin— Cadre de traitement simultané multiligne

Qu'est - ce queForkJoin?

ava.util.concurrent.ForkJoinPoolParJavaMaître!Doug LeaAuteur principal,.Il peut diviser une grande tâche en plusieurs sous - tâches pour un traitement parallèle,Enfin, les résultats de la Sous - tâche sont combinés dans le résultat final du calcul,Et la sortie.Dans cet articleFork/JoinExplication du cadre,Basé surJDK1.8+DansFork/JoinMise en œuvre du cadre,RéférenceFork/JoinLe code source principal du cadre est également basé surJDK1.8+.

Ces articles tenteront d'expliquer Fork/Join Points de connaissance du cadre , Pour se faire 、 Quelques inspirations pour les lecteurs sur la conception de programmes simultanés . L'article commence par Fork/Join Utilisation de base du cadre , Et les points d'utilisation qui nécessitent une attention particulière ;Ensuite, utilisezFork/Join Le cadre aborde un certain nombre de problèmes pratiques ; Enfin, expliquez Fork/JoinComment fonctionne le cadre.

image-20211008180947714

1)ForkJoin Caractéristiques: Vol de travail!

image-20211008181432199

2)Si vous utilisezForkJoin

Première étape,AdoptionForkJoinPoolPour mettre en œuvre

Deuxième étape,Tâches de calcul execute(ForkJoinTask<?> task)

Troisième étape, Classe de calcul à hériter ForkJoinTask

ForkJoin Classe de calcul pour

ForkJoinComputer.java

package com.zmz.ForkJoin;
import java.util.concurrent.RecursiveTask;


/** * @ProjectName: Juc * @Package: com.zmz.ForkJoin * @ClassName: ForkJoinComputer * @Author: Zhang shengrui * @Date: 2021/10/9 15:17 * @Version: 1.0 */

public class ForkJoinComputer extends RecursiveTask<Long> {
    
    private long start;
    private long end;
    /** Seuil */
    private long temp = 1000000L;

    public ForkJoinComputer(long start, long end) {
    
        this.start = start;
        this.end = end;
    }

    /** * Méthode de calcul * @return */
    @Override
    protected Long compute() {
    
        if ((end - start) < temp) {
    
            Long sum = 0L;
            for (Long i = start; i < end; i++) {
    
                sum += i;
            }
            return sum;
        }else {
    
            // UtiliserForkJoin Diviser pour régner. Calcul
            //1 . Calculer la moyenne
            long middle = (start + end) / 2;
            ForkJoinComputer forkJoinDemo1 = new ForkJoinComputer(start, middle);
            // Tâches fractionnées, Appuyez sur le fil dans la file d'attente 
            forkJoinDemo1.fork();
            ForkJoinComputer forkJoinDemo2 = new ForkJoinComputer(middle, end);
            forkJoinDemo2.fork();

            long taskSum = forkJoinDemo1.join() + forkJoinDemo2.join();
            return taskSum;
        }
    }
}

Catégorie d'essai ForkJoinTest.java

package com.zmz.ForkJoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

/** * @ProjectName: Juc * @Package: com.zmz.ForkJoin * @ClassName: ForkJoinTest * @Author: Zhang shengrui * @Date: 2021/10/9 15:18 * @Version: 1.0 */
public class ForkJoinTest {
    
    private static final long SUM = 20_0000_0000;

    public static void main(String[] args) throws ExecutionException, InterruptedException {
    
        test1();
        test2();
        test3();
    }

    /** *  En utilisant la méthode ordinaire  */
    public static void test1() {
    
        long star = System.currentTimeMillis();
        long sum = 0L;
        for (long i = 1; i < SUM ; i++) {
    
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println(sum);
        System.out.println(" Singe de programme ordinaire ——Temps:" + (end - star));
        System.out.println("============================");
    }
    /** * UtiliserForkJoin Méthodes */
    public static void test2() throws ExecutionException, InterruptedException {
    
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinComputer(0L, SUM);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long along = submit.get();

        System.out.println(along);
        long end = System.currentTimeMillis();
        System.out.println(" Singe de programme intermédiaire ——Temps:" + (end - start));
        System.out.println("--------------");
    }
    /** * Utiliser Stream Calcul des flux */
    public static void test3() {
    
        long start = System.currentTimeMillis();

        long sum = LongStream.range(0L, 20_0000_0000L).parallel().reduce(0, Long::sum);
        System.out.println(sum);
        long end = System.currentTimeMillis();
        System.out.println(" Singe de programme avancé ——Temps:" + (end - start));
        System.out.println("--------------");
        System.out.println("============================");
    }
}

image-20211009152827573

Analyser le traitement des singes de programme avancés :

image-20211009152915075

.parallel().reduce(0, Long::sum) Utiliser un flux parallèle pour calculer l'ensemble du calcul ,Amélioration de l'efficacité.

️‍️‍️‍Enfin( Photo de la jeune fille de l'école )

Avec une photo d'une jeune fille

image-20211009151426415

Les filles de l'école ont déjà une collection !!!

版权声明
本文为[Directeur d'usine Java]所创,转载请带上原文链接,感谢
https://chowdera.com/2021/10/20211013211944075c.html

随机推荐