Bagaimana untuk melaksanakan masalah pengguna-pengguna di Java?

Gunakan tunggu () dan memberitahu () untuk melaksanakan masalah pengguna pengeluar: Kaedah yang disegerakkan digunakan untuk mengawal akses kepada penampan yang dikongsi. Pengeluar menunggu apabila penampan penuh, pengguna menunggu apabila penampan kosong, dan menggunakan memberitahu () untuk membangunkan benang yang sepadan. 2. Gunakan BlockingQueue dalam pakej java.util.concurrent untuk melaksanakan pertukaran data yang selamat dengan lebih mudah, mengelakkan pengurusan manual kunci dan menunggu bersyarat.

Masalah pengguna-pengguna adalah isu penyegerakan klasik dalam multithreading di mana satu atau lebih benang (pengeluar) menjana data dan memasukkannya ke dalam penampan bersama, manakala benang lain (pengguna) mengambil dan memproses data tersebut. Cabarannya terletak pada memastikan keselamatan benang apabila mengakses penampan bersama dan mengelakkan isu -isu seperti keadaan perlumbaan, kebuntuan, atau sibuk menunggu.

Di Java, ini dapat diselesaikan dengan cekap menggunakan tunggu () , memberitahu () , dan blok yang disegerakkan , atau lebih mudah dengan kelas dari pakej java.util.concurrent . Berikut adalah dua pelaksanaan praktikal.

1. Menggunakan tunggu () dan memberitahu () dengan kaedah yang disegerakkan

Pendekatan ini secara manual menguruskan koordinasi benang menggunakan kunci intrinsik.

// Kelas Buffer Dikongsi

 Kelas SharedBuffer {<br> buffer final int [] swasta;<br> indeks int swasta = 0;<br><br> public sharedbuffer (saiz int) {<br> this.buffer = new int [size];<br> }<br><br> Hasil kekosongan yang disegerakkan awam (nilai int) melemparkan Gangguan InterruptedException {<br> sementara (index == buffer.length) {<br> // buffer penuh - tunggu pengguna<br> tunggu ();<br> }<br> penampan [indeks] = nilai;<br> System.out.println ("dihasilkan:" nilai);<br> memberitahu (); // Beritahu pengguna menunggu<br> }<br><br> Penggunaan Int yang disegerakkan awam () melemparkan Gangguan Bergerak {<br> sementara (index == 0) {<br> // buffer kosong - tunggu pengeluar<br> tunggu ();<br> }<br> int value = buffer [-index];<br> System.out.println ("dimakan:" nilai);<br> memberitahu (); // Beritahu pengeluar menunggu<br> nilai pulangan;<br> }<br> }

// Thread Pengeluar

 Pengeluar kelas melaksanakan runnable {<br> buffer sharedbuffer akhir swasta;<br><br> pengeluar awam (buffer sharedbuffer) {<br> this.buffer = buffer;<br> }<br><br> @Override<br> public void run () {<br> Cuba {<br> untuk (int i = 1; i <= 10; i) {<br> buffer.produce (i);<br> Thread.sleep (100); // simulasi masa untuk menghasilkan<br> }<br> } tangkapan (InterruptedException e) {<br> Thread.currentthread (). Interrupt ();<br> }<br> }<br> }

// benang pengguna

 Kelas Pengguna Kelas Runnable {<br> buffer sharedbuffer akhir swasta;<br><br> Pengguna awam (buffer sharedbuffer) {<br> this.buffer = buffer;<br> }<br><br> @Override<br> public void run () {<br> Cuba {<br> untuk (int i = 1; i <= 10; i) {<br> buffer.consume ();<br> Thread.Sleep (200); // simulasi masa untuk dimakan<br> }<br> } tangkapan (InterruptedException e) {<br> Thread.currentthread (). Interrupt ();<br> }<br> }<br> }

// kelas utama untuk memulakan utas

 Kelas awam ProducerConsumerExample {<br> public static void main (string [] args) {<br> SharedBuffer Buffer = New SheetBuffer (5);<br><br> Thread producertHread = thread baru (pengeluar baru (penampan), "pengeluar");<br> Thread consumerthread = thread baru (pengguna baru (penampan), "pengguna");<br><br> producerthread.start ();<br> consumerthread.start ();<br> }<br> }

2. Menggunakan BlockingQueue (disyorkan)

Cara yang lebih mudah dan lebih selamat adalah menggunakan BlockingQueue dari java.util.concurrent, yang mengendalikan penyegerakan secara dalaman.

 import java.util.concurrent.blockingqueue;<br> import java.util.concurrent.linkedblockingqueue;<br><br> kelas safeBuffer {<br> Swasta akhir Swasta <teger> giliran;<br><br> SafeBuffer awam (kapasiti int) {<br> this.queue = New LinkedBlockingQueue <> (kapasiti);<br> }<br><br> Public Void Produce (Int Value) melemparkan Gangguan InterruptedException {<br> giliran.put (nilai); // Menunggu secara automatik jika penuh<br> System.out.println ("dihasilkan:" nilai);<br> }<br><br> Penggunaan Int Awam () melemparkan Gangguan TerrectedException {<br> int value = queue.take (); // Menunggu secara automatik jika kosong<br> System.out.println ("dimakan:" nilai);<br> nilai pulangan;<br> }<br> }

Kelas pengeluar dan pengguna yang sepadan akan menggunakan safeBuffer sebaliknya, dan kaedah utama tetap sama. Versi ini mengelakkan pengurusan kunci manual dan mengurangkan risiko ralat.

Menggunakan BlockingQueue biasanya disukai kerana ia lebih bersih, kurang rawan ralat, dan menawarkan ciri-ciri tambahan seperti tamat masa ( tawaran () , pungutan () dengan tamat masa).

Pada dasarnya hanya memilih pendekatan berdasarkan keperluan anda: kawalan peringkat rendah dengan tunggu/memberitahu, atau kesederhanaan dan kebolehpercayaan dengan menyekat.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan masalah pengguna-pengguna di Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!