อินเทอร์เฟซคิวอยู่ในระดับเดียวกับรายการและชุดและทั้งสองสืบทอดอินเตอร์เฟสคอลเลกชัน LinkedList ใช้อินเทอร์เฟซคิว อินเทอร์เฟซคิวแคบลงการเข้าถึงวิธี LinkedList (นั่นคือถ้าประเภทพารามิเตอร์ในวิธีการคือคิวมันสามารถเข้าถึงวิธีการที่กำหนดโดยอินเตอร์เฟสคิวและไม่สามารถเข้าถึงวิธีการไม่คายของ LinkedList) โดยตรงเพื่อให้สามารถใช้วิธีที่เหมาะสมเท่านั้น BlockingQueue สืบทอดอินเทอร์เฟซคิว
คิวเป็นโครงสร้างข้อมูล มันมีการดำเนินการพื้นฐานสองประการ: การเพิ่มองค์ประกอบในตอนท้ายของคิวและการลบองค์ประกอบออกจากหัวของคิวหมายความว่าคิวจัดการข้อมูลในวิธีแรกในครั้งแรก หากคุณพยายามเพิ่มองค์ประกอบลงในคิวการบล็อกเต็มรูปแบบหรือลบ metasector ออกจากคิวการบล็อกที่ว่างเปล่ามันจะทำให้เธรดถูกบล็อก การปิดกั้นคิวเป็นเครื่องมือที่มีประโยชน์เมื่อร่วมมือกับหลายเธรด เธรดของคนงานสามารถจัดเก็บผลลัพธ์ระดับกลางเป็นประจำในคิวการปิดกั้นในขณะที่เธรดคนงานอื่น ๆ จะนำผลลัพธ์ระดับกลางออกมาและแก้ไขในอนาคต คิวปรับสมดุลโหลดโดยอัตโนมัติ หากชุดเธรดแรกทำงานช้ากว่าชุดที่สองชุดเธรดที่สองจะบล็อกขณะรอผลลัพธ์ หากชุดเธรดแรกทำงานเร็วมันจะรอชุดเธรดที่สองเพื่อติดตาม ตารางต่อไปนี้แสดงการดำเนินการของคิวการบล็อกใน JDK1.5:
เพิ่มเพิ่ม metasearch หากคิวเต็มรูปแบบให้โยนข้อยกเว้น iiiegaislabeepeplian
ลบลบและส่งคืนองค์ประกอบที่หัวของคิว หากคิวว่างเปล่าข้อยกเว้น nosuchelementexception จะถูกโยนลงไป
องค์ประกอบส่งคืนองค์ประกอบที่หัวของคิว หากคิวว่างเปล่าข้อยกเว้น nosuchelementexception จะถูกโยนลงไป
ข้อเสนอเพิ่มองค์ประกอบและส่งคืนจริงถ้าคิวเต็มให้ส่งคืนเท็จ
โพลลบและส่งคืนองค์ประกอบในหัวของคิว หากคิวว่างเปล่าให้ส่งคืนค่า null
Peek ส่งคืนองค์ประกอบที่หัวของคิว หากคิวว่างเปล่าให้ส่งคืนค่า null
ใส่เพิ่มองค์ประกอบหากคิวเต็มบล็อก
นำลบและส่งคืนองค์ประกอบที่หัวของคิว หากคิวว่างเปล่าบล็อก
ลบองค์ประกอบข้อเสนอการสำรวจความคิดเห็นและ PEEK จริง ๆ แล้วเป็นของอินเทอร์เฟซคิว
การดำเนินการที่บล็อกคิวสามารถแบ่งออกเป็นสามหมวดหมู่ต่อไปนี้ตามคำตอบของพวกเขา: AAD, removee และการดำเนินการองค์ประกอบจะทำการยกเว้นเมื่อคุณพยายามเพิ่มองค์ประกอบในคิวเต็มหรือรับองค์ประกอบจากคิวเปล่า แน่นอนในโปรแกรมมัลติเธรดคิวอาจเต็มหรือว่างเปล่าตลอดเวลาดังนั้นคุณอาจต้องการใช้ข้อเสนอการสำรวจความคิดเห็นวิธีการดู วิธีการเหล่านี้เพียงแค่ให้ข้อความแสดงข้อผิดพลาดเมื่องานไม่เสร็จโดยไม่ต้องมีข้อยกเว้น
หมายเหตุ: วิธีการสำรวจความคิดเห็นและวิธีการมองดูข้อผิดพลาดและส่งคืนโมฆะ ดังนั้นจึงเป็นการผิดกฎหมายที่จะแทรกค่าโมฆะลงในคิว
นอกจากนี้ยังมีข้อเสนอและวิธีการสำรวจความคิดเห็นที่มีการหมดเวลาเช่นการโทรต่อไปนี้:
ความสำเร็จของบูลีน = q.offer (x, 100, timeunit.milliseconds);
ลองแทรกองค์ประกอบเข้าไปในหางของคิวใน 100 มิลลิวินาที หากประสบความสำเร็จให้กลับมาเป็นจริงทันที มิฉะนั้นเมื่อถึงหมดเวลาให้กลับมาเป็นเท็จ ในทำนองเดียวกันโทร:
หัววัตถุ = q.poll (100, timeunit.milliseconds);
หากองค์ประกอบส่วนหัวของคิวถูกลบออกภายใน 100 มิลลิวินาทีองค์ประกอบส่วนหัวจะถูกส่งคืนทันที มิฉะนั้นค่า NULL จะถูกส่งคืนเมื่อถึงหมดเวลา
ในที่สุดเรามีการปิดกั้นการดำเนินการและการดำเนินการ บล็อกวิธีการบล็อกเมื่อคิวเต็มและใช้วิธีการบล็อกเมื่อคิวว่างเปล่า
แพ็คเกจ java.ulil.concurrent มี 4 สายพันธุ์ของการปิดกั้นคิว โดยค่าเริ่มต้นความจุของ LinkedBlockingQueue ไม่ได้ จำกัด ด้านบน (ไม่ถูกต้องความจุคือจำนวนเต็ม. max_value เมื่อไม่ได้ระบุหากไม่ได้ถูกบล็อกเมื่อใส่) แต่คุณสามารถเลือกที่จะระบุความจุสูงสุด มันเป็นคิวตามรายการที่เชื่อมโยงซึ่งเรียงลำดับองค์ประกอบโดย FIFO (ครั้งแรกในครั้งแรก)
Arrayblockingqueue ต้องระบุความสามารถในระหว่างการก่อสร้างและคุณสามารถเลือกได้ว่าต้องการความยุติธรรมหรือไม่ หากพารามิเตอร์ที่เป็นธรรมถูกตั้งค่าจริงเธรดที่มีเวลารอคอยที่ยาวที่สุดจะถูกประมวลผลก่อน (อันที่จริงแล้วความยุติธรรมนี้ทำได้โดยการตั้งค่า reentrantlock ให้เป็นจริง: นั่นคือเธรดที่มีเวลารอนานที่สุดจะทำงานก่อน) โดยทั่วไปแล้วความเป็นธรรมอาจทำให้คุณมีประสิทธิภาพและใช้งานเฉพาะเมื่อจำเป็นจริงๆ มันเป็นคิวลูปบล็อกแบบอาร์เรย์ที่เรียงลำดับองค์ประกอบตามหลักการ FIFO (ครั้งแรกในครั้งแรก)
PriorityBlockingQueue เป็นคิวที่มีลำดับความสำคัญไม่ใช่คิวแรกในออกเป็นครั้งแรก องค์ประกอบจะถูกลบออกตามลำดับความสำคัญและคิวไม่มีขีด จำกัด สูงสุด (ฉันดูที่ซอร์สโค้ด PriorityBlockingQueue เป็นการห่อหุ้มของ PriorityQueue อีกครั้งซึ่งขึ้นอยู่กับโครงสร้างข้อมูลกอง priorityQueue ไม่มีขีด จำกัด ความจุเช่นเดียวกับการปิดการดำเนินการ OutofMemoryError เนื่องจากทรัพยากรที่หมดลง) แต่ถ้าคิวว่างเปล่าการดำเนินการขององค์ประกอบจะบล็อกดังนั้นการดำเนินการค้นหาจะถูกบล็อก นอกจากนี้องค์ประกอบที่เข้าสู่คิวจะต้องมีความสามารถเปรียบเทียบ
ในที่สุด DelayQueue (ดำเนินการตาม PriorityQueue) เป็นคิวการปิดกั้นที่ไม่มีขอบเขตซึ่งจัดเก็บองค์ประกอบที่ล่าช้าและองค์ประกอบสามารถสกัดได้ก็ต่อเมื่อความล่าช้าหมดอายุเท่านั้น หัวของคิวนี้เป็นองค์ประกอบที่ล่าช้าด้วยเวลาการจัดเก็บที่ยาวที่สุดหลังจากความล่าช้าหมดอายุ หากไม่มีความล่าช้าใด ๆ ที่หมดอายุคิวจะไม่มีส่วนหัวและแบบสำรวจความคิดเห็นจะกลับมาเป็นโมฆะ เมื่อวิธี getDelay (timeUnit.nanoseconds) ขององค์ประกอบส่งคืนค่าน้อยกว่าหรือเท่ากับศูนย์การหมดอายุจะเกิดขึ้นและการสำรวจความคิดเห็นจะลบองค์ประกอบ คิวนี้ไม่อนุญาตองค์ประกอบที่เป็นโมฆะ นี่คืออินเทอร์เฟซล่าช้า:
รหัส Java
อินเทอร์เฟซสาธารณะล่าช้าขยายการเปรียบเทียบ <layed> {long getDelay (หน่วย TimeUnit); -องค์ประกอบที่ทำให้ DelayQueue จะใช้วิธีการเปรียบเทียบซึ่งใช้สิ่งนี้เพื่อเรียงลำดับองค์ประกอบ
ตัวอย่างต่อไปนี้แสดงวิธีใช้คิวการบล็อกเพื่อควบคุมชุดเธรด โปรแกรมค้นหาไฟล์ทั้งหมดในไดเรกทอรีเดียวและไดเรกทอรีย่อยทั้งหมดและพิมพ์รายการไฟล์ที่มีคำหลักที่ระบุ ดังที่เห็นได้จากตัวอย่างต่อไปนี้ประโยชน์ที่สำคัญสองประการของการใช้คิวการปิดกั้นคือ: การดำเนินการหลายเธรดของคิวทั่วไปไม่จำเป็นต้องมีการซิงโครไนซ์เพิ่มเติม นอกจากนี้คิวจะปรับสมดุลโหลดโดยอัตโนมัตินั่นคือหากการประมวลผล (ทั้งสองด้านของการผลิตและการบริโภค) ถูกประมวลผลอย่างรวดเร็วมันจะถูกบล็อกซึ่งจะช่วยลดช่องว่างความเร็วในการประมวลผลระหว่างทั้งสองด้าน ต่อไปนี้คือการใช้งานเฉพาะ:
รหัส Java
คลาสสาธารณะ BlockingQueuetest {โมฆะสาธารณะคงที่หลัก (สตริง [] args) {เครื่องสแกนเนอร์ใน = สแกนเนอร์ใหม่ (System.in); System.out.print ("ป้อนไดเรกทอรีพื้นฐาน (เช่น /usr/local/jdk5.0/src):"); สตริงไดเรกทอรี = in.nextline (); System.out.print ("ป้อนคำหลัก (เช่นความผันผวน):"); คีย์เวิร์ดสตริง = in.nextline (); Final int file_queue_size = 10; // การปิดกั้นขนาดคิวสุดท้าย int search_threads = 100; // จำนวนเธรดการค้นหาคำหลัก // การปิดกั้นคิวตาม arrayblockingqueueBlockingqueue <ไฟล์> คิว = arrayblockingqueue ใหม่ <file> (file_queue_size); // เริ่มต้นหนึ่งเธรดหนึ่งเธรดเพื่อค้นหาไดเรกทอรี FileenumerationTask Enumerator = ใหม่ FileenumerationTask (คิวไฟล์ใหม่ (ไดเรกทอรี)); เธรดใหม่ (enumerator). start (); // เริ่มต้น 100 เธรดเพื่อค้นหาคำหลักที่ระบุในไฟล์สำหรับ (int i = 1; i <= search_threads; i ++) เธรดใหม่ (SearchTask ใหม่ (คิว, คีย์เวิร์ด)). start (); }} คลาส FileenumerationTask ใช้งาน Runnable {// วัตถุ metafile ที่เป็นใบ้ถูกวางไว้ที่ส่วนท้ายของคิวการบล็อกเพื่อระบุว่าไฟล์ได้รับการสำรวจไฟล์แบบคงที่สาธารณะ = ไฟล์ใหม่ (""); Private BlockingQueue <File> คิว; ไฟล์ส่วนตัวเริ่มต้นไดเรกทอรี; Public FileenumerationTask (blockingqueue <file> คิว, ไฟล์เริ่มต้นไฟล์) {this.queue = คิว; this.startingDirectory = เริ่มต้นไดเรกทอรี; } โมฆะสาธารณะเรียกใช้ () {ลอง {enumerate (เริ่มต้นไดเรกทอรี); queue.put (dummy); // ดำเนินการที่นี่เพื่อระบุว่าไฟล์ในไดเรกทอรีที่ระบุได้ถูกสำรวจ} catch (interruptedException e) {}} // วางไฟล์ทั้งหมดในไดเรกทอรีที่ระบุลงในคิวการปิดกั้น สำหรับ (ไฟล์ไฟล์: ไฟล์) {ถ้า (file.isdirectory ()) แจกแจง (ไฟล์); อื่น // วางองค์ประกอบไปที่ส่วนท้ายของคิว หากคิวเต็มให้บล็อกคิวบิ๊ก (ไฟล์); }}} คลาส SearchTask ใช้งาน runnable {ส่วนตัว BlockingQueue <file> คิว; คำหลักสตริงส่วนตัว; Public SearchTask (BlockingQueue <File> คิว, คีย์เวิร์ดสตริง) {this.queue = queue; this.keyword = คำหลัก; } โมฆะสาธารณะเรียกใช้ () {ลอง {บูลีนเสร็จ = เท็จ; ในขณะที่ (! เสร็จแล้ว) {// ดึงองค์ประกอบแรกของคิวออกมา หากคิวว่างเปล่าไฟล์บล็อกไฟล์ = queue.take (); if (file == FileenumerationTask.dummy) {// ดึงออกมาแล้วใส่ไว้เพื่อให้เธรดอื่นจะสิ้นสุดลงอย่างรวดเร็วเมื่ออ่าน queue.put (ไฟล์); เสร็จสิ้น = จริง; } การค้นหาอื่น ๆ (ไฟล์); }} catch (ioexception e) {e.printstacktrace (); } catch (interruptedException e) {}} การค้นหาโมฆะสาธารณะ (ไฟล์ไฟล์) พ่น IOException {สแกนเนอร์ใน = สแกนเนอร์ใหม่ (FileInputStream ใหม่ (ไฟล์)); int linenumber = 0; ในขณะที่ (in.hasnextline ()) {linenumber ++; สตริงบรรทัด = in.nextline (); if (line.contains (คำหลัก)) system.out.printf ("%s:%d:%s%n", file.getpath (), ผ้าลินิน, บรรทัด); } in.close (); - ลิงค์ดั้งเดิม: http://www.cnblogs.com/end/archive/2012/10/25/2738493.html
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น