Pausa para café #171. Como usar a palavra-chave sincronizada. Manipulação de arquivos em Java

Como usar a palavra-chave sincronizada

Fonte: Medium Hoje você aprenderá em quais casos e como usar corretamente a palavra-chave sincronizada na linguagem de programação Java. Modificadores são certas palavras-chave presentes em Java com as quais podemos fazer alterações nas características de uma variável, método ou classe e limitar seu escopo. A linguagem Java possui um conjunto bastante grande de modificadores. Os modificadores em Java são divididos em dois tipos - modificadores de acesso e modificadores de não acesso.

Modificadores sem acesso

Modificadores não acessíveis fornecem à JVM informações sobre as características de uma classe, método ou variável. Existem sete tipos de modificadores sem acesso em Java:

• final
• estático
• abstrato
• sincronizado
• volátil
• transitório
• nativo

Neste artigo, examinaremos mais de perto a palavra-chave sincronizada . Primeiro, vamos definir onde e quando usá-lo.

Em que casos o sincronizado é usado?

Em Java, a palavra-chave sincronizada é usada para fornecer controle de acesso a um método ou bloco de código. Quando um thread tenta executar um método sincronizado ou bloco de código, ele deve primeiro adquirir um bloqueio. Depois de receber o bloqueio, você pode iniciar a execução. No entanto, qualquer outro thread que tentar executar o mesmo método sincronizado ou bloco de código será bloqueado até que o primeiro thread libere o bloqueio. Isso garante que apenas um thread possa executar código por vez, o que é importante para manter a integridade dos dados. A palavra-chave sincronizada pode ser usada com métodos estáticos e não estáticos, bem como com blocos de código.

• Quando usados ​​com métodos estáticos, todos os threads competem pelo mesmo bloqueio. Isso pode afetar o desempenho, por isso é melhor evitar a sincronização de métodos estáticos, a menos que seja absolutamente necessário.

• Quando usado com métodos não estáticos, cada instância da classe terá seu próprio bloqueio, de modo que vários threads podem executar simultaneamente código sincronizado de diferentes instâncias. Esta é geralmente a abordagem preferida.

• Quando usado com blocos de código, um bloqueio é adquirido em um objeto que é passado para a instrução sincronizada . Isso permite que vários threads executem simultaneamente blocos de código sincronizados de diferentes objetos.

Assim, a palavra-chave sincronizada é uma ferramenta poderosa para controlar o acesso simultâneo a dados em aplicativos Java. Quando usado corretamente, pode ajudar a garantir a integridade dos dados e melhorar o desempenho.

Exemplos de uso

1. Bloco sincronizado

public class Counter {
  private int count = 0;

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

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

Existem dois blocos de código aqui que acessam o contador. O mais simples deles é o método get , que simplesmente lê o valor. À primeira vista, o método incremento parece conter uma linha de código. Mas lembre-se de que a operação de incremento deve ler o valor atual, adicionar um valor a ele e gravar o novo valor de volta na memória. Em outras palavras, existem três suboperações que queremos realizar sem interrupção de outros threads. Por exemplo, colocando-o do outro lado ou tornando a operação de incremento atômica . Quando prefixamos dois blocos de código com a palavra-chave sincronizada , é importante observar que também os marcamos como sincronizados para um objeto específico , conforme mostrado em nosso exemplo. Isso significa que se tivermos vários objetos Counter , diferentes threads poderão atualizar esses diferentes contadores ao mesmo tempo. Mas dois threads não podem executar simultaneamente blocos sincronizados na mesma instância do Counter .

2. Método sincronizado

public class SynchronizedCounter {
    private int c = 0;

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

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

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

Se count for uma instância de SynchronizedCounter , a sincronização desses métodos terá dois efeitos:

• Primeiro, duas chamadas para métodos sincronizados no mesmo objeto não podem ser intercaladas. Quando um thread executa um método sincronizado em um objeto, todos os outros threads que chamam métodos sincronizados no mesmo bloco do objeto fazem uma pausa até que o primeiro thread termine de trabalhar no objeto.

• Segundo, quando o método sincronizado termina, ele define automaticamente o valor como “acontece antes” em quaisquer chamadas subsequentes ao método sincronizado no mesmo objeto. Isso garante que as alterações no estado do objeto sejam visíveis para todos os threads.

Lembre-se de que saber por que, como e quando usar o sincronizado , bem como outros modificadores, vem com a experiência, e a experiência vem com o tempo.

Manipulação de arquivos em Java

Fonte: Usemynotes O conteúdo deste post é sobre processamento de arquivos em Java. Você se familiarizará com as operações de processamento de arquivos, os métodos da classe File e os tipos de fluxos. Trabalhar com arquivos é parte integrante de qualquer linguagem de programação. Usando arquivos, um programa pode armazenar dados em um dispositivo de armazenamento. A execução de diversas ações em um arquivo, como leitura ou gravação, requer o processamento do arquivo. O processamento de arquivo é definido como leitura de um arquivo e gravação em um arquivo. Para criar um objeto de arquivo e lidar com diferentes formatos de arquivo, podemos usar a classe File do pacote java.io. Se quisermos usar a classe File, precisamos criar um objeto da classe File e especificar o nome ou caminho do arquivo. Usando esta classe, podemos acessar metadados do arquivo, como nome do arquivo, tamanho do arquivo, permissões, tipo de arquivo e assim por diante.

// 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");
}
}

Para importar a classe File , você também pode usar import java.io.File em vez de import java.io.* . Agora vamos aprender sobre threads, pois Java usa threads para realizar operações de entrada/saída (E/S) em um arquivo.

O que é um thread em Java?

Stream é uma sequência de dados. Também pode ser definido como uma sequência de bytes. Um fluxo pode ser usado para representar uma fonte de entrada ou um destino. A origem e o destino podem ser arquivos em disco, matrizes, arquivos de texto e assim por diante. O fluxo de entrada lê ou recupera dados da origem e o fluxo de saída grava dados no destino. Existem dois tipos de fluxos:

Fluxo de bytes

Um Byte Stream é usado para realizar operações de leitura e gravação em dados de bytes. O processo de processamento de um arquivo de fluxo de bytes é definido como a execução de entrada usando dados de bytes. Existem muitas classes relacionadas a fluxos de bytes, mas as classes mais usadas são FileInputStream e 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();
 }
}

No exemplo acima, estamos lendo dados do arquivo de origem e gravando os dados no destino. -1 indica o final do arquivo. Portanto, a leitura do arquivo de origem será interrompida quando -1 aparecer.

Fluxo de caracteres

Character Stream é usado para realizar operações de leitura e gravação em dados de caracteres. O processo de processamento de um arquivo com fluxo de caracteres é o processo de execução de dados de entrada com caracteres. Existem muitas classes de fluxo de caracteres disponíveis, mas as classes mais usadas incluem FileWriter e FileReader . Agora vamos discutir alguns métodos da classe File .

Métodos da classe File em Java

pode ler()

Este método de classe de arquivo verifica se o arquivo é legível e retorna um valor booleano, ou seja, true ou false .

pode escrever()

Este é um método de classe de arquivo que verifica se um arquivo é gravável e retorna um valor booleano, ou seja, verdadeiro ou falso.

existe()

Este é um método de classe de arquivo usado para verificar a existência de um determinado arquivo e retorna um valor booleano.

criarNovoArquivo()

Quando quisermos criar um novo arquivo vazio, use este método de classe de arquivo. Ele retorna um valor booleano.

excluir()

Este é um método de classe de arquivo usado para excluir um arquivo e retornar um valor booleano.

getAbsolutePath()

Este método é usado para retornar o caminho absoluto de um arquivo. getName() Este é um método usado para retornar um valor de string que é o nome do arquivo.

lista()

Ele retorna uma matriz de strings que representa todos os arquivos do diretório.

comprimento()

Este método de classe de arquivo retorna o tamanho do arquivo em bytes.

mkdir()

Este é um método de classe de arquivo usado para criar um novo diretório. Vamos dar uma olhada nas diversas operações de arquivo disponíveis em Java e como usá-las.

Quais são as operações de arquivo em Java?

Ao processar arquivos Java, podemos realizar as seguintes operações em um arquivo:

• Criando um arquivo
• Gravando dados em um arquivo
• Lendo dados de um arquivo
• Excluindo um arquivo
• Obtendo informações sobre um arquivo
• Criando um arquivo

Em Java, podemos criar um arquivo usando o método createNewFile() da classe File . Este método retorna verdadeiro se o arquivo for criado; caso contrário, retorna falso se o arquivo já existir.

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.");
 }
}

Gravando dados em um arquivo

Uma operação de gravação em um arquivo significa armazenar dados em um arquivo. Para realizar operações de gravação em um arquivo, usamos o método write() junto com a classe FileWriter . Para fechar um fluxo e obter recursos alocados, devemos usar o método 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();
   }
}

Lendo de um arquivo

Uma operação de leitura significa acessar ou recuperar dados armazenados em um arquivo. Para realizar uma operação de gravação em um arquivo, usaremos a classe Scanner junto com os métodos hasNextLine() e nextLine() para recuperar dados do arquivo. Para fechar um stream, devemos usar o método 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();
   }
}

Excluindo um arquivo

Ao processar arquivos Java, podemos excluir um arquivo usando o método delete() da classe File . Não há necessidade de fechar o arquivo usando a função close() , pois as classes FileWriter e Scanner não são usadas para excluir o arquivo .

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.");
   }
}

Obtendo informações sobre um arquivo

Existem vários métodos em Java para obter informações sobre um arquivo. Eles já foram mencionados anteriormente nos métodos da 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());
  }
}

Vejamos como um programa Java funciona para determinar se um número é par ou ímpar usando um fluxo de matriz de bytes durante o processamento de arquivos Java. Para escrever este programa, usaremos a classe ByteArrayInputStream do pacote java.io. Esta classe contém um buffer usado para ler uma matriz de bytes como um fluxo de entrada. Abaixo está o código para verificar se os números são pares ou ímpares.

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.");
     }
   }
}

Espero que as informações aqui apresentadas tenham sido úteis para você. Para entender melhor como trabalhar com arquivos em Java, você deve tentar implementar você mesmo todos os métodos de arquivo e operação.