Pause café #171. Comment utiliser le mot-clé synchronisé. Gestion des fichiers en Java

Comment utiliser le mot-clé synchronisé

Source : Medium Aujourd'hui, vous apprendrez dans quels cas et comment utiliser correctement le mot-clé synchronisé dans le langage de programmation Java. Les modificateurs sont certains mots-clés présents en Java à l'aide desquels nous pouvons modifier les caractéristiques d'une variable, d'une méthode ou d'une classe et en limiter la portée. Le langage Java dispose d'un ensemble assez large de modificateurs. Les modificateurs en Java sont divisés en deux types : les modificateurs d'accès et les modificateurs de non -accès.

Modificateurs sans accès

Les modificateurs non accessibles fournissent à la JVM des informations sur les caractéristiques d'une classe, d'une méthode ou d'une variable. Il existe sept types de modificateurs de non-accès en Java :

• final
• statique
• abstrait
• synchronisé
• volatil
• transitoire
• indigène

Dans cet article, nous examinerons de plus près le mot-clé synchronisé . Tout d’abord, définissons où et quand l’utiliser.

Dans quels cas la synchronisation est-elle utilisée ?

En Java, le mot-clé synchronisé est utilisé pour fournir un contrôle d'accès à une méthode ou un bloc de code. Lorsqu'un thread tente d'exécuter une méthode synchronisée ou un bloc de code, il doit d'abord acquérir un verrou. Une fois que vous avez reçu le verrou, vous pouvez commencer l'exécution. Cependant, tout autre thread tentant d'exécuter la même méthode synchronisée ou le même bloc de code sera bloqué jusqu'à ce que le premier thread libère le verrou. Cela garantit qu'un seul thread peut exécuter du code à la fois, ce qui est important pour maintenir l'intégrité des données. Le mot-clé synchronisé peut être utilisé avec des méthodes statiques et non statiques, ainsi qu'avec des blocs de code.

• Lorsqu'ils sont utilisés avec des méthodes statiques, tous les threads sont en compétition pour le même verrou. Cela peut avoir un impact sur les performances, il est donc préférable d'éviter de synchroniser les méthodes statiques, sauf en cas d'absolue nécessité.

• Lorsqu'elle est utilisée avec des méthodes non statiques, chaque instance de la classe aura son propre verrou, de sorte que plusieurs threads peuvent exécuter simultanément du code synchronisé à partir de différentes instances. C’est généralement l’approche privilégiée.

• Lorsqu'il est utilisé avec des blocs de code, un verrou est acquis sur un objet qui est transmis à l' instruction synchronisée . Cela permet à plusieurs threads d'exécuter simultanément des blocs de code synchronisés à partir de différents objets.

Ainsi, le mot-clé synchronisé est un outil puissant pour contrôler l'accès simultané aux données dans les applications Java. Lorsqu’il est utilisé correctement, il peut contribuer à garantir l’intégrité des données et à améliorer les performances.

Exemples d'utilisation

1. Bloc synchronisé

public class Counter {
  private int count = 0;

  public int getCount() {
    synchronized (this) {
      return count;
    }
  }

  public void increment() {
    synchronized (this) {
      count++;
    }
  }
}

Il y a ici deux blocs de code qui accèdent au compteur. La plus simple d’entre elles est la méthode get , qui lit simplement la valeur. À première vue, la méthode d'incrémentation semble contenir une seule ligne de code. Mais rappelez-vous que l' opération d'incrémentation doit lire la valeur actuelle, y ajouter une et réécrire la nouvelle valeur en mémoire. En d’autres termes, nous souhaitons effectuer trois sous-opérations sans interruption des autres threads. Par exemple, en le plaçant de l'autre côté ou en rendant l' opération d'incrémentation atomique . Lorsque nous préfixons deux blocs de code avec le mot-clé synchronisé , il est important de noter que nous les marquons également comme synchronisés pour un objet spécifique , comme le montre notre exemple. Cela signifie que si nous avons plusieurs objets Counter , alors différents threads peuvent mettre à jour ces différents compteurs en même temps. Mais deux Threads ne peuvent pas exécuter simultanément des blocs synchronisés sur la même Counter Instance .

2. Méthode synchronisée

public class SynchronizedCounter {
    private int c = 0;

    public synchronized void increment() {
        c++;
    }

    public synchronized void decrement() {
        c--;
    }

    public synchronized int value() {
        return c;
    }
}

Si count est une instance de SynchronizedCounter , la synchronisation de ces méthodes a deux effets :

• Premièrement, deux appels à des méthodes synchronisées sur le même objet ne peuvent pas s'entrelacer. Lorsqu'un thread exécute une méthode synchronisée sur un objet, tous les autres threads qui appellent des méthodes synchronisées sur le même bloc de l'objet font une pause jusqu'à ce que le premier thread ait fini de travailler sur l'objet.

• Deuxièmement, lorsque la méthode synchronisée se termine, elle définit automatiquement la valeur sur « arrive-avant » lors de tout appel ultérieur à la méthode synchronisée sur le même objet. Cela garantit que les modifications apportées à l'état de l'objet sont visibles par tous les threads.

N'oubliez pas que savoir pourquoi, comment et quand utiliser synchronisé ainsi que d'autres modificateurs vient avec l'expérience, et l'expérience vient avec le temps.

Gestion des fichiers en Java

Source : Usemynotes Le contenu de cet article concerne le traitement de fichiers en Java. Vous vous familiariserez avec les opérations de traitement de fichiers, les méthodes de la classe File et les types de flux. Travailler avec des fichiers fait partie intégrante de tout langage de programmation. À l'aide de fichiers, un programme peut stocker des données sur un périphérique de stockage. Effectuer diverses actions sur un fichier, comme la lecture ou l'écriture, nécessite le traitement du fichier. Le traitement de fichiers est défini comme la lecture d'un fichier et l'écriture dans un fichier. Pour créer un objet fichier et gérer différents formats de fichiers, nous pouvons utiliser la classe File du package java.io. Si nous voulons utiliser la classe File, nous devons créer un objet de la classe File et spécifier le nom ou le chemin du fichier. En utilisant cette classe, nous pouvons accéder aux métadonnées des fichiers telles que le nom du fichier, la taille du fichier, les autorisations, le type de fichier, etc.

// importing all the classes of java.io
import java.io.*;
class FileHandle {
    public static void main(String[] arr) {
       // an object of File class is created.
       File f=new File("demo.txt");
}
}

Pour importer la classe File , vous pouvez également utiliser import java.io.File au lieu de import java.io.* . Découvrons maintenant les threads, car Java utilise des threads pour effectuer des opérations d'entrée/sortie (E/S) sur un fichier.

Qu’est-ce qu’un thread en Java ?

Le flux est une séquence de données. Il peut également être défini comme une séquence d'octets. Un flux peut être utilisé pour représenter soit une source d’entrée, soit une destination. La source et la destination peuvent être des fichiers sur disque, des tableaux, des fichiers texte, etc. Le flux d'entrée lit ou récupère les données de la source et le flux de sortie écrit les données vers la destination. Il existe deux types de flux :

Flux d'octets

Un flux d'octets est utilisé pour effectuer des opérations de lecture et d'écriture sur des données d'octets. Le processus de traitement d'un fichier de flux d'octets est défini comme effectuant une entrée à l'aide de données d'octets. Il existe de nombreuses classes liées aux flux d'octets, mais les classes les plus couramment utilisées sont FileInputStream et FileOutputStream .

import java.io.*;
public class FileHandle{
   public static void main(String []arr) throws IOException{
   FileInputStream fin=new FileInputStream("source_file.txt");
   FileOutputStream fout=new FileOutputStream("destination_file.txt");
   int character;
   while((character=fin.read())!=-1)
   {
      System.out.print((char)character);
      // writing to destination file
      fout.write((char)character);
   }
   // closing source_file.txt
   fin.close();
   // closing destination_file.txt
   fout.close();
 }
}

Dans l'exemple ci-dessus, nous lisons les données du fichier source et écrivons les données vers la destination. -1 indique la fin du fichier. Ainsi, la lecture du fichier source s'arrêtera lorsque -1 apparaîtra.

Flux de personnages

Character Stream est utilisé pour effectuer des opérations de lecture et d’écriture sur les données de caractères. Le processus de traitement d'un fichier avec un flux de caractères est le processus d'exécution de données d'entrée avec des caractères. Il existe de nombreuses classes de flux de caractères disponibles, mais les classes les plus couramment utilisées incluent FileWriter et FileReader . Parlons maintenant de quelques méthodes de la classe File .

Méthodes de la classe File en Java

Peux lire()

Cette méthode de classe de fichier vérifie si le fichier est lisible et renvoie une valeur booléenne, c'est-à-dire true ou false .

peut écrire()

Il s'agit d'une méthode de classe de fichier qui vérifie si un fichier est accessible en écriture et renvoie une valeur booléenne, c'est-à-dire vrai ou faux.

existe()

Il s'agit d'une méthode de classe de fichier utilisée pour vérifier l'existence d'un fichier donné et renvoie une valeur booléenne.

créer un nouveau fichier()

Lorsque nous voulons créer un nouveau fichier vide, utilisez cette méthode de classe de fichier. Il renvoie une valeur booléenne.

supprimer()

Il s'agit d'une méthode de classe de fichier utilisée pour supprimer un fichier et renvoyer une valeur booléenne.

getAbsolutePath()

Cette méthode est utilisée pour renvoyer le chemin absolu d'un fichier. getName() Il s'agit d'une méthode utilisée pour renvoyer une valeur de chaîne qui est le nom du fichier.

liste()

Il renvoie un tableau de chaînes représentant tous les fichiers du répertoire.

longueur()

Cette méthode de classe de fichier renvoie la taille du fichier en octets.

mkdir()

Il s'agit d'une méthode de classe de fichier utilisée pour créer un nouveau répertoire. Jetons un coup d'œil aux différentes opérations sur les fichiers disponibles en Java et comment les utiliser.

Que sont les opérations sur les fichiers en Java ?

Lors du traitement de fichiers Java, nous pouvons effectuer les opérations suivantes sur un fichier :

• Création d'un fichier
• Écrire des données dans un fichier
• Lire les données d'un fichier
• Supprimer un fichier
• Obtenir des informations sur un fichier
• Création d'un fichier

En Java, nous pouvons créer un fichier en utilisant la méthode createNewFile() de la classe File . Cette méthode renvoie vrai si le fichier est créé, sinon renvoie faux si le fichier existe déjà.

import java.io.*;
public class FileHandle{
   public static void main(String []arr) throws IOException{
   // an object of file class
   File f=new File("demo.txt");
   // creating a new file
   Boolean result=f.createNewFile();
   if(result)
      System.out.print(f+" created successfully.");
   else
      System.out.format("%s","File cannot be created due to some error.");
 }
}

Écrire des données dans un fichier

Une opération d'écriture dans un fichier signifie stocker des données dans un fichier. Pour effectuer des opérations d'écriture sur un fichier, nous utilisons la méthode write() avec la classe FileWriter . Pour fermer un flux et obtenir les ressources allouées, nous devons utiliser la méthode close() .

import java.io.*;
public class FileHandle{
   public static void main(String []arr) throws IOException{
     // creating a new file and writing data to a file
     FileWriter fw=new FileWriter("demo.txt");
     String s="Welcome, this is tutorial of Java File Handling.";
     fw.write(s);
     // closing a file
     fw.close();
   }
}

Lecture à partir d'un fichier

Une opération de lecture signifie accéder ou récupérer des données stockées dans un fichier. Pour effectuer une opération d'écriture sur un fichier, nous utiliserons la classe Scanner ainsi que les méthodes hasNextLine() et nextLine() pour récupérer les données du fichier. Pour fermer un flux, nous devons utiliser la méthode close() .

import java.io.*;
import java.util.Scanner;
public class FileHandle{
   public static void main(String []arr) throws IOException{
     File f=new File("demo.txt");
     Scanner sc=new Scanner(f);
     while(sc.hasNextLine())
     {
       String str=sc.nextLine();
       System.out.println(str);
     }
     // closing a file
     sc.close();
   }
}

Supprimer un fichier

Lors du traitement de fichiers Java, nous pouvons supprimer un fichier en utilisant la méthode delete() de la classe File . Il n'est pas nécessaire de fermer le fichier à l'aide de la fonction close() puisque les classes FileWriter et Scanner ne sont pas utilisées pour supprimer le fichier .

import java.io.*;
public class FileHandle{
   public static void main(String []arr) throws IOException{
      File f=new File("demo.txt");
      Boolean result=f.delete();
      if(result)
         System.out.print(f+" deleted successfully.");
      else
         System.out.format("%s","File cannot be deleted due to some error.");
   }
}

Obtenir des informations sur un fichier

Il existe plusieurs méthodes en Java pour obtenir des informations sur un fichier. Ils ont déjà été évoqués plus haut dans les méthodes de la classe file.

import java.io.*;
public class FileHandle{
   public static void main(String []arr) throws IOException{
     File file=new File("demo.txt");
     file.createNewFile();
     String filename=file.getName();
     System.out.println("File Name is "+filename);
     System.out.println("Absolute path of "+filename+" : "+file.getAbsolutePath());
     System.out.print("length of "+filename+" : "+file.length());
     System.out.println("Is "+filename+" readable? "+file.canRead());
     System.out.println("Is "+filename+" writable? "+file.canWrite());
     System.out.println("Is "+filename+" exists? "+file.exists());
  }
}

Examinons comment fonctionne un programme Java pour déterminer si un nombre est pair ou impair à l'aide d'un flux de tableau d'octets lors du traitement des fichiers Java. Pour écrire ce programme, nous utiliserons la classe ByteArrayInputStream du package java.io. Cette classe contient un tampon utilisé pour lire un tableau d'octets en tant que flux d'entrée. Vous trouverez ci-dessous le code pour vérifier si les nombres sont pairs ou impairs.

import java.io.*;
public class FileHandle{
   public static void main(String []arr) throws IOException{
     byte []buffer={10,40,81,23,32,100,57};
     ByteArrayInputStream by=new ByteArrayInputStream(buffer);

     int character=0;
     while((character=by.read())!=-1)
     {
        int number=character;
        if(number%2==0)
          System.out.println(number+" is an even number.");
        else
          System.out.println(number+" is an odd number.");
     }
   }
}

J'espère que les informations présentées ici vous ont été utiles. Pour mieux comprendre l'utilisation de fichiers en Java, vous devez essayer d'implémenter vous-même toutes les méthodes de fichiers et de fonctionnement.