คอฟฟี่เบรค #171 วิธีใช้คำสำคัญที่ซิงโครไนซ์ การจัดการไฟล์ใน Java

วิธีใช้คำสำคัญที่ซิงโครไนซ์

ที่มา: สื่อ วันนี้คุณจะได้เรียนรู้ในกรณีใดบ้างและวิธีใช้คำหลักที่ซิงโครไนซ์ในภาษาการเขียนโปรแกรม Java อย่างถูกต้อง Modifiersคือคีย์เวิร์ดบางคำที่มีอยู่ใน Java ซึ่งเราสามารถเปลี่ยนแปลงคุณสมบัติของตัวแปร วิธีการ หรือคลาส และจำกัดขอบเขตของมันได้ ภาษา Java มีชุดตัวปรับแต่งที่ค่อนข้างใหญ่ Modifiers ใน Java แบ่งออกเป็นสองประเภท - Access ModifiersและNon -Access Modifiers

ตัวแก้ไขที่ไม่มีการเข้าถึง

โมดิฟายเออร์ที่ไม่สามารถเข้าถึงได้จะให้ข้อมูลเกี่ยวกับคุณลักษณะของคลาส เมธอด หรือตัวแปรแก่ JVM ตัวดัดแปลงที่ไม่สามารถเข้าถึงได้ใน Java มีเจ็ดประเภท:

• สุดท้าย
• คงที่
• เชิงนามธรรม
• ซิงโครไนซ์
• ระเหย
• ชั่วคราว
• พื้นเมือง

ในบทความนี้ เราจะมาดูรายละเอียดเกี่ยวกับ คำหลักที่ซิงโครไนซ์กัน ก่อนอื่น เรามากำหนดสถานที่และเวลาที่ควรใช้กันก่อน

การซิงโครไนซ์จะใช้ในกรณีใดบ้าง?

ใน Java คำสำคัญที่ซิงโครไนซ์จะใช้เพื่อให้การควบคุมการเข้าถึงวิธีการหรือบล็อกของโค้ด เมื่อเธรดพยายามดำเนินการวิธีการซิงโครไนซ์หรือบล็อกของโค้ด เธรดนั้นจะต้องได้รับการล็อคก่อน เมื่อคุณได้รับล็อคแล้ว คุณก็สามารถเริ่มดำเนินการได้ อย่างไรก็ตาม เธรดอื่นๆ ที่พยายามดำเนินการวิธีการซิงโครไนซ์หรือบล็อกโค้ดเดียวกันจะถูกบล็อกจนกว่าเธรดแรกจะปลดล็อก สิ่งนี้ทำให้มั่นใจได้ว่ามีเพียงเธรดเดียวเท่านั้นที่สามารถรันโค้ดได้ในแต่ละครั้ง ซึ่งเป็นสิ่งสำคัญสำหรับการรักษาความสมบูรณ์ของข้อมูล คำสำคัญที่ซิงโครไนซ์สามารถใช้ได้ทั้งกับวิธีการแบบคงที่และแบบไม่คงที่ตลอดจนบล็อกของโค้ด

• เมื่อใช้กับวิธีสแตติกเธรดทั้งหมดแข่งขันกันเพื่อล็อคเดียวกัน ซึ่งอาจส่งผลต่อประสิทธิภาพการทำงาน ดังนั้นจึงควรหลีกเลี่ยงการซิงโครไนซ์วิธีการคงที่ เว้นแต่จำเป็นจริงๆ

• เมื่อใช้กับวิธีการที่ไม่คงที่ แต่ละอินสแตนซ์ของคลาสจะมีการล็อคของตัวเอง ดังนั้นเธรดจำนวนมากจึงสามารถรันโค้ดที่ซิงโครไนซ์จากอินสแตนซ์ที่แตกต่างกันได้พร้อมกัน โดยปกติจะเป็นแนวทางที่ต้องการ

• เมื่อใช้กับบล็อคโค้ดจะมีการล็อคบนออบเจ็กต์ที่ส่งผ่านไปยัง คำ สั่งซิงโครไนซ์ สิ่งนี้ทำให้หลายเธรดสามารถรันบล็อคโค้ดที่ซิงโครไนซ์จากอ็อบเจ็กต์ที่แตกต่างกันได้พร้อมกัน

ดังนั้น คีย์เวิร์ด ที่ซิงโครไนซ์จึงเป็นเครื่องมือที่มีประสิทธิภาพในการควบคุมการเข้าถึงข้อมูลพร้อมกันในแอปพลิเคชัน Java เมื่อใช้อย่างถูกต้อง จะช่วยรับรองความสมบูรณ์ของข้อมูลและปรับปรุงประสิทธิภาพได้

ตัวอย่างการใช้งาน

1. บล็อกซิงโครไนซ์

public class Counter {
  private int count = 0;

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

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

มีโค้ดสองช่วงที่นี่ที่เข้าถึงตัวนับ วิธีที่ง่ายที่สุดคือget method ซึ่งเพียงอ่านค่า เมื่อมองแวบแรก วิธีการเพิ่มดูเหมือนจะมีโค้ดหนึ่งบรรทัด แต่โปรดจำไว้ว่า การดำเนินการ เพิ่มจะต้องอ่านค่าปัจจุบัน เพิ่มหนึ่งเข้าไป และเขียนค่าใหม่กลับไปยังหน่วยความจำ กล่าวอีกนัยหนึ่ง มีการดำเนินการย่อยสามประการที่เราต้องการดำเนินการโดยไม่หยุดชะงักจากเธรดอื่น ตัวอย่างเช่น วางไว้อีกด้านหนึ่ง หรือทำให้การดำเนินการเพิ่มขึ้นเป็นอะตอมมิก เมื่อเรานำหน้าโค้ดสองช่วงด้วย คำหลัก ที่ซิงโครไนซ์สิ่งสำคัญที่ควรทราบก็คือ เรากำลังทำเครื่องหมายว่าซิงโครไนซ์ สำหรับออบเจ็กต์เฉพาะดังที่แสดงในตัวอย่างของเรา ซึ่งหมายความว่าหากเรามี วัตถุตัว นับ หลาย ตัว เธรดที่ต่างกันก็สามารถอัปเดตตัวนับที่ต่างกันเหล่านั้นได้ในเวลาเดียวกัน แต่สองเธรดไม่สามารถเรียกใช้บล็อกที่ซิงโครไนซ์บน อินสแตนซ์ Counter เดียวกันพร้อมกัน ได้

2. วิธีการซิงโครไนซ์

public class SynchronizedCounter {
    private int c = 0;

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

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

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

หากcountเป็นอินสแตนซ์ของSynchronizedCounterการซิงโครไนซ์วิธีการเหล่านี้จะมีเอฟเฟกต์สองประการ:

• ขั้นแรก การเรียกสองครั้งไปยังวิธีการซิงโครไนซ์บนออบเจ็กต์เดียวกันไม่สามารถแทรกแซงได้ เมื่อเธรดหนึ่งดำเนิน การวิธี การซิงโครไนซ์บนออบเจ็กต์ เธรดอื่น ๆ ทั้งหมดที่เรียกใช้ วิธีการ ซิงโครไนซ์บนบล็อกเดียวกันของออบเจ็กต์จะหยุดชั่วคราวจนกว่าเธรดแรกจะเสร็จสิ้นการทำงานบนออบเจ็กต์

• ประการที่สอง เมื่อออกจากวิธีการซิงโครไนซ์ มันจะตั้งค่าเป็น "เกิดขึ้นก่อน" โดยอัตโนมัติในการเรียกวิธีการซิงโครไนซ์บนออบเจ็กต์เดียวกันครั้งต่อ ๆ ไป เพื่อให้แน่ใจว่าการเปลี่ยนแปลงสถานะของออบเจ็กต์จะมองเห็นได้จากทุกเธรด

โปรดจำไว้ว่าการรู้ว่าทำไม อย่างไร และเมื่อใดจึงควรใช้การซิงโครไนซ์และตัวปรับแต่งอื่นๆ มาพร้อมกับประสบการณ์ และประสบการณ์มาพร้อมกับเวลา

การจัดการไฟล์ใน Java

ที่มา: Usemynotes เนื้อหาของโพสต์นี้เกี่ยวกับการประมวลผลไฟล์ใน Java คุณจะคุ้นเคยกับการดำเนินการประมวลผลไฟล์ วิธีการของคลาส File และประเภทของสตรีม การทำงานกับไฟล์เป็นส่วนสำคัญของภาษาการเขียนโปรแกรมใดๆ การใช้ไฟล์โปรแกรมสามารถจัดเก็บข้อมูลบนอุปกรณ์จัดเก็บข้อมูลได้ การดำเนินการต่างๆ กับไฟล์ เช่น การอ่านหรือการเขียน จำเป็นต้องมีการประมวลผลไฟล์ การประมวลผลไฟล์หมายถึงการอ่านจากไฟล์และการเขียนไปยังไฟล์ ในการสร้างอ็อบเจ็กต์ไฟล์และจัดการรูปแบบไฟล์ต่างๆ เราสามารถใช้คลาสFileจาก แพ็คเกจ java.io หากเราต้องการใช้คลาส File เราจำเป็นต้องสร้างอ็อบเจ็กต์ของ คลาส Fileและระบุชื่อไฟล์หรือพาธ เมื่อใช้คลาสนี้ เราสามารถเข้าถึงข้อมูลเมตาของไฟล์ได้ เช่น ชื่อไฟล์ ขนาดไฟล์ การอนุญาต ประเภทไฟล์ และอื่นๆ

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

หากต้องการนำเข้า คลาส Fileคุณสามารถใช้import java.io.Fileแทนimport java.io.*ได้ ตอนนี้เรามาเรียนรู้เกี่ยวกับเธรดเนื่องจาก Java ใช้เธรดเพื่อดำเนินการอินพุต/เอาต์พุต (I/O) บนไฟล์

เธรดใน Java คืออะไร?

สตรีมคือลำดับของข้อมูล นอกจากนี้ยังสามารถกำหนดเป็นลำดับของไบต์ได้ สตรีมสามารถใช้เพื่อเป็นตัวแทนของแหล่งอินพุตหรือปลายทาง ต้นทางและปลายทางอาจเป็นไฟล์บนดิสก์ อาร์เรย์ ไฟล์ข้อความ และอื่นๆ สตรีมอินพุตอ่านหรือดึงข้อมูลจากแหล่งที่มา และสตรีมเอาต์พุตจะเขียนข้อมูลไปยังปลายทาง สตรีมมีสองประเภท:

กระแสไบต์

Byte Stream ใช้เพื่อดำเนินการอ่านและเขียนข้อมูลไบต์ กระบวนการประมวลผลไฟล์สตรีมไบต์ถูกกำหนดให้เป็นอินพุตโดยใช้ข้อมูลไบต์ มีหลายคลาสที่เกี่ยวข้องกับไบต์สตรีม แต่คลาสที่ใช้บ่อยที่สุดคือ FileInputStreamและ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();
 }
}

ในตัวอย่างข้างต้น เรากำลังอ่านข้อมูลจากไฟล์ต้นฉบับและเขียนข้อมูลไปยังปลายทาง -1 หมายถึงจุดสิ้นสุดของไฟล์ ดังนั้นการอ่านจากไฟล์ต้นฉบับจะหยุดเมื่อ -1 ปรากฏขึ้น

สตรีมตัวละคร

Character Stream ใช้เพื่อดำเนินการอ่านและเขียนข้อมูลอักขระ กระบวนการประมวลผลไฟล์ด้วยสตรีมอักขระคือกระบวนการดำเนินการข้อมูลอินพุตด้วยอักขระ มีคลาสสตรีมอักขระมากมาย แต่คลาสที่ใช้บ่อยที่สุดได้แก่FileWriterและFileReader ตอน นี้เรามาพูดถึงวิธีการบางอย่างของ คลาส File

วิธีการของคลาสไฟล์ใน Java

สามารถอ่าน()

เมธอดคลาสไฟล์นี้จะตรวจสอบว่าไฟล์สามารถอ่านได้หรือไม่ และส่งกลับค่าบูลีน ซึ่งก็คือ trueหรือfalse

สามารถเขียน()

นี่คือเมธอดคลาสไฟล์ที่ตรวจสอบว่าไฟล์สามารถเขียนได้และส่งกลับค่าบูลีน เช่น จริงหรือเท็จ

มีอยู่()

นี่เป็นวิธีคลาสไฟล์ที่ใช้ในการตรวจสอบการมีอยู่ของไฟล์ที่กำหนดและส่งกลับค่าบูลีน

createNewFile()

เมื่อเราต้องการสร้างไฟล์เปล่าใหม่ ให้ใช้วิธีคลาสไฟล์นี้ มันจะส่งกลับค่าบูลีน

ลบ()

นี่เป็นวิธีคลาสไฟล์ที่ใช้ในการลบไฟล์และส่งกลับค่าบูลีน

getAbsolutePath ()

วิธีนี้ใช้เพื่อส่งคืนเส้นทางที่แน่นอนของไฟล์ getName() เป็นวิธีการที่ใช้ในการส่งกลับค่าสตริงซึ่งเป็นชื่อของไฟล์

รายการ()

มันจะส่งคืนอาร์เรย์ของสตริงที่แสดงถึงไฟล์ทั้งหมดในไดเร็กทอรี

ความยาว()

วิธีการเรียนไฟล์นี้ส่งคืนขนาดไฟล์เป็นไบต์

mkdir()

นี่เป็นวิธีคลาสไฟล์ที่ใช้ในการสร้างไดเร็กทอรีใหม่ มาดูการทำงานของไฟล์ต่างๆ ที่มีอยู่ใน Java และวิธีการใช้งานกัน

การทำงานของไฟล์ใน Java คืออะไร?

เมื่อประมวลผลไฟล์ Java เราสามารถดำเนินการต่อไปนี้กับไฟล์ได้:

• การสร้างไฟล์
• การเขียนข้อมูลลงไฟล์
• การอ่านข้อมูลจากไฟล์
• กำลังลบไฟล์
• รับข้อมูลเกี่ยวกับไฟล์
• การสร้างไฟล์

ใน Java เราสามารถสร้างไฟล์โดยใช้ เมธอด createNewFile ( ) ของ คลาสFile เมธอดนี้จะคืนค่าเป็นจริงหากไฟล์ถูกสร้างขึ้น มิฉะนั้นจะส่งคืนค่าเท็จหากไฟล์นั้นมีอยู่แล้ว

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

การเขียนข้อมูลลงไฟล์

การดำเนินการเขียนลงในไฟล์หมายถึงการจัดเก็บข้อมูลในไฟล์ ในการดำเนินการ เขียนไฟล์ เราใช้ เมธอด write()ร่วมกับ คลาส FileWriter หากต้องการปิดสตรีมและรับทรัพยากรที่จัดสรร เราต้องใช้เมธอด 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();
   }
}

อ่านจากไฟล์

การดำเนินการอ่านหมายถึงการเข้าถึงหรือเรียกข้อมูลที่จัดเก็บไว้ในไฟล์ ในการดำเนินการเขียนไฟล์ เราจะใช้คลาส Scanner ร่วมกับเมธอดhasNextLine()และnextLine()เพื่อดึงข้อมูลจากไฟล์ หากต้องการปิดสตรีม เราต้องใช้ เมธอด 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();
   }
}

กำลังลบไฟล์

เมื่อประมวล ผลไฟล์ Java เราสามารถลบไฟล์โดยใช้ เมธอด Delete() ของ คลาสFile ไม่จำเป็นต้องปิดไฟล์โดยใช้ ฟังก์ชัน close()เนื่องจาก ไม่ได้ใช้คลาส FileWriterและScannerเพื่อ ลบไฟล์

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

รับข้อมูลเกี่ยวกับไฟล์

มีหลายวิธีใน Java เพื่อรับข้อมูลเกี่ยวกับไฟล์ มีการกล่าวถึงแล้วก่อนหน้านี้ในวิธีการของคลาสไฟล์

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

มาดูกันว่าโปรแกรม Java ตัวหนึ่งทำงานอย่างไรเพื่อพิจารณาว่าตัวเลขเป็นเลขคู่หรือคี่โดยใช้สตรีมอาร์เรย์ไบต์ขณะประมวลผลไฟล์ Java ในการ เขียนโปรแกรมนี้ เราจะใช้ คลาส ByteArrayInputStreamจาก แพ็คเกจ java.io คลาสนี้มีบัฟเฟอร์ที่ใช้ในการอ่านอาร์เรย์ไบต์เป็นสตรีมอินพุต ด้านล่างนี้เป็นโค้ดสำหรับตรวจสอบว่าตัวเลขเป็นเลขคู่หรือคี่

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

ฉันหวังว่าข้อมูลที่นำเสนอนี้มีประโยชน์สำหรับคุณ เพื่อให้เข้าใจการทำงานกับไฟล์ใน Java ได้ดีขึ้น คุณควรลองใช้ไฟล์และวิธีการดำเนินการทั้งหมดด้วยตัวเอง