มีรายการพร้อมกันใน JDK ของ Java หรือไม่

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

มีการดำเนินงานที่เกิดขึ้นพร้อมกันในรายการเป็นjava.util.concurrent โดยเฉพาะอย่างยิ่งCopyOnWriteArrayList

หากคุณไม่สนใจเกี่ยวกับที่มีการเข้าถึงดัชนี-based และต้องการเพียงแค่ลักษณะการแทรกคำสั่งรักษาของรายการคุณสามารถพิจารณาjava.util.concurrent.ConcurrentLinkedQueue เนื่องจากมันใช้ Iterable ได้เมื่อคุณเพิ่มรายการทั้งหมดเสร็จแล้วคุณสามารถวนซ้ำเนื้อหาโดยใช้การปรับปรุงสำหรับไวยากรณ์:

Queue<String> globalQueue = new ConcurrentLinkedQueue<String>();

//Multiple threads can safely call globalQueue.add()...

for (String href : globalQueue) {
    //do something with href
}

คุณสามารถใช้Collections.synchronizedList (รายการ) ได้เป็นอย่างดีหากคุณต้องการเพียงแค่การซิงโครไนซ์การเรียกใช้:

 List<Object> objList = Collections.synchronizedList(new ArrayList<Object>());

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

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

ดังนั้นการทำให้องค์ประกอบอยู่ในตำแหน่งที่กำหนดnจากListการดำเนินการของอะตอมจึงไม่สมเหตุสมผลในสถานการณ์ที่คาดว่าจะมีการเข้าถึงพร้อมกัน

คุณมีตัวเลือกเหล่านี้:

• Collections.synchronizedList()คุณสามารถห่อใด ๆListการดำเนินงาน ( ArrayList, LinkedListหรือรายชื่อของบุคคลที่ 3 ก) เข้าถึงทุกวิธี (การอ่านและการเขียน) synchronizedจะได้รับการคุ้มครองโดยใช้ เมื่อใช้iterator()หรือปรับปรุงสำหรับลูปคุณต้องซิงโครไนซ์ด้วยตนเอง ในขณะที่วนซ้ำเธรดอื่น ๆ จะถูกบล็อกอย่างสมบูรณ์แม้กระทั่งการอ่าน คุณยังสามารถซิงโครไนซ์แยกกันสำหรับการโทรแต่ละครั้งhasNextและnextโทรออกได้ แต่ก็ConcurrentModificationExceptionเป็นไปได้

• CopyOnWriteArrayList: การแก้ไขมีราคาแพง แต่ไม่ต้องรอให้อ่าน Iterators ไม่เคยโยนConcurrentModificationExceptionพวกเขาคืนค่าสแนปชอตของรายการในขณะที่สร้างตัววนซ้ำแม้ว่ารายการนั้นจะถูกแก้ไขโดยเธรดอื่นในขณะที่วนซ้ำ มีประโยชน์สำหรับรายการที่อัปเดตไม่บ่อยครั้ง ต้องการการดำเนินการแบบกลุ่มเช่นaddAllอัปเดต - อาร์เรย์ภายในจะถูกคัดลอกน้อยลงหลายครั้ง

• Vector: ชอบมากsynchronizedListแต่การทำซ้ำก็ทำข้อมูลให้ตรงกันด้วย อย่างไรก็ตามตัววนซ้ำสามารถโยนConcurrentModificationExceptionได้หากเวกเตอร์ถูกแก้ไขโดยเธรดอื่นในขณะที่วนซ้ำ

ตัวเลือกอื่น:

• Collections.unmodifiableList(): ปลอดล็อคเกลียวปลอดภัย แต่ไม่สามารถแก้ไขได้
• QueueหรือDequeอาจเป็นทางเลือกถ้าคุณเพียงเพิ่ม / ลบที่ท้ายรายการและวนซ้ำรายการ ไม่มีการเข้าถึงโดยดัชนีและไม่มีการเพิ่ม / ลบในตำแหน่งที่ต้องการ พวกเขามีการใช้งานพร้อมกันหลายครั้งที่มีประสิทธิภาพที่ดีขึ้นและการเข้าถึงพร้อมกันที่ดีกว่า แต่มันเกินขอบเขตของคำถามนี้ คุณยังสามารถดูJCToolsซึ่งมีการใช้คิวที่มีประสิทธิภาพมากขึ้นสำหรับผู้บริโภครายเดียวหรือผู้ผลิตรายเดียว

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

CopyOnWriteArrayList เป็นทางเลือกที่เกิดขึ้นพร้อมกันของการทำข้อมูลให้ตรงกันโดยใช้ List List Interface และเป็นส่วนหนึ่งของ java.util.concurrent package และชุดของเธรดที่ปลอดภัย

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

CopyOnWriteArrayList ไม่ปลอดภัยและไม่ทิ้ง ConcurrentModificationException เมื่อต้นแบบ CopyOnWriteArrayList พื้นฐานได้รับการแก้ไขในระหว่างการทำซ้ำใช้ ArrayList แยกต่างหาก

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

/**
         * Returns a shallow copy of this list.  (The elements themselves
         * are not copied.)
         *
         * @return a clone of this list
         */
        public Object clone() {
            try {
                @SuppressWarnings("unchecked")
                CopyOnWriteArrayList<E> clone =
                    (CopyOnWriteArrayList<E>) super.clone();
                clone.resetLock();
                return clone;
            } catch (CloneNotSupportedException e) {
                // this shouldn't happen, since we are Cloneable
                throw new InternalError();
            }
        }

• http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CopyOnWriteArrayList.html

• https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/CopyOnWriteArrayList.html

• https://www.logicbig.com/tutorials/core-java-tutorial/java-collections/concurrent-collection-cheatsheet.html