1 Apa masalah konkurensi.
Beberapa proses atau utas yang mengakses sumber daya yang sama secara bersamaan (atau dalam periode waktu yang sama) akan menyebabkan masalah konkurensi.
Contoh khas adalah bahwa dua operator bank mengoperasikan akun yang sama secara bersamaan. Misalnya, operator A dan B membaca akun dengan saldo 1.000 yuan pada saat yang sama, Operator A menambahkan 100 yuan ke akun, operator B juga mengurangi 50 yuan untuk akun, A mengirimkan terlebih dahulu, dan B dikirimkan nanti. Saldo akun aktual akhir adalah 1000-50 = 950 yuan, tetapi seharusnya 1000+100-50 = 1050. Ini adalah masalah konkurensi yang khas. Bagaimana cara menyelesaikannya? Dapat menggunakan kunci.
2 Pengguna Sinkronisasi di Java
Penggunaan 1
tes kelas publik {public disinkronkan void print () {….;}}Jika utas menjalankan metode print (), objek akan dikunci. Utas lain tidak akan dapat menjalankan semua blok objek yang disinkronkan.
Penggunaan 2
tes kelas publik {public void print () {disinkronkan (this) {// Kunci objek ini…;}}} Penggunaan yang sama 1, tetapi dapat mencerminkan esensi penggunaan yang disinkronkan dengan lebih baik.
Penggunaan 3
tes kelas publik {private string a = "test"; public void print () {disinkronkan (a) {// Kunci objek ...;}} public disinkronkan void t () {…; // Blok kode yang disinkronkan ini tidak akan dikunci karena print ().}}Eksekusi print () akan mengunci objek a. Perhatikan bahwa itu tidak mengunci objek tes, yang berarti bahwa metode lain yang disinkronkan dari objek uji tidak akan dikunci karena print (). Setelah blok kode sinkronisasi dieksekusi, kunci ke A dirilis.
Untuk mengunci blok kode suatu objek tanpa mempengaruhi penulisan kinerja tinggi dari blok objek yang disinkronkan lainnya:
tes kelas publik {private byte [] lock = byte baru [0]; public void print () {disinkronkan (lock) {…;}} public disinkronkan void t () {…;}}}Kunci Metode Statis
tes kelas publik {public static void void execute () {...;}}Efek yang sama
tes kelas publik {public static void execute () {disinkronkan (testThread.class) {...;}}}3 kunci di Jawa dan antri untuk pergi ke toilet.
Kunci adalah cara untuk mencegah proses atau utas lain dari mengakses sumber daya, yaitu, sumber daya yang terkunci tidak dapat diakses oleh permintaan lain. Di Java, kata kunci Sychronized digunakan untuk mengunci objek. Misalnya:
kelas publik mystack {int idx = 0; char [] data = new char [6]; publy disinkronkan void push (char c) {data [idx] = c; idx ++;} public disinkronkan char pop () {idx-; data kembali [idx];} public static void main (string args []) {mystack. Sebenarnya, semua blok objek M yang disinkronkan terkunci. Jika ada utas lain yang mencoba mengakses M, maka T tidak dapat menjalankan metode dorong dan pop dari objek M. */m.pop (); // objek m terkunci. }}Lock-up unlocking Java persis sama dengan banyak orang yang mengantri untuk toilet umum. Orang pertama mengunci pintu dari dalam setelah masuk, jadi yang lain harus mengantri. Pintu hanya akan terbuka (membuka kunci) ketika orang pertama keluar setelah akhir. Itu adalah giliran orang kedua untuk masuk, dan dia akan mengunci pintu dari dalam lagi, dan yang lain akan terus menunggu dalam antrean.
Mudah dimengerti menggunakan teori toilet: Ketika seseorang memasuki toilet, toilet akan dikunci, tetapi itu tidak akan menyebabkan toilet lain terkunci, karena satu orang tidak dapat berjongkok di dua toilet pada saat yang sama. Untuk Java, itu berarti: Kunci di Java ditargetkan pada objek yang sama, bukan di kelas. Lihat contoh berikut:
Mystatckm1 = newMyStack (); mystatckm2 = newMystatck (); m1.pop (); m2.pop ();
Kunci objek M1 tidak akan mempengaruhi kunci M2 karena mereka bukan posisi toilet yang sama. Dengan kata lain, jika ada 3 utas T1, T2, dan T3 mengoperasikan M1, maka 3 utas ini hanya dapat mengantri dan menunggu M1. Dengan asumsi bahwa 2 utas lainnya T8, T9 mengoperasikan M2, maka T8, T9 hanya akan menunggu M2. T2 dan T8 tidak ada hubungannya dengan itu. Bahkan jika kunci pada M2 dilepaskan, T1, T2, dan T3 mungkin masih harus mengantri pada M1. Tidak ada alasan, itu bukan kursi toilet yang sama.
Java tidak dapat menambahkan dua kunci ke blok kode secara bersamaan. Ini berbeda dari mekanisme kunci database. Basis data dapat menambahkan beberapa kunci berbeda ke catatan pada saat yang sama.
4 Kapan saya harus melepaskan kuncinya?
Secara umum, kunci dilepaskan setelah blok kode sinkronisasi (blok kode terkunci) dieksekusi, atau kunci dapat dilepaskan di tengah -tengah metode tunggu (). Metode tunggu () seperti jongkok di toilet setengah jalan dan tiba -tiba saya menemukan bahwa selokan diblokir. Saya harus keluar dan berdiri di samping sehingga perbaikan saluran pembuangan (benang yang siap untuk dieksekusi notify) dapat masuk dan membersihkan toilet. Setelah pemblokiran, tuan berteriak: "Telah diperbaiki." Kawan yang keluar baru saja berbaris lagi setelah mendengarnya. Perhatikan, Anda harus menunggu tuannya keluar. Jika master tidak keluar, tidak ada yang bisa masuk. Artinya, setelah memberi tahu, utas lain dapat memasukkan area yang diblokir dan segera bergerak, tetapi utas lain dapat masuk setelah area yang diblokir di mana kode pemberitahuan dieksekusi dan dirilis untuk melepaskan kunci.
Berikut adalah contoh tunggu dan beri tahu kode:
public disinkronkan char pop () {char c; while (buffer.size () == 0) {coba {this.wait (); // di luar toilet} catch (interruptedException e) {// abaikan ...}} c = ((karakter) buffer.remove (buffer.size ()-1)). charvalue (); return c;} public disinkronkan void push (char c) {this.notify (); // beri tahu utas tunggu () untuk mengantri lagi. Catatan: Beri tahu mereka untuk kembali. Karakter charobj = karakter baru (c); buffer.addelement (charobj);} // mengeksekusi dan melepaskan kunci. Benang yang antri itu bisa masuk.Pergi lebih dalam.
Karena operasi tunggu (), kawan -kawan yang keluar setengah jalan tidak akan mengantri sampai mereka menerima sinyal pemberitahuan. Dia akan menyaksikan orang -orang mengantri di sebelahnya (master perbaikan pipa air juga di antara mereka). Perhatikan bahwa Master Perbaikan Pipa Air tidak dapat pergi ke telepon, dan ia harus mengantri seperti mereka yang pergi ke toilet. Bukannya setelah seseorang berjongkok di tengah jalan, master perbaikan pipa air tiba -tiba muncul dan masuk untuk segera memperbaikinya. Dia ingin bersaing secara adil dengan orang -orang yang awalnya mengantri, karena dia juga utas biasa. Jika master perbaikan pipa air dilapisi, orang di depan akan menemukan bahwa itu diblokir dan menunggu, kemudian keluar dan berdiri di samping, tunggu, keluar, berdiri di samping, dan hanya pergi ke master untuk masuk dan mengeksekusi notify. Dengan cara ini, setelah beberapa saat, akan ada banyak orang yang berdiri di samping antrian, menunggu untuk memberi tahu.
Akhirnya, sang Guru masuk dan memberi tahu. Apa selanjutnya?
1. Orang tunggu (utas) diberitahu.
2. Kenapa dia diberitahu, bukan orang yang menunggu lagi? Tergantung pada JVM. Kita tidak bisa pre-emptive
Tentukan mana yang akan diberitahu. Dengan kata lain, mereka yang memiliki prioritas tinggi mungkin tidak terbangun terlebih dahulu, menunggu
Setiap saat belum tentu terbangun terlebih dahulu, semuanya tidak dapat diprediksi! (Tentu saja, jika Anda tahu JVM
Jika diimplementasikan, Anda dapat memprediksi).
3. Dia (utas yang diberitahukan) perlu mengantri lagi.
4. Apakah dia akan berada di tempat pertama? Jawabannya adalah: tidak yakin. Apakah dia akan menjadi yang terakhir? Belum tentu.
Tetapi jika prioritas utas ditetapkan relatif tinggi, maka probabilitas peringkat pertama relatif tinggi.
5. Ketika gilirannya untuk masuk kembali ke kursi toilet, ia akan terus mengeksekusi dari tempat menunggu terakhir (), dan tidak akan mengeksekusi kembali.
Singkatnya dengan cara yang menjijikkan, ia akan terus mengoceh, tidak mengoceh lagi.
6. Jika master notifyall (), maka semua orang yang menyerah setengah akan berbaris lagi. Pesanan tidak diketahui.
Javadoc mengatakan bahwa TheawakenedThreadswillnotbeabletoproadreCrentThreadRelinquishthelockontHject (utas yang dibangunkan tidak dapat dieksekusi sebelum utas saat ini melepaskan kunci).
Ini jelas menjelaskan menggunakan teori kursi toilet.
Penggunaan 5Lock
Gunakan kata kunci yang disinkronkan untuk mengunci sumber daya. Kata kunci kunci juga OK. Ini baru di JDK1.5. Penggunaannya adalah sebagai berikut:
Class BoundedBuffer {final lock lock = baru reentrantlock (); kondisi akhir tigi = lock.newcondition (); kondisi akhir notempty = lock.newcondition (); objek akhir [] item = objek baru [100]; intptr, takePtr, count; public void put (objek X) melempar interruptEccepte. Taktiffull.AWAIT (); item [putptr] = x; if (++ putptr == item.length) putptr = 0; ++ count; notempty.signal ();} akhirnya {lock.unlock ();}} objek publik mengambil () melempar interruptedException {lock.lock (); try; cobalah {while {while () () (nount = no count = no count {lock. item [TakePtr]; if (++ takePtr == item.length) TakePtr = 0;-count; tisterfull.signal (); return x;} akhirnya {lock.unlock ();}}}}(Catatan: Ini adalah contoh di Javadoc, contoh implementasi dari antrian pemblokiran. Antrian pemblokiran yang disebut berarti bahwa jika antrian penuh atau kosong, itu akan menyebabkan benang pemblokiran dan menunggu. Arrayblockingqueue di Java menyediakan antrian pemblokiran siap pakai, dan Anda tidak perlu menulis salah satu secara khusus.)
Kode antara lock.lock () dan lock.unlock () dari suatu objek akan dikunci. Apa hal yang lebih baik tentang metode ini dibandingkan dengan sinkronisasi? Singkatnya, ini mengklasifikasikan utas tunggu. Untuk menggambarkannya menggunakan teori kursi toilet, mereka yang berjongkok setengah jalan dan keluar dari kursi toilet dan menunggu mungkin memiliki alasan yang berbeda. Beberapa karena toilet diblokir, dan beberapa karena toilet keluar dari air. Saat memberi tahu, Anda dapat berteriak: Jika Anda menunggu toilet diblokir, Anda akan kembali (misalnya, masalah toilet yang diblokir telah dipecahkan), atau berteriak, jika Anda menunggu toilet diblokir, Anda akan kembali dalam antrean (misalnya, masalah toilet yang akan diblokir telah diselesaikan). Ini memungkinkan kontrol yang lebih rinci. Berbeda dengan menunggu dan memberi tahu dalam sinkronisasi, apakah toilet diblokir atau toilet tidak berair, Anda hanya bisa berteriak: Saya hanya menunggu di sini untuk mengantri! Jika orang -orang dalam antrean masuk dan melihat, mereka menemukan bahwa masalah toilet baru saja diselesaikan, dan masalah yang ingin mereka selesaikan (toilet belum memiliki air) belum dipecahkan, jadi mereka harus kembali dan menunggu (tunggu), dan masuk untuk berjalan -jalan dengan sia -sia, membuang -buang waktu dan sumber daya.
Hubungan yang sesuai antara metode kunci dan disinkronkan:
LOCKAWAITSIGNALSIGNALAll
SynchronizedWaitNotifyNotifyAll
CATATAN: Jangan menelepon tunggu, memberi tahu, memberi tahu semua blok terkunci oleh kunci
6. Gunakan pipa untuk berkomunikasi di antara benang
Prinsipnya sederhana. Dua utas, satu mengoperasikan PipedInputStream dan yang lainnya mengoperasikan PipedOutputStream. Data yang ditulis oleh PipedoutputStream di -cache di buffer terlebih dahulu. Jika buffer penuh, utas ini menunggu. PipedInputStream membacakan data dalam buffer. Jika buffer tidak memiliki data, utas ini menunggu.
Fungsi yang sama dapat dicapai dengan memblokir antrian di JDK1.5.
package io;import java.io.*;public class PipedStreamTest {public static void main(String[] args) {PipedOutputStream ops=new PipedOutputStream();PipedInputStream pis=new PipedInputStream();try{ops.connect(pis);//Implement pipeline connection new Producer(ops).run();new Konsumen (pis) .run ();} catch (pengecualian e) {e.printstacktrace ();}}} // produser kelas produsen mengimplementasikan runnable {private pipedoutputStream op run(){try{ops.write("hell,spell".getBytes());ops.close();}catch(Exception e) {e.printStackTrace();}}}//Consumer class Consumer implements Runnable{private PipedInputStream pis;public Consumer(PipedInputStream pis) {this.pis=pis;}public void run () {coba {byte [] bu = byte baru [100]; int len = pis.read (bu); System.out.println (string baru (bu, 0, len)); pis.close ();} catch (pengecualian e) {e.printStacktrace ();}}}Contoh 2: Sedikit perubahan pada program di atas menjadi dua utas.
package io;import java.io.*;public class PipedStreamTest {public static void main(String[] args) {PipedOutputStream ops=new PipedOutputStream();PipedInputStream pis=new PipedInputStream();try{ops.connect(pis);//Implement pipeline connection Producer p = new Producer(ops);new Thread (p) .start (); konsumen c = konsumen baru (pis); utas baru (c) .start ();} catch (exception e) {e.printstacktrace ();}}}} // produser produsen mengimplementasikan runnable {private pipedoutsputStream ops; publicer publicer (pipedoutStrip -{private pipedOutputStream Ops; publicer publicer (PipedOutStream PipedoutStream {private Ops. run () {try {for (;;) {ops.write ("neraka, mantra" .getbytes ()); ops.close ();}}} // Kelas konsumen mengimplementasikan runnable {private PipedInputStream pis; publicer (PipedInputStream pis) {this.pis = pis; publicer (PipedInputStream pis) {this.pis = piss; {{{{{pipedInputsstream piPer {{{{pipedInpum; bu = byte baru [100]; int len = pis.read (bu); system.out.println (string baru (bu, 0, len));} pis.close ();} catch (Exception e) {e.printstacktrace ();}}}Contoh 3. Contoh ini lebih sesuai dengan aplikasi
import java.io.*;public class PipedIO {//After the program is running, copy the content of the sendFile file to the receiverFile file public static void main(String args[]){try{//Construct the read and write pipeline flow object PipedInputStream pis=new PipedInputStream();PipedOutputStream pos=new PipedOutputStream();//Implement the association pos.connect (pis); // Bangun dua utas dan mulai. pengirim baru (pos, "c: /text2.txt"). start (); receiver baru (pis, "c: /text3.txt"). start ();} catch (ioException e) {System.out.println ("Pipe error" + e);}}}} // Thread kirim kirim class kirim class extends extends " + e); Pengirim (PIPEDOUTPUTSTREAM POS, string fileName) {this.pos = pos; file = file baru (fileName);} // thread run Metode public void run () {try {// baca file konten fileInputStream fs baru = -peinpeam (file); int data; while ((data = fs.read ()! pos.write (data);} pos.close ();} catch (ioException e) {System.out.println ("kesalahan pengirim" +e);}}} // penerima kelas utas memperluas thread {pipedinputStream pis; file; // penerima metode konstruksi (pipedinputsstream piPer = pis) {piPedinput pis = pise =pere.pere.pereReSe. File (fileName);} // Thread menjalankan public void run () {try {// tulis File Stream File Objek FileOutputStream fs = baru fileOutputStream (file); int data; // baca while ((data = pis.read ())! =-1) {// tulis ke file lokal fs.write (data);} pis. e) {System.out.println ("kesalahan penerima" +e);}}}7 antrian memblokir
Antrian pemblokiran dapat menggantikan metode aliran pipa untuk mengimplementasikan mode pipa inlet/drainase (produsen/konsumen). JDK1.5 menyediakan beberapa antrian pemblokiran siap pakai. Sekarang mari kita lihat kode arrayblockingqueue sebagai berikut:
Ini antrian pemblokiran
Blockingqueue blockingq = arrayblockingqueue 10 baru;
Benang mengambil dari antrian
untuk (;;) {objek o = blockingq.take (); // antriannya kosong, lalu tunggu (blocking)}Benang lain disimpan dalam antrian
untuk (;;) {blockingq.put (objek baru ()); // Jika antrian penuh, tunggu (blocking)}Dapat dilihat bahwa memblokir antrian lebih sederhana untuk digunakan daripada pipa.
8 menggunakan pelaksana, pelaksana, ExecutorService, ThreadPoolExecutor
Anda dapat menggunakan tugas manajemen utas. Anda juga dapat menggunakan satu set kelas yang disediakan oleh JDK1.5 untuk mengelola tugas dengan lebih mudah. Dari kategori-kategori ini kita dapat mengalami cara berpikir yang berorientasi pada tugas. Kelas -kelas ini adalah:
Antarmuka pelaksana. Bagaimana menggunakan:
Executor Executor = anexecutor; // menghasilkan instance eksekutor. executor.execute (runnableTask1 ());
Niat: Pengguna hanya fokus pada pelaksanaan tugas, dan tidak perlu khawatir tentang pembuatan tugas dan detail eksekusi, dan masalah lain yang menjadi perhatian pelaksana pihak ketiga. Dengan kata lain, memisahkan eksekusi panggilan tugas dan implementasi tugas.
Bahkan, sudah ada implementasi antarmuka ini yang sangat baik di JDK1.5. Cukup.
Eksekutor adalah kelas pabrik atau kelas alat seperti koleksi, yang digunakan untuk menghasilkan contoh dari berbagai antarmuka.
Antarmuka ExecutorService diwarisi dari Executor.Executor hanya melemparkan tugas ke Executor () untuk dieksekusi, dan mengabaikan sisanya. ExecutorService berbeda, itu akan melakukan lebih banyak pekerjaan kontrol. Misalnya:
Class NetworkService {Private Final Serversocket Serversocket; Private Final ExecutorService Pool; Public NetworkService (int port, int poolsize) melempar ioException {serversocket = new Serverersocket (port); pool = excecutors.newfixedThreadpool (poolsize);} port void serve () {for (poolsIze);} public void serve () {for (poolsexize);} public void serve () {for. Handler(serverSocket.accept()));}}catch (IOException ex) {pool.shutdown();//No new tasks are executed}}}class Handler implements Runnable {private final Socket socket;Handler(Socket socket) {this.socket = socket;}public void run() {// read and service request}}Setelah ExecutorService (yaitu, objek kumpulan dalam kode) mengeksekusi shutdown, itu tidak dapat lagi menjalankan tugas baru, tetapi tugas -tugas lama akan terus dieksekusi, dan mereka yang menunggu eksekusi tidak akan lagi menunggu.
Pengajuk tugas dan komunikasi pemain
public static void main (string args []) melempar pengecualian {executorService executor = executors.newsingleThreadExecutor (); callable Task = new callable () {public string call () melempar Exception {return "test";}}; future f = executor.submit (tugas); f. return "; System.out.println (hasil); executor.shutdown ();}Execoror Instance yang diperoleh oleh Executors.NewsingletHreadExecutor () memiliki karakteristik berikut:
Eksekusi tugas secara berurutan. Misalnya:
Executor.submit (Task1); Executor.submit (Task2);
Anda harus menunggu Task1 dieksekusi sebelum Task2 dapat dieksekusi.
Task1 dan Task2 akan ditempatkan dalam antrian dan diproses oleh utas pekerja. Artinya: ada 2 utas secara total (utas utama, utas pekerja yang memproses tugas).
Untuk kelas lain, silakan merujuk ke Javadoc
9 Kontrol proses bersamaan
Contoh -contoh di bagian ini berasal dari tutorial konkurensi Java Wen Shao dan dapat diubah. Salut kepada Tn. Wen.
Penghitung pin pintu Countdownlatch
Mulai utas dan tunggu utas berakhir. Artinya, utas utama umum dan utas anak lainnya dieksekusi setelah akhir utas utama.
public static void main (string [] args) melempar Exception {// TODO Metode yang dihasilkan secara otomatis stub final int count = 10; Final Countdownlatch completeLatch = countDownlatch baru (count); // Tentukan jumlah latches do ("int i = 0; i <count; i ++) {Thread Thread = New Thread (" DOAD PROYX ("PROWER BAGIT" {i) {i thread do ("DOAD (" DOAX BARU ("DEOX BARU (" PROYX ("POERX BABY" DEOX "DEAD (" DEAD ("POERBER (" POERX BEAK. "I. completeLatch.countdown (); // kurangi satu pintu kait}}; thread.start ();} completeLatch.AWAIT (); // Jika kait pintu belum dikurangi, tunggu. }Dalam JDK1.4, metode umum adalah mengatur status deteksi utas anak dan loop dari utas utama. Kemudahan penggunaan dan efisiensi tidak baik.
Mulailah banyak utas dan tunggu pemberitahuan untuk memulai
public static void main(String[] args) throws Exception {// TODO Auto-generated method stub final CountDownLatch startLatch = new CountDownLatch(1);//Define a door latch for (int i = 0; i < 10; i++) {Thread thread = new Thread("worker thread" + i) {public void run() {try {startLatch.await();//If the door latch has not telah dikurangi, tunggu} catch (InterruptedException e) {} // do xxxx}}; thread.start ();} startlatch.countdown (); // kurangi satu pintu kait}Cyclibarrier. Hanya setelah semua utas mencapai garis awal mereka dapat terus berjalan.
CyclibarrierTest kelas publik mengimplementasikan runnable {private cyclibarrier Barrier; cyclibarrierTest publik (cyclibarrier Barrier) {this.barrier = Barrier;} public void run () {// do xxxx; coba {this.barrier.Await (); // Thread akan memeriksa apakah semua utas lainnya tiba. Jika Anda tidak tiba, terus tunggu. Ketika semua tercapai, jalankan konten bodi run function batang} catch (exception e) {}}/** * @param args */public static void main (string [] args) {// parameter 2 berarti kedua utas telah mencapai garis start sebelum mereka mulai mengeksekusi bersama cyclicbarrier belah cyclicbarrier = cyclicbarrier = cyclicbarrier cyclicbarrier = cyclicbarrier cyclicbarrier cyclicbarrier cyclicbarrier cyclicbarrier Barrier cyclicbarrier cyclicbarrier cyclicbarrier Barrier cyclicbarrier cyclicbarrier cyclicbarrier Barrier cyclicbarrier Barrier CyclicBarrier BARU CYCLICBARRUM xxxx;}}); thread t1 = utas baru (cyclibarrierTest baru (penghalang)); thread t2 = utas baru (cyclibarrierTest baru (penghalang)); t1.start (); t2.start ();}}Ini menyederhanakan cara tradisional untuk mengimplementasikan fungsi ini dengan Counter + Wait/NotifyAll.
10 Hukum Concurrency 3
Hukum Amdahl. Mengingat skala masalah, bagian paralelisasi menyumbang 12%. Kemudian, bahkan jika paralelisme diterapkan pada ekstrem, kinerja sistem hanya dapat ditingkatkan dengan 1/(1-0.12) = 1,136 kali paling banyak. Yaitu: paralelisme memiliki batas atas untuk meningkatkan kinerja sistem.
Hukum Gustafson. Hukum Gustafson mengatakan hukum Amdahl tidak menganggap bahwa lebih banyak daya komputasi dapat digunakan seiring dengan meningkatnya jumlah CPU. Intinya adalah mengubah skala masalah sehingga 88% dari pemrosesan serial yang tersisa dalam hukum Amdahl dapat diparalelkan, sehingga menembus ambang kinerja. Intinya, ini adalah semacam waktu pertukaran ruang.
Hukum Sun-Ni. Ini adalah promosi lebih lanjut dari dua undang -undang pertama. Gagasan utamanya adalah bahwa kecepatan komputasi dibatasi oleh kecepatan penyimpanan daripada CPU. Oleh karena itu, kita harus memanfaatkan sepenuhnya sumber daya komputasi seperti ruang penyimpanan dan mencoba meningkatkan skala masalah untuk menghasilkan solusi yang lebih baik/lebih akurat.
11 dari bersamaan ke paralel
Komputer perlu menghitung dengan cepat saat mengidentifikasi objek, sehingga chip menjadi panas dan panas. Ketika orang -orang mengenali objek, mereka jelas dalam sekejap, tetapi mereka tidak menyebabkan sel otak tertentu dibakar (dibesar -besarkan) dan merasa tidak nyaman. Ini karena otak adalah sistem operasi paralel terdistribusi. Sama seperti Google dapat menggunakan beberapa server Linux murah untuk melakukan perhitungan besar dan kompleks, neuron yang tak terhitung jumlahnya di otak menghitung secara independen, berbagi hasil satu sama lain, dan langsung melengkapi efek yang membutuhkan triliunan operasi untuk satu CPU tunggal. Bayangkan saja, jika dibuat di bidang pemrosesan paralel, itu akan memiliki dampak yang tak terukur pada pengembangan dan masa depan komputer. Tentu saja, tantangannya juga dapat dibayangkan: banyak masalah tidak mudah "dibagi".
Meringkaskan
Di atas adalah seluruh konten artikel ini tentang masalah konkurensi 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!