Coffee break #171. Cara menggunakan kata kunci yang disegerakkan. Pengendalian Fail dalam Java

Cara menggunakan kata kunci yang disegerakkan

Sumber: Sederhana Hari ini anda akan belajar dalam kes apa dan cara menggunakan kata kunci yang disegerakkan dengan betul dalam bahasa pengaturcaraan Java. Pengubah suai ialah kata kunci tertentu yang terdapat dalam Java dengan bantuan yang mana kita boleh membuat perubahan pada ciri pembolehubah, kaedah atau kelas dan mengehadkan skopnya. Bahasa Java mempunyai set pengubah yang agak besar. Pengubah suai di Java dibahagikan kepada dua jenis - Pengubahsuai Akses dan pengubah Bukan Akses.

Pengubah suai tanpa akses

Pengubah suai tidak boleh diakses memberikan JVM maklumat tentang ciri kelas, kaedah atau pembolehubah. Terdapat tujuh jenis pengubah bukan akses dalam Java:

• muktamad
• statik
• abstrak
• disegerakkan
• tidak menentu
• sementara
• asli

Dalam artikel ini, kita akan melihat dengan lebih dekat kata kunci yang disegerakkan . Pertama, mari kita tentukan di mana dan bila untuk menggunakannya.

Dalam kes apakah yang disegerakkan digunakan?

Di Java, kata kunci yang disegerakkan digunakan untuk menyediakan kawalan akses kepada kaedah atau blok kod. Apabila utas cuba melaksanakan kaedah atau blok kod yang disegerakkan, ia mesti memperoleh kunci terlebih dahulu. Sebaik sahaja anda menerima kunci, anda boleh memulakan pelaksanaan. Walau bagaimanapun, sebarang utas lain yang cuba melaksanakan kaedah disegerakkan atau blok kod yang sama akan disekat sehingga utas pertama melepaskan kunci. Ini memastikan bahawa hanya satu utas boleh melaksanakan kod pada satu masa, yang penting untuk mengekalkan integriti data. Kata kunci yang disegerakkan boleh digunakan dengan kaedah statik dan bukan statik, serta blok kod.

• Apabila digunakan dengan kaedah statik, semua benang bersaing untuk kunci yang sama. Ini boleh menjejaskan prestasi, jadi sebaiknya elakkan menyegerakkan kaedah statik melainkan benar-benar perlu.

• Apabila digunakan dengan kaedah bukan statik, setiap contoh kelas akan mempunyai kuncinya sendiri, jadi berbilang benang boleh melaksanakan kod disegerakkan secara serentak daripada kejadian yang berbeza. Ini biasanya pendekatan pilihan.

• Apabila digunakan dengan blok kod, kunci diperoleh pada objek yang dihantar ke pernyataan disegerakkan . Ini membolehkan berbilang benang untuk melaksanakan blok kod yang disegerakkan secara serentak daripada objek yang berbeza.

Oleh itu, kata kunci yang disegerakkan ialah alat yang berkuasa untuk mengawal akses data serentak dalam aplikasi Java. Apabila digunakan dengan betul, ia boleh membantu memastikan integriti data dan meningkatkan prestasi.

Contoh penggunaan

1. Blok disegerakkan

public class Counter {
  private int count = 0;

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

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

Terdapat dua blok kod di sini yang mengakses kaunter. Yang paling mudah ialah kaedah get , yang hanya membaca nilai. Pada pandangan pertama, kaedah kenaikan nampaknya mengandungi satu baris kod. Tetapi ingat bahawa operasi kenaikan mesti membaca nilai semasa, menambah satu padanya, dan menulis nilai baharu kembali ke ingatan. Dalam erti kata lain, terdapat tiga sub-operasi yang ingin kami lakukan tanpa gangguan daripada rangkaian lain. Contohnya, meletakkannya di sisi lain atau menjadikan operasi kenaikan atomik . Apabila kami awalan dua blok kod dengan kata kunci yang disegerakkan , adalah penting untuk ambil perhatian bahawa kami juga menandakannya sebagai disegerakkan untuk objek tertentu , seperti yang ditunjukkan dalam contoh kami. Ini bermakna jika kita mempunyai berbilang objek Counter , maka urutan yang berbeza boleh mengemas kini pembilang yang berbeza itu pada masa yang sama. Tetapi dua utas tidak boleh menjalankan blok disegerakkan secara serentak pada contoh Kaunter yang sama .

2. Kaedah disegerakkan

public class SynchronizedCounter {
    private int c = 0;

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

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

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

Jika count ialah contoh SynchronizedCounter , maka penyegerakan kaedah ini mempunyai dua kesan:

• Pertama, dua panggilan ke kaedah yang disegerakkan pada objek yang sama tidak boleh selang. Apabila satu utas melaksanakan kaedah disegerakkan pada objek, semua utas lain yang memanggil kaedah disegerakkan pada blok objek yang sama berhenti seketika sehingga utas pertama selesai berfungsi pada objek.

• Kedua, apabila kaedah yang disegerakkan keluar, ia secara automatik menetapkan nilai kepada "berlaku-sebelum" pada mana-mana panggilan berikutnya kepada kaedah yang disegerakkan pada objek yang sama. Ini memastikan bahawa perubahan kepada keadaan objek kelihatan kepada semua benang.

Ingat bahawa mengetahui sebab, cara dan bila untuk menggunakan penyegerakan serta pengubah suai lain datang dengan pengalaman, dan pengalaman datang dengan masa.

Pengendalian Fail dalam Java

Sumber: Usemynotes Kandungan siaran ini adalah mengenai pemprosesan fail dalam Java. Anda akan menjadi biasa dengan operasi pemprosesan fail, kaedah kelas Fail dan jenis strim. Bekerja dengan fail adalah bahagian penting dalam mana-mana bahasa pengaturcaraan. Menggunakan fail, program boleh menyimpan data pada peranti storan. Melakukan pelbagai tindakan pada fail, seperti membaca atau menulis, memerlukan pemprosesan fail. Pemprosesan fail ditakrifkan sebagai membaca daripada fail dan menulis kepada fail. Untuk mencipta objek fail dan mengendalikan format fail yang berbeza, kami boleh menggunakan kelas Fail daripada pakej java.io . Jika kita ingin menggunakan kelas Fail, kita perlu mencipta objek kelas Fail dan menentukan nama fail atau laluan. Menggunakan kelas ini, kita boleh mengakses metadata fail seperti nama fail, saiz fail, kebenaran, jenis fail dan sebagainya.

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

Untuk mengimport kelas Fail , anda juga boleh menggunakan import java.io.File dan bukannya import java.io.* . Sekarang mari kita belajar tentang benang kerana Java menggunakan benang untuk melaksanakan operasi input/output (I/O) pada fail.

Apakah benang di Jawa?

Strim ialah urutan data. Ia juga boleh ditakrifkan sebagai jujukan bait. Strim boleh digunakan untuk mewakili sama ada sumber input atau destinasi. Sumber dan destinasi boleh berupa fail pada cakera, tatasusunan, fail teks dan sebagainya. Strim input membaca atau mendapatkan semula data daripada sumber, dan aliran output menulis data ke destinasi. Terdapat dua jenis aliran:

Strim bait

Strim Byte digunakan untuk melaksanakan operasi baca dan tulis pada data bait. Proses memproses fail aliran bait ditakrifkan sebagai melaksanakan input menggunakan data bait. Terdapat banyak kelas yang berkaitan dengan aliran bait, tetapi kelas yang paling biasa digunakan ialah FileInputStream dan 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();
 }
}

Dalam contoh di atas, kami sedang membaca data daripada fail sumber dan menulis data ke destinasi. -1 menunjukkan penghujung fail. Jadi membaca dari fail sumber akan berhenti apabila -1 muncul.

Aliran watak

Character Stream digunakan untuk melaksanakan operasi baca dan tulis pada data aksara. Proses memproses fail dengan aliran aksara ialah proses melaksanakan data input dengan aksara. Terdapat banyak kelas aliran aksara yang tersedia, tetapi kelas yang paling biasa digunakan termasuk FileWriter dan FileReader . Sekarang mari kita bincangkan beberapa kaedah kelas Fail .

Kaedah kelas Fail dalam Java

bolehBaca()

Kaedah kelas fail ini menyemak sama ada fail itu boleh dibaca dan mengembalikan nilai Boolean, iaitu benar atau palsu .

bolehTulis()

Ini ialah kaedah kelas fail yang menyemak sama ada fail boleh ditulis dan mengembalikan nilai boolean, iaitu benar atau palsu.

wujud()

Ini ialah kaedah kelas fail yang digunakan untuk menyemak kewujudan fail tertentu dan mengembalikan nilai boolean.

createNewFile()

Apabila kita ingin mencipta fail kosong baharu, gunakan kaedah kelas fail ini. Ia mengembalikan nilai boolean.

padam()

Ini ialah kaedah kelas fail yang digunakan untuk memadam fail dan mengembalikan nilai boolean.

getAbsolutePath()

Kaedah ini digunakan untuk mengembalikan laluan mutlak fail. getName() Ini ialah kaedah yang digunakan untuk mengembalikan nilai rentetan yang merupakan nama fail.

senarai()

Ia mengembalikan tatasusunan rentetan yang mewakili semua fail dalam direktori.

panjang()

Kaedah kelas fail ini mengembalikan saiz fail dalam bait.

mkdir()

Ini ialah kaedah kelas fail yang digunakan untuk mencipta direktori baharu. Mari kita lihat pelbagai operasi fail yang tersedia di Java dan cara menggunakannya.

Apakah operasi fail dalam Java?

Apabila memproses fail Java, kami boleh melakukan operasi berikut pada fail:

• Mencipta fail
• Menulis data ke fail
• Membaca data daripada fail
• Memadam fail
• Mendapatkan maklumat tentang fail
• Mencipta fail

Di Java, kita boleh mencipta fail menggunakan kaedah createNewFile() bagi kelas Fail . Kaedah ini mengembalikan benar jika fail dibuat, sebaliknya mengembalikan palsu jika fail sudah wujud.

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

Menulis data ke fail

Operasi tulis ke fail bermakna menyimpan data dalam fail. Untuk melaksanakan operasi tulis pada fail, kami menggunakan kaedah write() bersama dengan kelas FileWriter . Untuk menutup aliran dan mendapatkan sumber yang diperuntukkan, kita mesti menggunakan kaedah 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();
   }
}

Membaca daripada fail

Operasi baca bermaksud mengakses atau mendapatkan semula data yang disimpan dalam fail. Untuk melaksanakan operasi tulis pada fail, kami akan menggunakan kelas Pengimbas bersama-sama dengan kaedah hasNextLine() dan nextLine() untuk mendapatkan semula data daripada fail. Untuk menutup aliran, kita mesti menggunakan kaedah 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();
   }
}

Memadam fail

Apabila memproses fail Java, kami boleh memadamkan fail menggunakan kaedah delete() kelas Fail . Tidak perlu menutup fail menggunakan fungsi close() kerana kelas FileWriter dan Scanner tidak digunakan untuk memadam fail .

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

Mendapatkan maklumat tentang fail

Terdapat beberapa kaedah dalam Java untuk mendapatkan maklumat tentang fail. Mereka telah disebutkan sebelumnya dalam kaedah kelas fail.

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

Mari lihat bagaimana satu program Java berfungsi untuk menentukan sama ada nombor genap atau ganjil menggunakan aliran tatasusunan bait semasa memproses fail Java. Untuk menulis program ini, kami akan menggunakan kelas ByteArrayInputStream daripada pakej java.io . Kelas ini mengandungi penimbal yang digunakan untuk membaca tatasusunan bait sebagai aliran input. Di bawah ialah kod untuk menyemak sama ada nombor genap atau ganjil.

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

Saya harap maklumat yang disampaikan di sini berguna kepada anda. Untuk lebih memahami bekerja dengan fail dalam Java, anda harus cuba melaksanakan semua fail dan kaedah operasi sendiri.