การวิเคราะห์หลัก
ในระหว่างการพัฒนาฟังก์ชั่นของ "การส่งสัญญาณต่อเนื่องแบบเบรกพอยต์" นั้นใช้งานได้จริงและเป็นเรื่องธรรมดาและยังฟังดู "มาตรฐาน" มากขึ้น ดังนั้นเรามักจะสนใจที่จะศึกษาว่าฟังก์ชั่นนี้ถูกนำไปใช้อย่างไร
ใน Java คุณสามารถค้นหาข้อมูลจำนวนมากเกี่ยวกับการใช้งานฟังก์ชั่นที่คล้ายกันบนอินเทอร์เน็ต อย่างไรก็ตามส่วนใหญ่ให้การสาธิตและโพสต์ซอร์สโค้ด มีคำอธิบายโดยละเอียดน้อยมากสำหรับหลักการดำเนินการ
ดังนั้นเมื่อเราติดต่อกับมันเป็นครั้งแรกเราอาจใช้รหัส CRTL + C/V โดยตรงจากนั้นจี้กับมัน แต่ในที่สุดเราก็สามารถรับเอฟเฟกต์ได้ แต่การทำเช่นนี้เมื่อคุณเป็นผู้เริ่มต้นนั้นดีและไม่ดี
ข้อได้เปรียบคือมีรหัสแหล่งที่มามากมายและคำอธิบายเล็กน้อย หากเรายินดีที่จะทำงานหนักเราจะค้นหาข้อมูลและศึกษาสิ่งที่เราไม่เข้าใจในรหัสที่โพสต์โดยผู้อื่น ในท้ายที่สุดคุณอาจได้รับรางวัลมากมาย
ข้อเสียก็ชัดเจนเช่นกัน: ในฐานะผู้เริ่มต้นเมื่อเผชิญหน้ากับซอร์สโค้ดจำนวนมากมันให้ความรู้สึกเหมือนมีหลายสิ่งหลายอย่างที่ไม่คุ้นเคยดังนั้นจึงเป็นเรื่องง่ายที่จะหวาดกลัว แม้ว่าคุณจะมีความเข้าใจอย่างคร่าวๆเกี่ยวกับการใช้งานในที่สุดคุณอาจไม่เข้าใจหลักการดำเนินการ
วันนี้มาเริ่มจากมุมมองพื้นฐานที่สุดและดูว่าสิ่งที่เรียกว่า
ในความเป็นจริงเมื่อคุณได้รับการติดต่อกับ "สิ่ง" ใหม่คุณสามารถเปลี่ยนเป็นสิ่งที่เราคุ้นเคยกับการอ้างถึงและเปรียบเทียบและเรียนรู้ โดยปกติจะเป็นสองเท่าของผลลัพธ์ด้วยความพยายามครึ่งหนึ่ง
หากเราเพิ่งสัมผัสกับแนวคิดของ "การส่งสัญญาณต่อเนื่องแบบเบรกพอยต์" มันจะยากที่จะอธิบายอย่างชัดเจนหนึ่งสองและสาม จากนั้นเราจะคุ้นเคยกับ "เล่นเกม" อย่างแน่นอน
โอเคสมมติว่าตอนนี้เรามี "เกม RPG ระดับชัดเจน" คิดเกี่ยวกับสิ่งที่เรามักจะทำเมื่อเล่นเกมประเภทนี้?
เห็นได้ชัดว่าในวันแรกที่เราต่อสู้กับการต่อสู้นองเลือดและฆ่าทุกคนโดยสมมติว่าในที่สุดเราก็มาถึงในระดับที่สี่ แม้ว่าการต่อสู้ที่ดุเดือดนั้นเต็มไปด้วยการแกว่งเมื่อฉันดูนาฬิกาบนผนังมันก็เป็นเวลา 12.00 น. และถึงเวลาเข้านอนแล้ว
มันน่าอายมากในเวลานี้ เพื่อให้ทันกับความคืบหน้าของเกมของเราในครั้งต่อไปที่เราเล่นเราควรทำอย่างไร?
มันง่ายมาก เราไม่ปิดเกมเราเข้านอนและเล่นต่อในวันถัดไป นี่ก็โอเค แต่ดูเหมือนว่ามีบางสิ่งที่ทำให้ผู้คนรู้สึกไม่สบายใจ
ดังนั้นในเวลานี้ถ้าเกมมีฟังก์ชั่นที่เรียกว่า "บันทึก" มันจะสำคัญมาก เราเลือกที่เก็บถาวรโดยตรงป้อนชื่อที่เก็บถาวร "ระดับที่สี่" จากนั้นเราสามารถปิดเกมได้
เมื่อเราเล่นเกมในครั้งต่อไปเราจะพบบันทึก "ระดับที่สี่" โดยตรงจากนั้นอ่านไฟล์แล้วเราสามารถเล่นเกมต่อไปได้
ในเวลานี้สิ่งที่เรียกว่า "การส่งสัญญาณต่อเนื่อง" นั้นง่ายต่อการเข้าใจ ลองทำตามแนวคิดก่อนหน้าของเราเกี่ยวกับ“ การเล่นเกม”:
สมมติว่ามีไฟล์ที่เราต้องดาวน์โหลดตอนนี้ เมื่อเราดาวน์โหลดบางส่วนสถานการณ์จะเกิดขึ้นเช่น: คอมพิวเตอร์ขัดข้องกำลังไฟออกเครือข่ายจะถูกขัดจังหวะ ฯลฯ
ในความเป็นจริงนี่เป็นเหมือนตอนที่เราเล่นเกมมาก่อนเราต้องเข้านอนและพักผ่อนตอน 12 โมงเช้า ตกลงแล้วสถานการณ์ในเวลานี้คือ:
• หากเกมไม่สามารถบันทึกได้หมายความว่าในครั้งต่อไปที่เราเล่นความคืบหน้าของ 4 ระดับที่ผ่านไปในครั้งนี้จะหายไปและเราไม่สามารถติดตามเกมได้
• ตามลำดับหากพฤติกรรม "ดาวน์โหลด" ไม่สามารถบันทึกความคืบหน้าของการดาวน์โหลดนี้ได้ จากนั้นเมื่อเราดาวน์โหลดไฟล์นี้อีกครั้งเราสามารถเริ่มต้นใหม่ได้
ณ จุดนี้เราได้ค้นพบจริง ๆ ว่ากุญแจสำคัญในพฤติกรรมที่เรากล่าวถึงข้างต้นคือคำว่า " ดำเนินการต่อ "!
เพื่อให้บรรลุวัตถุประสงค์ของ "ดำเนินการต่อ" พฤติกรรมที่ตัดการเชื่อมต่อกุญแจสำคัญคือการมี "สื่อ" สามารถบันทึกและอ่านข้อมูลของโหนดที่พฤติกรรมมี "การหยุดชะงัก"
เปลี่ยนเป็นโลกการเขียนโปรแกรม
ในความเป็นจริงนี่เป็นหลักการพื้นฐานที่สุดของ "การส่งสัญญาณอย่างต่อเนื่อง" ในคำธรรมดาเราต้องบันทึกข้อมูลตำแหน่งอินเตอร์รัปต์เมื่อพฤติกรรมการดาวน์โหลดถูกขัดจังหวะแล้วอ่านในพฤติกรรมถัดไป
ด้วยข้อมูลตำแหน่งนี้ลองคิดดูว่าเราควรทำอะไร ใช่มันง่ายมาก เมื่อพฤติกรรมการดาวน์โหลดใหม่เริ่มต้นดาวน์โหลดเนื้อหาโดยตรงจากตำแหน่งนี้ของบันทึกและไม่เริ่มต้นจากศูนย์อีกต่อไป
เราได้พูดถึงหลักการของภาษาธรรมดามานานและเริ่มรู้สึกเบื่อ ดังนั้นขอสรุปในตอนท้ายแล้วดูว่าเราควรแปลงหลักการเป็นโลกการเขียนโปรแกรมอย่างไร
• เมื่อพฤติกรรม "อัปโหลด (ดาวน์โหลด)" ถูกขัดจังหวะเราจำเป็นต้องบันทึกตำแหน่ง (ตำแหน่ง) ของการอัปโหลดนี้ (ดาวน์โหลด)
• เมื่อพฤติกรรม "ดำเนินการต่อ" เริ่มต้นขึ้นเราจะข้ามไปที่โพสต์โดยตรงเพื่ออัปโหลดต่อไป (ดาวน์โหลด)
เห็นได้ชัดว่ากุญแจสำคัญของปัญหาอยู่ในสิ่งที่เรียกว่า "ตำแหน่ง" ใน "เกมระดับผ่าน" ที่เรากล่าวถึง "ระดับใด" สามารถใช้เป็นหน่วยของตำแหน่งนี้
ดังนั้นเมื่อเราเปลี่ยนไปใช้สิ่งที่เรียกว่า เห็นได้ชัดว่ามันกลับสู่ไบนารีเพราะสาระสำคัญที่นี่ไม่มีอะไรมากไปกว่าการอ่านและเขียนไฟล์
จากนั้นงานที่เหลือก็ง่ายมาก ก่อนอื่นบันทึกตำแหน่งซึ่งดูเหมือนจะไม่มีอะไรคุ้มค่าที่จะพูดถึงเพราะมันเป็นเพียงการคงอยู่ของข้อมูล (หน่วยความจำไฟล์ฐานข้อมูล) และเรามีหลายวิธี
อีกกุญแจสำคัญคือเมื่อพฤติกรรม "ต่อเนื่อง" เริ่มต้นขึ้นเราต้องเริ่มต้นการดำเนินการอ่านและเขียนจากตำแหน่งที่เราบันทึกไว้ในครั้งที่แล้วดังนั้นเราจึงต้องการสิ่งที่คล้ายกับฟังก์ชัน "ตัวชี้"
แน่นอนว่าเรายังสามารถหาวิธีที่จะใช้ "ตัวชี้" เช่นนี้ แต่มีความสุขที่ Java ได้ให้ชั้นเรียนดังกล่าวแก่เรานั่นคือ RandomaccessFile
ฟังก์ชั่นของคลาสนี้สะท้อนให้เห็นอย่างสังหรณ์ใจในชื่อและสามารถเข้าถึงไฟล์แบบสุ่ม มาดูคำอธิบายของคลาสนี้ในเอกสาร API:
อินสแตนซ์ของการสนับสนุนคลาสนี้อ่านและเขียนไปยังไฟล์ที่เข้าถึงได้แบบสุ่ม การเข้าถึงไฟล์แบบสุ่มทำงานเหมือนอาร์เรย์ไบต์ขนาดใหญ่ที่เก็บไว้ในระบบไฟล์
หากมีการเข้าถึงไฟล์แบบสุ่มในโหมดอ่าน/เขียนการดำเนินการเอาต์พุตก็พร้อมใช้งานเช่นกัน การดำเนินการเอาต์พุตเริ่มต้นด้วยตัวชี้ไฟล์และก้าวหน้าตัวชี้ไฟล์เป็นไบต์ที่เขียนขึ้น
การดำเนินการส่งออกหลังจากเขียนถึงปลายปัจจุบันของอาร์เรย์โดยนัยทำให้อาร์เรย์ขยาย ตัวชี้ไฟล์สามารถอ่านผ่านวิธี getFilePointer และตั้งค่าผ่านวิธีการค้นหา
หลังจากอ่านคำแนะนำ API เราหัวเราะ ใช่นี่ไม่ใช่สิ่งที่เราต้องการใช่ไหม เรามีดคมของเรามานานแล้วทำไมเราถึงไม่สับไม้ล่ะ?
ตัวอย่างการสาธิต
เนื่องจากเป็น "ความต่อเนื่องของจุดพัก" ของไฟล์จึงเป็นที่ชัดเจนว่าเราจะสร้างไฟล์ก่อน บางทีไฟล์เสียงไฟล์ภาพ ฯลฯ จะดูดีขึ้นเล็กน้อย
แต่เราได้กล่าวไปแล้วว่าในสายตาของพี่น้องคอมพิวเตอร์ใหญ่พวกเขาจะกลับไปที่ "ไบนารี" ในที่สุด ดังนั้นเราจะสร้างไฟล์ "txt" อย่างง่ายที่นี่เพราะ TXT เอื้อต่อการทำความเข้าใจ
เราสร้างไฟล์ชื่อ "test.txt" ในไดเรกทอรีรูทของดิสก์ D. เนื้อหาไฟล์นั้นง่ายมากดังแสดงในรูป:
ถูกต้องสิ่งที่เราพิมพ์คือ 6 ตัวอักษรภาษาอังกฤษง่ายๆ จากนั้นเราคลิกขวา→คุณสมบัติ:
เราเห็นว่าไฟล์มีขนาด 6 ไบต์ นี่คือเหตุผลที่เราบอกว่าทุกอย่างแยกออกไม่ได้จาก "ไบนารี"
ใช่เราทุกคนเข้าใจเพราะเราป้อนจดหมายภาษาอังกฤษ 6 ฉบับและพื้นที่เก็บข้อมูลที่จดหมายภาษาอังกฤษ 1 ฉบับจะครอบครองคือ 1 ไบต์ (เช่น 8 บิต)
จนถึงตอนนี้สิ่งที่เราได้เห็นนั้นน่าเบื่อเพราะนี่เป็นเรื่องไร้สาระและผู้คนที่มีความรู้ด้านคอมพิวเตอร์เล็กน้อยรู้ถึงความรู้นี้ ไม่ต้องกังวลมาต่อกันเถอะ
มันง่ายต่อการอ่านและเขียนไฟล์ใน Java สมมติว่าข้อกำหนดปัจจุบันคือ "เขียนไฟล์นี้จากไดรฟ์ D เพื่อขับ E" จากนั้นเราจะยกคีย์บอร์ดและทำมันให้เสร็จ!
แต่ไม่ได้เรียกว่า "อัปโหลด (ดาวน์โหลด)" ของไฟล์ที่เรียกว่าใช่ไหม ความแตกต่างเพียงอย่างเดียวคือพฤติกรรมเปลี่ยนจาก "เพียงระหว่างชาวพื้นเมือง" เป็น "ระหว่างชาวพื้นเมือง" ถึง "ระหว่างชาวพื้นเมือง" การอ่านไฟล์และการเขียน
ในเวลานี้เราจะพูดว่า "หยุดการกระตุ้นทุกคนรู้สิ่งเหล่านี้สิ่งที่เกี่ยวกับ 'การส่งต่ออย่างต่อเนื่อง'?" อันที่จริงแล้วมันง่ายมากที่นี่ เราจะทำให้ชัดเจนอีกครั้งว่าสิ่งที่เราต้องทำในการส่งสัญญาณอย่างต่อเนื่องคือ:
หากมีการหยุดชะงักในพฤติกรรมการอ่านและการเขียนก่อนหน้านี้โปรดบันทึกข้อมูลตำแหน่งของเนื้อหาไฟล์ที่อ่านและเขียนในครั้งนี้ เมื่อ "ความต่อเนื่องเริ่มต้น" ย้ายตัวชี้โดยตรงที่นี่และเริ่มดำเนินการอ่านและเขียนต่อไป
การเน้นย้ำซ้ำ ๆ กับหลักการนั้นเป็นเพราะตราบใดที่เข้าใจหลักการส่วนที่เหลือก็เป็นเพียงการเคลื่อนไหว นี่เป็นเหมือน "Nine Nine Return to One" Dharma ในนวนิยายศิลปะการต่อสู้ระดับสูงสุดคือการกลับไปยังแหล่งเดิม
ตราบใดที่เราเข้าใจหลักการของสิ่งที่ซับซ้อนใด ๆ เราสามารถตัดมันออกไปและลดลงในสิ่งที่เรียบง่าย ในทำนองเดียวกันชุดของสิ่งที่เรียบง่ายผ่านการผสมผสานเชิงตรรกะสร้างสิ่งที่ซับซ้อน
ต่อไปเราจะกลับไปสู่ความโกลาหลในไม่ช้าและจำลอง "การส่งสัญญาณอย่างต่อเนื่อง" ในรูปแบบพื้นฐานที่สุด ที่นี่เราไม่ได้เขียนโค้ดเซิร์ฟเวอร์และเราเพิ่งทำผ่านคลาสทดสอบท้องถิ่น
เอฟเฟกต์ที่เราต้องการบรรลุนั้นง่ายมาก: เขียนไฟล์ "test.txt" บนดิสก์ D ไปยังดิสก์ E แต่เราจะจำลองพฤติกรรม "ขัดจังหวะ" ในช่วงกลางของกระบวนการแล้วอัปโหลดต่อไปอีกครั้งเพื่อดำเนินการตามกระบวนการทั้งหมดในที่สุด
กล่าวอีกนัยหนึ่งเราจะถือว่า "D Drive" เป็นคอมพิวเตอร์ที่นี่และพิจารณาว่า "E Drive" เป็นเซิร์ฟเวอร์โดยตรง จากนั้นเราจะไม่เกี่ยวข้องกับโปรโตคอล HTTP อีกต่อไปครึ่งเซ็นต์ (แน่นอนเราต้องทำกับมันในการพัฒนาจริง) ดังนั้นเราจึงสนใจเฉพาะหลักการพื้นฐานที่สุดของ "การทำลาย" และ "ดำเนินการต่อ" สำหรับการอ่านและการเขียนไฟล์
เพื่อให้ความเข้าใจของเราลึกซึ้งยิ่งขึ้นผ่านการเปรียบเทียบเราจะเขียนรหัสชิ้นหนึ่งก่อนนั่นคืออ่านและเขียนตามปกติโดยไม่ต้องหยุดชะงัก:
การทดสอบระดับสาธารณะ {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// แหล่งที่มาและไฟล์เป้าหมายไฟล์ไฟล์ filefile = ไฟล์ใหม่ ("d:/", "test.txt"); ไฟล์ targetFile = ไฟล์ใหม่ ("e:/", "test.txt"); // อินพุตและเอาต์พุตสตรีม FileInputStream FIS = NULL; fileOutputStream fos = null; // ข้อมูลบัฟเฟอร์ไบต์ [] buf = ไบต์ใหม่ [1]; ลอง {FIS = ใหม่ FileInputStream (SourceFile); FOS = ใหม่ fileOutputStream (TargetFile); // อ่านและเขียนข้อมูลในขณะที่ (fis.read (buf)! = -1) {system.out.println ("เขียนข้อมูล ... "); fos.write (buf); }} catch (filenotfoundexception e) {system.out.println ("ไฟล์ที่ระบุไม่มีอยู่"); } catch (ioexception e) {// todo: จัดการข้อยกเว้น} ในที่สุด {ลอง {// ปิดสตรีมอินพุตและเอาต์พุตถ้า (fis! = null) fis.close (); ถ้า (fos! = null) fos.close (); } catch (ioexception e) {e.printstacktrace (); - เมื่อรหัสนี้ทำงานเราจะพบว่าสำเนาของ "test.txt" ได้รับการคัดลอกสำเร็จในดิสก์อีรหัสนี้ง่ายมากสิ่งเดียวที่จะพูดคือ:
เราเห็นว่าเราตั้งค่า BUF นั่นคือขนาดของบัฟเฟอร์คือ 1 ซึ่งจริง ๆ แล้วหมายความว่าทุกครั้งที่เราอ่านเราอ่านข้อมูลไบต์ (เช่นจดหมายภาษาอังกฤษ 1 ฉบับ)
ทีนี้มาจำลองพฤติกรรมของการอ่านและเขียนขัดจังหวะ เราจะสมบูรณ์แบบรหัสก่อนหน้าดังนี้:
นำเข้า java.io.file; นำเข้า java.io.fileinputstream; นำเข้า java.io.filenotfoundexception; นำเข้า java.io.fileoutputStream; นำเข้า java.io.ioException; นำเข้า Java.io.randomaccessFile; โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// แหล่งข้อมูลและไฟล์เป้าหมายไฟล์ไฟล์ sourceFile = ไฟล์ใหม่ ("d:/", "test.txt"); ไฟล์ targetFile = ไฟล์ใหม่ ("e:/", "test.txt"); // อินพุตและเอาต์พุตสตรีม FileInputStream FIS = NULL; fileOutputStream fos = null; // ข้อมูลบัฟเฟอร์ไบต์ [] buf = ไบต์ใหม่ [1]; ลอง {FIS = ใหม่ FileInputStream (SourceFile); FOS = ใหม่ fileOutputStream (TargetFile); // ข้อมูลอ่านและเขียนในขณะที่ (fis.read (buf)! = -1) {fos.write (buf); // เมื่ออัปโหลดเนื้อหาไฟล์ 3 ไบต์ 3 ไบต์เครือข่ายขัดจังหวะและข้อยกเว้นจะถูกโยนลงถ้า (targetFile.length () == 3) {position = 3; โยน FileCascessException ใหม่ (); }}} catch (filecaccessexception e) {Keep -toing (SourceFile, TargetFile, ตำแหน่ง); } catch (filenotfoundexception e) {system.out.println ("ระบุไฟล์ไม่มีอยู่"); } catch (ioexception e) {// todo: จัดการข้อยกเว้น} ในที่สุด {ลอง {// ปิดสตรีมอินพุตและเอาต์พุตถ้า (fis! = null) fis.close (); ถ้า (fos! = null) fos.close (); } catch (ioexception e) {e.printstacktrace (); }}} โมฆะคงที่ส่วนตัวเก็บรักษา (แหล่งที่มาไฟล์เป้าหมายไฟล์ตำแหน่ง int) {ลอง {thread.sleep (10,000); } catch (interruptedException e) {// toDo บล็อก catch block ที่สร้างขึ้นอัตโนมัติ E.PrintStackTrace (); } ลอง {randomAccessFile readFile = new RandomActCessFile (แหล่งที่มา, "rw"); RandomaccessFile writefile = new RandomaccessFile (Target, "RW"); readfile.seek (ตำแหน่ง); writefile.seek (ตำแหน่ง); // ข้อมูลบัฟเฟอร์ไบต์ [] buf = ไบต์ใหม่ [1]; // ข้อมูลอ่านและเขียนในขณะที่ (readfile.read (buf)! = -1) {writefile.write (buf); }} catch (filenotfoundexception e) {// todo บล็อก catch block ที่สร้างขึ้นอัตโนมัติ e.printstacktrace (); } catch (ioexception e) {// todo บล็อก catch block ที่สร้างอัตโนมัติ e.printstacktrace (); }}} คลาส FileCecessException ขยายข้อยกเว้น {}โดยสรุปแล้วเราทำงานอะไรในการเปลี่ยนแปลงนี้:
• ก่อนอื่นเรากำหนดตำแหน่งตัวแปรเพื่อบันทึกตำแหน่งที่อ่านและเขียนเสร็จสมบูรณ์เมื่อเกิดการขัดจังหวะ (นี่คือเพื่อความสะดวกในความเป็นจริงควรกล่าวว่าค่านี้ควรเก็บไว้ในไฟล์หรือฐานข้อมูลเพื่อการคงอยู่)
• จากนั้นในขณะที่วนรอบการอ่านและการเขียนเราจำลองการเกิดขึ้นของพฤติกรรมการขัดจังหวะ ที่นี่เมื่อความยาวไฟล์ของ TargetFile คือ 3 ไบต์มันจะจำลองการขว้างข้อยกเว้นที่เราปรับแต่ง (เราสามารถจินตนาการได้ว่าในการดาวน์โหลดจริงเนื้อหาของ "X" ไบต์ได้รับการอัปโหลด (ดาวน์โหลด) และเครือข่ายถูกขัดจังหวะในเวลานี้ดังนั้นเราจะบันทึก "X" ในข้อยกเว้นที่ถูกขัดจังหวะโดยเครือข่ายขัดจังหวะ)
• ส่วนที่เหลือเป็นอย่างที่เราพูดไว้ก่อนหน้านี้หลังจากพฤติกรรม "ความต่อเนื่อง" เริ่มต้นขึ้นเราจะห่อไฟล์ของเราผ่านคลาสสุ่มที่ File แล้วระบุตัวชี้ไปยังตำแหน่งที่การขัดจังหวะก่อนหน้านี้เกิดขึ้นสำหรับการอ่านและเขียนผ่านการค้นหา
(สำหรับการดาวน์โหลดไฟล์จริงและอัปโหลดแน่นอนว่าเราจำเป็นต้องอัปโหลดค่าอินเตอร์รัปต์ที่บันทึกไว้ไปยังเซิร์ฟเวอร์วิธีนี้มักจะเป็น httpConnection.setRequestProperty ("ช่วง", "bytes = x");)
ในรหัสของเราเปิดใช้งานพฤติกรรม "ต่อเนื่อง" นั่นคือวิธีการรักษา: เราเริ่มปล่อยให้เธรดนอนหลับเป็นเวลา 10 วินาทีซึ่งเป็นการให้เราเรียกใช้โปรแกรมและดูเอฟเฟกต์
ตอนนี้เราเรียกใช้โปรแกรมไฟล์จะเริ่ม "กระบวนการอัปโหลดจาก D Disk ไปยัง E Disk" ก่อนอื่นเราคลิกที่ดิสก์ E และพบว่ามีไฟล์ test.txt เพิ่มเติมแน่นอน เปิดและค้นหาเนื้อหาดังนี้:
ถูกต้องในเวลานี้เราพบว่าเนื้อหามี "ABC" เท่านั้น นี่คือความคาดหวังของเราเนื่องจากการจำลองโปรแกรมของเราขัดจังหวะเมื่อไฟล์ถูกอัปโหลดโดย 3 ไบต์
โอเครออย่างเงียบ ๆ เป็นเวลา 10 วินาทีในการผ่านแล้วคลิกที่ไฟล์เพื่อดูว่ามันสามารถประสบความสำเร็จได้หรือไม่:
ผ่านภาพหน้าจอเราพบว่าเนื้อหาได้กลายเป็น "ABC" และทำให้ความต่อเนื่องเสร็จสมบูรณ์
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น