วิธีใช้คำสำคัญที่ซิงโครไนซ์
ที่มา: สื่อ วันนี้คุณจะได้เรียนรู้ในกรณีใดบ้างและวิธีใช้คำหลักที่ซิงโครไนซ์ในภาษาการเขียนโปรแกรม Java อย่างถูกต้อง
ตัวแก้ไขที่ไม่มีการเข้าถึง
โมดิฟายเออร์ที่ไม่สามารถเข้าถึงได้จะให้ข้อมูลเกี่ยวกับคุณลักษณะของคลาส เมธอด หรือตัวแปรแก่ JVM ตัวดัดแปลงที่ไม่สามารถเข้าถึงได้ใน 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 และประเภทของสตรีม
// 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และFileOutputStreamimport 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 เราสามารถดำเนินการต่อไปนี้กับไฟล์ได้:- การสร้างไฟล์
- การเขียนข้อมูลลงไฟล์
- การอ่านข้อมูลจากไฟล์
- กำลังลบไฟล์
- รับข้อมูลเกี่ยวกับไฟล์
- การสร้างไฟล์
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 ได้ดีขึ้น คุณควรลองใช้ไฟล์และวิธีการดำเนินการทั้งหมดด้วยตัวเอง
GO TO FULL VERSION