Implementasi array ukuran variabel antarmuka daftar. Semua operasi daftar opsional diimplementasikan dan semua elemen termasuk NULL diizinkan. Selain menerapkan antarmuka daftar, kelas ini juga menyediakan beberapa metode untuk memanipulasi ukuran array yang digunakan untuk menyimpan daftar secara internal. (Kelas ini kira -kira setara dengan kelas vektor, kecuali bahwa kelas ini tidak disinkronkan.) Ukuran, ISEMPTY, GET, SET, ITERATOR, DAN OPERASI LISTITERATOR SEMUA dijalankan pada waktu yang tetap. Operasi Add berjalan pada waktu tetap bersama, yaitu, menambahkan N elemen membutuhkan waktu O (n). Semua operasi lain berjalan dalam waktu linier (secara umum). Implementasi ini memiliki faktor konstan yang lebih rendah daripada faktor konstan yang digunakan untuk implementasi LinkedList. Setiap contoh arraylist memiliki kapasitas. Kapasitas ini mengacu pada ukuran array yang digunakan untuk menyimpan daftar elemen. Itu selalu setidaknya sama dengan ukuran daftar. Karena elemen terus ditambahkan ke daftar array, kapasitasnya juga meningkat secara otomatis. Rincian strategi pertumbuhan tidak ditentukan, karena tidak sesederhana menambahkan elemen yang akan menghasilkan overhead waktu tetap. Sebelum menambahkan sejumlah besar elemen, aplikasi dapat menggunakan operasi Ensurecapacity untuk meningkatkan kapasitas contoh arraylist. Ini dapat mengurangi jumlah redistribusi tambahan.
Perhatikan bahwa implementasi ini tidak sinkron.
Jika beberapa utas mengakses instance ArrayList secara bersamaan, dan setidaknya satu dari utas secara struktural memodifikasi daftar, itu harus tetap disinkronkan secara eksternal. (Modifikasi struktural mengacu pada operasi penambahan atau menghilangkan satu atau lebih elemen, atau secara eksplisit menyesuaikan ukuran array yang mendasarinya; mengatur nilai elemen bukanlah modifikasi struktural.) Ini umumnya dilakukan dengan menyinkronkan objek yang secara alami merangkum daftar. Jika objek seperti itu tidak ada, daftar harus "dibungkus" menggunakan metode collections.synchronizedList. Ini paling baik dilakukan pada waktu penciptaan untuk mencegah akses yang tidak terduga ke daftar agar tidak disinkronkan:
ListList = collections.synchronizedList (newArrayList (...));
Iterator yang dikembalikan dengan metode Iterator dan Listiterator dari kelas ini gagal dengan cepat: Setelah membuat iterator, kecuali daftar ini dimodifikasi dari struktural dengan metode hapus atau tambah iterator sendiri, iterator akan melempar ConcurrentModificationException kapan saja dan cara apa pun untuk memodifikasi daftar. Oleh karena itu, dalam menghadapi modifikasi bersamaan, iterator akan segera gagal sepenuhnya, daripada mempertaruhkan perilaku yang tidak pasti sewenang -wenang di beberapa waktu yang tidak pasti di masa depan.
Perhatikan bahwa perilaku kegagalan cepat dari iterator tidak dapat dijamin, karena secara umum, tidak mungkin untuk membuat jaminan sulit tentang apakah ada modifikasi bersamaan yang tidak sinkron. Iterator yang gagal cepat akan melakukan yang terbaik untuk melempar ConcurrentModificationException. Oleh karena itu, adalah salah untuk menulis program yang tergantung pada pengecualian ini untuk meningkatkan kebenaran iterator tersebut: perilaku kegagalan cepat dari iterator harus digunakan hanya untuk mendeteksi bug.
Seperti yang ditunjukkan di atas, sekarang buat koleksi daftar, satu utas menulis koleksi, dan satu utas menghapus koleksi
impor java.util.arraylist; import java.util.collections; import java.util.iterator; import java.util.list; Iterator yang dikembalikan dengan metode ini cepat.*/Public void readWrite () {List <integer> nums = ArrayList baru <Integer> (); Daftar <Integer> Synnums = collections.synchronizedList (nums); // Mulai utas writelistThread baru (Syncnums). DeleteListThread (syncnums) .start ();} public static void main (string [] args) {new myarraylist (). Readwrite ();}} class writeListThread memperluas thread {private list <Integer> nums; publicelistThread (daftar <Integer) {nums) {nums) nums; publicelistThread (daftar <Integer) {nums) {nums) nums; publiceRistThread (daftar <Integer) {nums) {nums) {nums ("nums; this.nums = nums;}// Keep writing element 1 public void run() {while (true) {nums.add(new Random().nextint(1000));System.out.println(Thread.currentThread().getName());}}}class DeleteListThread extends Thread {private List<Integer> nums;public DeleteListThread(List<Integer> nums) {super ("deleteListThread"); this.nums = nums;} // hapus elemen pertama void run () {while (true) {coba {System.out.println (thread.currentThread (). getName ()+":"+nums.remove (0);} catch ().Operasi atom dapat disinkronkan dengan daftar <integer> syncnums = collections.synchronizedList (nums); Tetapi mengapa Anda perlu menambahkan sinkronisasi secara manual dengan contoh API resmi?
Daftar Daftar = Collections.SynchronizedList (ArrayList baru ()); disinkronkan (daftar) {iterator i = list.iterator (); // harus berada di blok yang disinkronkan sementara (i.hasnext ()) foo (i.next ()); }Lihat Kode Sumber Koleksi.SynchronizedList
SynchronizedCollection (koleksi <E> c) {if (c == null) lempar nullpointerException baru (); this.c = c; mutex = ini; } impor java.util.arraylist; import java.util.collections; import java.util.iterator; import java.util.list; Iterator yang dikembalikan dengan metode ini cepat.*/Public void readWrite () {List <integer> nums = ArrayList baru <Integer> (); Daftar <Integer> Synnums = collections.synchronizedList (nums); // Mulai utas writelistThread baru (Syncnums). DeleteListThread (syncnums) .start ();} public static void main (string [] args) {new myarraylist (). Readwrite ();}} class writeListThread memperluas thread {private list <Integer> nums; publicelistThread (daftar <Integer) {nums) {nums) nums; publicelistThread (daftar <Integer) {nums) {nums) nums; publiceRistThread (daftar <Integer) {nums) {nums) {nums ("nums; this.nums = nums;}// Keep writing element 1 public void run() {while (true) {nums.add(new Random().nextint(1000));System.out.println(Thread.currentThread().getName());}}}class DeleteListThread extends Thread {private List<Integer> nums;public DeleteListThread(List<Integer> nums) {super ("deleteListThread"); this.nums = nums;} // hapus elemen pertama void run () {while (true) {coba {System.out.println (thread.currentThread (). getName ()+":"+nums.remove (0);} catch ().Dapat dilihat bahwa untuk operasi sinkronisasi pengumpulan, menggunakan kelas alat pembungkus sinkronisasi koleksi, pengguna perlu menyinkronkan secara manual operasi non-atom.
Seperti yang ditunjukkan di bawah ini, tambahkan utas untuk membaca koleksi
class ReadListThread extends Thread {private List<Integer> nums;public ReadListThread(List<Integer> nums) {super("ReadListThread");this.nums = nums;}// Keep reading of elements and non-atomic operations, you need to manually add a lock public void run() {while (true) {//Sleep, hand the lock to other threads try {Thread.sleep (1000);} catch (InterruptedException e1) {e1.printstacktrace ();} disinkronkan (nums) {if (nums.size ()> 100) {iterator <integer> iter = nums.iterator (); while (iter.hasnext ()) {System.out.println(Thread.currentThread().getName() + ”:” + iter.next());;}} else{try {nums.wait(1000);}catch (InterruptedException e) {e.printStackTrace();}}}}}}}}Meringkaskan
Di atas adalah semua penjelasan terperinci dari kode sinkronisasi utas dari artikel ini tentang kerangka kerja koleksi Java, dan saya harap ini akan membantu semua orang. Teman yang tertarik dapat terus merujuk ke topik terkait lainnya di situs ini. Jika ada kekurangan, silakan tinggalkan pesan untuk menunjukkannya. Terima kasih teman atas dukungan Anda untuk situs ini!