Coffee break #171. Paano gamitin ang naka-synchronize na keyword. Paghawak ng File sa Java

Paano gamitin ang naka-synchronize na keyword

Pinagmulan: Medium Ngayon ay matututunan mo kung anong mga kaso at kung paano gamitin nang tama ang naka-synchronize na keyword sa Java programming language. Ang mga modifier ay ilang partikular na keyword na naroroon sa Java sa tulong kung saan makakagawa tayo ng mga pagbabago sa mga katangian ng isang variable, pamamaraan o klase at limitahan ang saklaw nito. Ang wikang Java ay may medyo malaking hanay ng mga modifier. Ang mga Modifier sa Java ay nahahati sa dalawang uri - Mga Access Modifier at Non -Access modifier.

Mga modifier na walang access

Ang mga hindi naa-access na modifier ay nagbibigay sa JVM ng impormasyon tungkol sa mga katangian ng isang klase, pamamaraan, o variable. Mayroong pitong uri ng mga non-access na modifier sa Java:

• pangwakas
• static
• abstract
• naka-synchronize
• pabagu-bago ng isip
• lumilipas
• katutubo

Sa artikulong ito, titingnan natin ang naka-synchronize na keyword . Una, tukuyin natin kung saan at kailan ito gagamitin.

Sa anong mga kaso ginagamit ang naka-synchronize?

Sa Java, ang naka-synchronize na keyword ay ginagamit upang magbigay ng access control sa isang paraan o block ng code. Kapag sinubukan ng isang thread na magsagawa ng naka-synchronize na paraan o block ng code, dapat muna itong kumuha ng lock. Kapag natanggap mo na ang lock, maaari mong simulan ang pagpapatupad. Gayunpaman, ang anumang iba pang thread na sumusubok na isagawa ang parehong naka-synchronize na paraan o block ng code ay haharangin hanggang sa ilabas ng unang thread ang lock. Tinitiyak nito na isang thread lang ang makakapagsagawa ng code sa isang pagkakataon, na mahalaga para sa pagpapanatili ng integridad ng data. Ang naka-synchronize na keyword ay maaaring gamitin sa parehong static at non-static na pamamaraan, pati na rin ang mga bloke ng code.

• Kapag ginamit sa mga static na pamamaraan, ang lahat ng mga thread ay nakikipagkumpitensya para sa parehong lock. Maaari itong makaapekto sa pagganap, kaya pinakamahusay na iwasan ang pag-synchronize ng mga static na pamamaraan maliban kung talagang kinakailangan.

• Kapag ginamit sa mga non-static na pamamaraan, ang bawat instance ng klase ay magkakaroon ng sarili nitong lock, kaya maraming mga thread ang maaaring sabay na magsagawa ng naka-synchronize na code mula sa iba't ibang pagkakataon. Ito ay karaniwang ang ginustong diskarte.

• Kapag ginamit sa mga bloke ng code, ang isang lock ay nakuha sa isang bagay na ipinapasa sa naka-synchronize na pahayag . Nagbibigay-daan ito sa maraming thread na sabay-sabay na magsagawa ng mga naka-synchronize na bloke ng code mula sa iba't ibang bagay.

Kaya, ang naka-synchronize na keyword ay isang makapangyarihang tool para sa pagkontrol ng sabay-sabay na pag-access ng data sa mga aplikasyon ng Java. Kapag ginamit nang tama, makakatulong ito na matiyak ang integridad ng data at mapabuti ang pagganap.

Mga halimbawa ng paggamit

1. Naka-synchronize na block

public class Counter {
  private int count = 0;

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

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

Mayroong dalawang bloke ng code dito na nag-a-access sa counter. Ang pinakasimple sa mga ito ay ang get method , na nagbabasa lang ng value. Sa unang sulyap, ang paraan ng pagdaragdag ay lilitaw na naglalaman ng isang linya ng code. Ngunit tandaan na ang pagpapatakbo ng pagtaas ay dapat basahin ang kasalukuyang halaga, magdagdag ng isa dito, at isulat ang bagong halaga pabalik sa memorya. Sa madaling salita, may tatlong sub-operasyon na gusto naming isagawa nang walang pagkaantala mula sa ibang mga thread. Halimbawa, ang paglalagay nito sa kabilang panig o paggawa ng increment operation atomic . Kapag nag-prefix kami ng dalawang bloke ng code gamit ang naka-synchronize na keyword , mahalagang tandaan na minarkahan din namin ang mga ito bilang naka-synchronize para sa isang partikular na bagay , tulad ng ipinapakita sa aming halimbawa. Nangangahulugan ito na kung marami kaming Counter object , maaaring i-update ng iba't ibang thread ang magkakaibang counter na iyon nang sabay-sabay. Ngunit ang dalawang thread ay hindi maaaring sabay na magpatakbo ng mga naka-synchronize na bloke sa parehong Counter instance .

2. Naka-synchronize na paraan

public class SynchronizedCounter {
    private int c = 0;

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

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

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

Kung ang count ay isang instance ng SynchronizedCounter , kung gayon ang pag-synchronize ng mga paraang ito ay may dalawang epekto:

• Una, hindi maaaring mag-interleave ang dalawang tawag sa mga naka-synchronize na pamamaraan sa parehong bagay. Kapag ang isang thread ay nagpatupad ng isang naka-synchronize na paraan sa isang bagay, ang lahat ng iba pang mga thread na tumatawag sa mga naka-synchronize na pamamaraan sa parehong bloke ng object ay i-pause hanggang sa ang unang thread ay matapos gumana sa object.

• Pangalawa, kapag lumabas ang naka-synchronize na paraan, awtomatiko nitong itinatakda ang value sa "nangyari-bago" sa anumang kasunod na mga tawag sa naka-synchronize na paraan sa parehong bagay. Tinitiyak nito na ang mga pagbabago sa estado ng object ay makikita ng lahat ng mga thread.

Tandaan na ang pag-alam kung bakit, paano at kailan gagamitin ang naka-synchronize pati na rin ang iba pang mga modifier ay may kasamang karanasan, at ang karanasan ay dumarating sa oras.

Paghawak ng File sa Java

Source: Usemynotes Ang nilalaman ng post na ito ay tungkol sa pagpoproseso ng file sa Java. Magiging pamilyar ka sa mga operasyon sa pagpoproseso ng file, ang mga pamamaraan ng klase ng File, at ang mga uri ng stream. Ang pagtatrabaho sa mga file ay isang mahalagang bahagi ng anumang programming language. Gamit ang mga file, maaaring mag-imbak ng data ang isang program sa isang storage device. Ang pagsasagawa ng iba't ibang aksyon sa isang file, tulad ng pagbabasa o pagsusulat, ay nangangailangan ng pagproseso ng file. Ang pagproseso ng file ay tinukoy bilang pagbabasa mula sa isang file at pagsulat sa isang file. Para gumawa ng file object at pangasiwaan ang iba't ibang format ng file, maaari naming gamitin ang File class mula sa java.io package . Kung gusto nating gamitin ang klase ng File, kailangan nating lumikha ng object ng klase ng File at tukuyin ang pangalan ng file o path. Gamit ang klase na ito, maa-access natin ang metadata ng file tulad ng pangalan ng file, laki ng file, mga pahintulot, uri ng file at iba pa.

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

Upang i-import ang klase ng File , maaari mo ring gamitin ang import java.io.File sa halip na import java.io.* . Ngayon, alamin natin ang tungkol sa mga thread habang ang Java ay gumagamit ng mga thread para magsagawa ng input/output (I/O) na mga operasyon sa isang file.

Ano ang isang thread sa Java?

Ang stream ay isang sequence ng data. Maaari rin itong tukuyin bilang isang pagkakasunud-sunod ng mga byte. Maaaring gamitin ang isang stream upang kumatawan sa isang input source o isang destinasyon. Ang pinagmulan at patutunguhan ay maaaring mga file sa disk, array, text file, at iba pa. Ang input stream ay nagbabasa o kumukuha ng data mula sa pinagmulan, at ang output stream ay nagsusulat ng data sa destinasyon. Mayroong dalawang uri ng stream:

Byte stream

Ang isang Byte Stream ay ginagamit upang magsagawa ng read at write na mga operasyon sa byte data. Ang proseso ng pagproseso ng isang byte stream file ay tinukoy bilang pagsasagawa ng input gamit ang byte data. Mayroong maraming mga klase na nauugnay sa mga byte stream, ngunit ang pinakakaraniwang ginagamit na mga klase ay ang FileInputStream at 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();
 }
}

Sa halimbawa sa itaas, binabasa namin ang data mula sa source file at isinusulat ang data sa destinasyon. -1 ay nagpapahiwatig ng dulo ng file. Kaya't ang pagbabasa mula sa source file ay titigil kapag lumitaw ang -1.

Stream ng character

Ginagamit ang Character Stream upang magsagawa ng mga operasyon sa pagbasa at pagsulat sa data ng character. Ang proseso ng pagproseso ng isang file na may stream ng character ay ang proseso ng pagpapatupad ng data ng input na may mga character. Mayroong maraming mga klase ng stream ng character na magagamit, ngunit ang pinakakaraniwang ginagamit na mga klase ay kinabibilangan ng FileWriter at FileReader . Ngayon talakayin natin ang ilang mga pamamaraan ng klase ng File .

Mga pamamaraan ng klase ng File sa Java

maaaring basahin()

Sinusuri ng paraan ng klase ng file kung nababasa ang file at nagbabalik ng Boolean value, iyon ay, true o false .

canWrite()

Ito ay isang paraan ng klase ng file na nagsusuri kung ang isang file ay maisusulat at nagbabalik ng boolean value, ibig sabihin, true o false.

umiiral()

Ito ay isang paraan ng klase ng file na ginagamit upang suriin ang pagkakaroon ng isang naibigay na file at nagbabalik ng boolean na halaga.

createNewFile()

Kapag gusto naming gumawa ng bagong walang laman na file, gamitin ang paraan ng klase ng file na ito. Nagbabalik ito ng boolean value.

tanggalin()

Isa itong paraan ng klase ng file na ginagamit para magtanggal ng file at magbalik ng boolean value.

getAbsolutePath()

Ang pamamaraang ito ay ginagamit upang ibalik ang ganap na landas ng isang file. getName() Ito ay isang paraan na ginagamit upang ibalik ang isang string value na siyang pangalan ng file.

listahan()

Nagbabalik ito ng hanay ng mga string na kumakatawan sa lahat ng mga file sa direktoryo.

haba()

Ibinabalik ng paraan ng klase ng file ang laki ng file sa mga byte.

mkdir()

Ito ay isang paraan ng klase ng file na ginagamit upang lumikha ng isang bagong direktoryo. Tingnan natin ang iba't ibang mga pagpapatakbo ng file na magagamit sa Java at kung paano gamitin ang mga ito.

Ano ang mga pagpapatakbo ng file sa Java?

Kapag nagpoproseso ng mga Java file, magagawa namin ang mga sumusunod na operasyon sa isang file:

• Paggawa ng file
• Pagsusulat ng data sa isang file
• Pagbabasa ng data mula sa isang file
• Pagtanggal ng file
• Pagkuha ng impormasyon tungkol sa isang file
• Paggawa ng file

Sa Java, maaari tayong lumikha ng file gamit ang createNewFile() na paraan ng File class . Ang pamamaraang ito ay nagbabalik ng true kung ang file ay ginawa, kung hindi man ay nagbabalik ng false kung ang file ay mayroon na.

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

Pagsusulat ng data sa isang file

Ang isang write operation sa isang file ay nangangahulugan ng pag-iimbak ng data sa isang file. Upang magsagawa ng mga operasyon sa pagsulat sa isang file, ginagamit namin ang write() na paraan kasama ang klase ng FileWriter . Upang isara ang isang stream at makakuha ng mga inilalaang mapagkukunan, dapat nating gamitin ang close() na pamamaraan .

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();
   }
}

Pagbabasa mula sa isang file

Ang isang read operation ay nangangahulugan ng pag-access o pagkuha ng data na nakaimbak sa isang file. Para magsagawa ng write operation sa isang file, gagamitin namin ang Scanner class kasama ang hasNextLine() at nextLine() na mga paraan para kunin ang data mula sa file. Upang isara ang isang stream, dapat nating gamitin ang close() na pamamaraan .

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();
   }
}

Pagtanggal ng file

Kapag nagpoproseso ng mga Java file, maaari kaming magtanggal ng file gamit ang delete() na paraan ng File class . Hindi na kailangang isara ang file gamit ang close() function dahil hindi ginagamit ang mga klase ng FileWriter at Scanner para tanggalin ang file .

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

Pagkuha ng impormasyon tungkol sa isang file

Mayroong ilang mga paraan sa Java upang makakuha ng impormasyon tungkol sa isang file. Nabanggit na sila nang mas maaga sa mga pamamaraan ng klase ng 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());
  }
}

Tingnan natin kung paano gumagana ang isang Java program upang matukoy kung ang isang numero ay pantay o kakaiba gamit ang isang byte array stream habang pinoproseso ang mga Java file. Upang isulat ang program na ito, gagamitin namin ang klase ng ByteArrayInputStream mula sa java.io package . Naglalaman ang klase na ito ng buffer na ginagamit para magbasa ng byte array bilang input stream. Nasa ibaba ang code upang suriin kung ang mga numero ay pantay o kakaiba.

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

Umaasa ako na ang impormasyong ipinakita dito ay naging kapaki-pakinabang sa iyo. Upang mas maunawaan ang pagtatrabaho sa mga file sa Java, dapat mong subukang ipatupad ang lahat ng mga file at mga pamamaraan ng pagpapatakbo sa iyong sarili.