1Was ist ein Parallelitätsproblem.
Mehrere Prozesse oder Threads, die gleichzeitig (oder im gleichen Zeitraum) auf dieselbe Ressource zugreifen, verursachen Parallelitätsprobleme.
Ein typisches Beispiel ist, dass zwei Bankbetreiber gleichzeitig dasselbe Konto betreiben. Zum Beispiel lesen die Betreiber A und B gleichzeitig ein Konto mit einem Guthaben von 1.000 Yuan, Betreiber A fügt dem Konto 100 Yuan hinzu, der Betreiber B reduziert auch 50 Yuan für das Konto, A einreicht und B hat sich später ein. Der endgültige tatsächliche Kontostand beträgt 1000-50 = 950 Yuan, sollte jedoch 1000+100-50 = 1050 betragen müssen. Dies ist ein typisches Problem. Wie löst ich es? Kann Schlösser verwenden.
2Us von synchronisierter Java
Verwendung 1
public class test {public synchronisierte void print () {….;}}Wenn ein Thread die Print () -Methode ausführt, wird das Objekt gesperrt. Andere Threads können nicht alle synchronisierten Blöcke des Objekts ausführen.
Verwendung 2
public class test {public void print () {synchronized (this) {// dieses Objekt sperren…;}}} Gleiche Verwendung 1, aber es kann die Essenz der synchronisierten Verwendung besser widerspiegeln.
Verwendung 3
public class test {private String a = "test"; public void print () {synchronisiert (a) {// Ein Objekt sperren ...;}} public synchronisierte void t () {…; // Dieser synchronisierte Codeblock wird aufgrund von Print () nicht gesperrt ().}}Ausführung von print () sperren Objekt a. Beachten Sie, dass es nicht das Testobjekt des Tests sperrt, was bedeutet, dass andere synchronisierte Methoden des Testobjekts aufgrund von Print () nicht gesperrt werden. Nachdem der Synchronisationscode -Block ausgeführt wurde, wird die Sperre zu A veröffentlicht.
Um den Codeblock eines Objekts zu sperren, ohne das Hochleistungsschreiben anderer synchronisierter Blöcke des Objekts zu beeinflussen:
public class test {private byte [] lock = new byte [0]; public void print () {synchronisiert (lock) {…;}} public synchronisierte void t () {…;}}Statische Methodesperre
public class test {public synchronisierte statische void execute () {…;}}Der gleiche Effekt
public class test {public static void execute () {synchronized (testthread.class) {…;}}}3 Schlösser in Java und Schlange, um auf die Toilette zu gehen.
Lock ist ein Weg, um zu verhindern, dass andere Prozesse oder Threads auf Ressourcen zugreifen, dh auf die gesperrte Ressource kann nicht von anderen Anfragen zugegriffen werden. In Java wird das sychronisierte Schlüsselwort verwendet, um ein Objekt zu sperren. Zum Beispiel:
public class mystack {int idx = 0; char [] data = new char [6]; public synchronisierte void push (char c) {data [idx] = c; idx ++;} public synchronisierte char char pop () {idx-; Streng genommen sind alle synchronisierten Objektblöcke m gesperrt. Wenn es einen weiteren Thread gibt, der versucht, auf m zuzugreifen, kann T die Push- und POP -Methoden des M -Objekts nicht ausführen. */m.pop (); // Objekt M ist gesperrt. }}Javas Lock-up-Entsperren ist genau das gleiche wie mehrere Personen, die sich für eine öffentliche Toilette anstellen. Die erste Person schloss nach dem Eintritt die Tür von innen ab, so dass die anderen in der Schlange warten mussten. Die Tür öffnet sich nur, wenn die erste Person nach dem Ende herauskommt. Es war die erste Person, die an der Reihe war, und er würde die Tür wieder von innen abschließen, und die anderen würden weiterhin in der Schlange warten.
Es ist leicht zu verstehen, die Toilettenheorie zu verwenden: Wenn eine Person eine Toilette betritt, wird die Toilette verschlossen, aber es wird nicht dazu führen, dass die andere Toilette verschlossen wird, da eine Person nicht gleichzeitig in zwei Toiletten in zwei Toiletten hocken kann. Für Java bedeutet dies: Die Schlösser in Java richten sich an dasselbe Objekt, nicht auf die Klasse. Siehe das folgende Beispiel:
Mystatckm1 = newmystack (); mystatckm2 = newmystatck (); m1.pop (); m2.pop ();
Die Schlösser von M1 -Objekten beeinflussen nicht die Schlösser von M2, da sie nicht die gleiche Toilettenposition sind. Das heißt, wenn es 3 Threads T1, T2 und T3 gibt, die M1 betreiben, können diese 3 Threads nur auf M1 anstehen und warten. Unter der Annahme, dass die anderen 2 Threads T8, T9 M2 betreiben, dann wartet T9 nur auf M2. T2 und T8 haben nichts damit zu tun. Auch wenn das Schloss auf M2 veröffentlicht wird, müssen T1, T2 und T3 möglicherweise noch auf M1 anstehen. Es gibt keinen Grund, es ist nicht der gleiche Toilettensitz.
Java kann nicht gleichzeitig zwei Schlösser zu einem Codeblock hinzufügen. Dies unterscheidet sich vom Datenbanksperrmechanismus. Die Datenbank kann gleichzeitig mehrere verschiedene Sperren zu einem Datensatz hinzufügen.
4Wenn sollte ich das Schloss veröffentlichen?
Im Allgemeinen wird die Sperre veröffentlicht, nachdem der Synchronisierungscode -Block (gesperrter Codeblock) ausgeführt wurde oder die Sperre auf halbem Weg bis Wait () veröffentlicht werden kann. Die Wait () -Methode ist wie in der Toilette auf halbem Weg und plötzlich stellte ich fest, dass der Abwasserkanal blockiert war. Ich musste herauskommen und beiseite kommen, damit der Abwasserreparatur (ein Faden, der bereit ist, Benachrichtigung auszuführen) eingehen und die Toilette löschen kann. Nach der Entblockung rief der Meister: "Es wurde repariert." Der Kamerad, der gerade herauskam, stellte sich wieder auf, nachdem er es gehört hatte. Achten Sie darauf, dass Sie warten müssen, bis der Meister herauskommt. Wenn der Meister nicht herauskommt, kann niemand einsteigen. Das heißt, nach Benachrichtigung können andere Threads den blockierten Bereich eingeben und sich sofort bewegen. Andere Threads können jedoch nach dem blockierten Bereich eingeben, in dem der Benachrichtigungscode ausgeführt und zur Veröffentlichung der Sperre freigegeben wird.
Hier ist das Beispiel für das Warten- und Benachrichtigungscode:
public synchronisierte char pop () {char c; while (buffer.size () == 0) {try {this.wait (); // aus der Toilset} catch (interruptedException e) {// ignore es…}} c = ((Zeichen) buffer.remove (puffer.size ()-1)). charValue (); return c;} public synchronisierte void push (char c) {this.notify (); // Diese Wait () threads benachrichtigen, um sich erneut zu verbinden. HINWEIS: Benachrichtigen Sie sie einfach erneut, um sie neu zu beziehen. Zeichen Charobj = neues Zeichen (c); buffer.addelement (Charobj);} // Die Sperre ausführen und freigeben. Diese in der Warnmacht in die Warnmacht einbezogenen Threads können hereinkommen.Gehen Sie tiefer.
Aufgrund der Wartezeit () Operation würden die Kameraden, die auf halber Strecke herauskamen, erst nach dem Benachrichtigungssignal angestellt. Er würde beobachten, wie sich die Leute neben ihm anstellten (der Wasserrohrreparaturmeister gehört auch unter ihnen). Beachten Sie, dass der Reparaturmeister der Wasserpfeife nicht in die Linie gehen kann und er sich wie diejenigen anstellen muss, die auf die Toilette gehen. Es ist nicht so, dass der Master der Wasserrohrreparatur plötzlich erscheinen und eingehen kann, um ihn sofort zu reparieren, nachdem eine Person auf halbem Weg geschlungen ist. Er möchte fair mit den Menschen konkurrieren, die ursprünglich anstehen, weil er auch ein gewöhnlicher Thread ist. Wenn der Meister der Wasserrohrreparatur hinter sich ist, wird die Person vorne feststellen, dass er blockiert ist und wartet. Auf diese Weise werden nach einer Weile eine Reihe von Leuten neben der Warteschlange stehen und auf Benachrichtigung warten.
Schließlich ging der Meister hinein und benachrichtigte. Was kommt als nächstes?
1. Eine Warteperson (Thread) wird benachrichtigt.
2. Warum wird er anstelle einer anderen Warteperson benachrichtigt? Hängt vom JVM ab. Wir können nicht präventiv
Bestimmen Sie, welches benachrichtigt wird. Mit anderen Worten, diejenigen mit hoher Priorität werden möglicherweise nicht zuerst geweckt und warten
Jede Zeit wird nicht unbedingt zuerst geweckt, alles ist unvorhersehbar! (Natürlich, wenn Sie die JVM kennen
Wenn Sie implementiert sind, können Sie es vorhersagen).
3. Er (der Thread benachrichtigt) muss sich erneut anstellen.
4. Wird er überhaupt in der Linie sein? Die Antwort lautet: nicht sicher. Wird er der letzte sein? Nicht unbedingt.
Wenn die Priorität des Threads jedoch relativ hoch ist, ist die Wahrscheinlichkeit, dass er zuerst eingestuft wird, relativ hoch.
5. Wenn er an der Reihe ist, den Toilettensitz wieder einzutreten, wird er weiterhin vom letzten Wartezeit () ausführen und nicht wieder ausführen.
Um es ekelhaft auszudrücken, wird er weiter streifen, um nicht wieder zu streifen.
6. Wenn der Meister notifyAll (), dann werden alle Leute, die auf halbem Weg aufgegeben haben, wieder angerichtet. Die Reihenfolge ist unbekannt.
Javadoc sagt, dass TheawakenedThreadsWillnotBeAbletoprosectheCurrentThreadrelinquishThelockonthisObject (der erwachte Thread kann nicht ausgeführt werden, bevor der aktuelle Thread die Sperre freigibt).
Dies ist offensichtlich, um die Theorie der Toilettensitztheorie zu erklären.
5LOCK -Nutzung
Verwenden Sie das synchronisierte Schlüsselwort, um die Ressourcen zu sperren. Das Schlüsselwort Sperre ist auch in Ordnung. Es ist neu in JDK1.5. Die Verwendung ist wie folgt:
Klasse BoundedBuffer {Final Lock Lock = new Reentrantlock (); endgültige Bedingung Notfull = lock.NewCondition (); endgültige Bedingung Notizty = lock.NewCondition () endgültig Objekt [] items = New Object [100]; int putptr, takeptr, takeptr, cobl. Notfull.await (); items [putptr] = x; if (++ putptr == items.länge) putptr = 0; ++ count; NotEMPTY.Signal ();} Schließlich {lock.unLlock ();}} public Object () löscht InterruptedException {lock.Lock (); items [takeptr]; if (++ takeptr == items.length) takeptr = 0;-count; Notfull.Signal (); return x;} schließlich {lock.unlock ();}}}(Hinweis: Dies ist ein Beispiel in Javadoc, einem Implementierungsbeispiel für eine blockierende Warteschlange. Die sogenannte blockierende Warteschlange bedeutet, dass, wenn eine Warteschlange voll oder leer ist, das Blockieren von Threads und das Warten verursacht. Das ArrayBlocking in Java bietet eine vorbereitete blockierende Warteschlange, und Sie müssen keine von ihnen spezifisch schreiben.)
Der Code zwischen lock.lock () und lock.unlock () eines Objekts wird gesperrt. Was ist das Bessere an dieser Methode im Vergleich zur Synchronisierung? Kurz gesagt, es klassifiziert Wait -Threads. Um es mit der Toilettensitztheorie zu beschreiben, können diejenigen, die auf halber Strecke hocken und aus dem Toilettensitz kommen und warten, unterschiedliche Gründe haben. Einige liegen daran, dass die Toilette blockiert ist und andere die Toilette nicht mehr Wasser haben. Wenn Sie benachrichtigen, können Sie rufen: Wenn Sie darauf warten, dass die Toilette blockiert wird, stehen Sie wieder in der Schlange (zum Beispiel wurde das Problem der blockierten Toilette gelöst) oder schreien, wenn Sie darauf warten, dass die Toilette blockiert wird, sind Sie wieder in der Schlange (zum Beispiel, dass die Toilette blockiert werden muss). Dies ermöglicht eine detailliertere Kontrolle. Im Gegensatz zum Warten und Benachrichtigungen in Synchronize, ob die Toilette blockiert ist oder die Toilette nicht wässrig ist, können Sie nur schreien: Ich habe nur hier darauf gewartet, dass ich mich anstellte! Wenn die Leute in der Reihe kommen und schauen, stellen sie fest, dass das Problem der Toilette nur gelöst ist und das Problem, dass sie unbedingt gelöst werden sollen (die Toilette hat kein Wasser), noch nicht gelöst wurde.
Die entsprechende Beziehung zwischen Sperrmethode und synchronisiert:
LockaWaitsignalSignalall
SynchronizedwaitnotifyNotifyAll
HINWEIS: Warten Sie nicht, benachrichtigen, benachrichtigen Sie in Blöcken, die per Sperre gesperrt sind
6. Verwenden Sie Pipelines, um zwischen Threads zu kommunizieren
Das Prinzip ist einfach. Zwei Threads, einer betreibt PipEdInputStream und der andere betreibt PipeDoutputStream. Die von PipeDoutputStream geschriebenen Daten werden zuerst im Puffer zwischengespeichert. Wenn der Puffer voll ist, wartet dieser Thread. PipedInputStream liest die Daten im Puffer vor. Wenn der Puffer keine Daten hat, wartet dieser Thread.
Die gleiche Funktion kann durch Blockieren von Warteschlangen in JDK1.5 erreicht werden.
Paket io; importieren java.io.*; public class poceedStreamtest {public static void main (String [] args) {PipeDoutputStream ops = new PipeDoutputStream (); PipEdInputStream pis = newInedInputStream (); Try {Ops.connect (PIS); // // PIPLELE -Anschluss Neue Produzent (Ops). Consumer (pis) .run ();} catch (Ausnahme E) {e.printstacktrace ();}}} // Produzent -Klassenproduzent implementiert Runnable {private pipeDoutputStream ops; öffentlicher Produzent (PipeDoutputStream) {this.ops = ops;} öffentlicher Void void void void void void void void run () {try {ops.write ("Hell, buch" .GetByTes ()); ops.close ();} catch (Ausnahme E) {E.printstacktrace ();}}} // Verbraucherklasse implementiert Verbraucherklasse implementiert runnable {private PipeputStream pis; öffentlich Verbraucher (PipedInputStum) {this.the.the.th; run () {try {byte [] bu = new byte [100]; int len = pis.read (bu); System.out.println (new String (bu, 0, len));Beispiel 2: Eine kleine Änderung des obigen Programms wird zu zwei Threads.
Paket IO; importieren java.io. Thread (p) .Start (); Verbraucher c = neuer Verbraucher (PIS); neuer Thread (c) .Start ();} catch (Ausnahme E) {E.printstacktrace ();}}}} // Produzenten -Produzent -Produzent implements runnable {private pipEmputStream ops; öffentlicher Produzent (Pipedoutputput) {this.oped -ops; {Ops; run(){try{for (;;){ops.write("hell,spell".getBytes());ops.close();}}}//Consumer class Consumer implements Runnable{private PipedInputStream pis;public Consumer(PipedInputStream pis) {this.pis=pis;}public void run(){try{for (;;){byte[] bu = new Byte [100]; int len = pis.read (bu); System.out.println (neue String (bu, 0, len));} pis.close ();} catch (Ausnahme E) {E.printstacktrace ();}}}}}}}}}}}}}}}}}}}}}}}Beispiel 3. Dieses Beispiel ist der Anwendung besser angemessen
Java.io importieren. Pos.Connect (PIS); // Konstruieren Sie zwei Threads und starten Sie. new Sender(pos,"c:/text2.txt").start();new Receiver(pis,"c:/text3.txt").start();}catch(IOException e){System.out.println("Pipe Error" + e);}}}}//Thread sends class Sender extends Thread{PipedOutputStream pos;File file;//Construction method Absender (PipeDoutputStream POS, String Dateiname) {this.pos = pos; Datei = new Datei (Dateiname);} // Thread Run-Methode public void run () {try {// Datei content FileInputStream fs = new FileInputStream (Datei); pos.write (data);} pos.close ();} catch (ioException e) {system.out.println ("Absenderfehler" +e);}}}} // Thread -Klasse -Empfänger erweitert Thread {PipEdInputStream Pis; Datei -Datei; Datei (Dateiname);} // Thread läuft public void run () {try {// Datei-Stream-Objekt-Objekt-DateiOutputStream fs = new FileOutputStream (Datei); int data; // lesen Sie while (data = pis.read ()! e) {System.out.println ("Empfängerfehler" +e);}}}7 Blockierung der Warteschlange
Die blockierende Warteschlange kann die Pipeline -Durchflussmethode ersetzen, um den Einlass-/Entwässerungsrohrmodus (Hersteller/Verbraucher) zu implementieren. JDK1.5 bietet mehrere fertige blockierende Warteschlangen. Schauen wir uns nun den Code von ArrayBlockingQueue wie folgt an:
Hier ist eine blockierende Warteschlange
BlockingQueue Blockingq = NeuarrayBlockingClocke 10;
Ein Thread nimmt aus der Warteschlange
für (;;) {Objekt o = blockingq.take (); // Die Warteschlange ist leer, dann warte (blockierend)}Ein weiterer Thread wird in der Warteschlange gespeichert
für (;;) {blockingq.put (neues Objekt ()); // Wenn die Warteschlange voll ist, warten Sie (Blocking)}}Es ist zu sehen, dass die Blockierung von Warteschlangen einfacher zu verwenden ist als Pipelines.
8use Executors, Executor, Testamentsvollstrecker, Threadpoolexecutor
Sie können Thread -Management -Aufgaben verwenden. Sie können auch eine Reihe von Klassen verwenden, die von JDK1.5 bereitgestellt werden, um Aufgaben bequemer zu verwalten. Aus diesen Kategorien können wir eine aufgabenorientierte Denkweise erleben. Diese Klassen sind:
Ausführungsschnittstelle. Wie man verwendet:
Executor Executor = Anexecutor; // Generieren Sie eine Executor -Instanz. Executor.execute (neuer Runnabletask1 ());
Absicht: Benutzer konzentrieren sich nur auf die Ausführung von Aufgaben und müssen sich keine Sorgen um Aufgabenerstellung und Ausführungsdetails sowie andere Themen machen, über die Drittanbieter implementiert sind. Das heißt, entkoppeln Sie die Ausführung der Aufgabenaufruf und die Aufgabenimplementierung.
Tatsächlich gibt es in JDK1.5 bereits hervorragende Implementierungen dieser Schnittstelle. Genug.
Executors sind eine Fabrikklasse oder eine Werkzeugklasse wie Sammlungen, mit denen Instanzen verschiedener Schnittstellen generiert werden.
Die ExecutorService -Schnittstelle wird von Executor.executor vererbt. Executorservice ist anders, es wird mehr Kontrollarbeiten erledigen. Zum Beispiel:
Klasse networkService {private final serversocket serversocket; Handler (ServerSocket.Accept ()));}} catch (ioException ex) {pool.shutdown (); // Keine neuen Aufgaben werden ausgeführt}}} Klassenhandler implementiert runnable {private endgültige Socket -Socket; Handler (Socket Socket) {this.socket = Socket;} public void run () {// les and service azet = sockket;} public void run () {//Nach dem Ausführungsdienst (dh dem Poolobjekt im Code) wird das Herunterfahren ausgeführt, es kann keine neuen Aufgaben mehr ausführen, aber die alten Aufgaben werden weiterhin ausgeführt, und diejenigen, die auf die Ausführung warten, warten nicht mehr.
Aufgaben -Einsender und Darsteller Kommunikation
public static void main (String args []) löst eine Ausnahme aus {ExecutorService Executor = Executors. System.out.println (Ergebnis); Executor.Shutdown ();}Executor -Instanz, die von Executors erhalten wurde.
Aufgabenausführung nacheinander. Zum Beispiel:
Executor.Submit (Task1); Executor.Submit (Task2);
Sie müssen warten, bis Task1 ausgeführt wird, bevor Task2 ausgeführt werden kann.
Task1 und Task2 werden in eine Warteschlange platziert und von einem Worker -Thread verarbeitet. Das heißt: Insgesamt gibt es 2 Threads (Hauptfaden, Worker -Thread, der Aufgaben verarbeitet).
Weitere Klassen finden Sie in Javadoc
9 gleichzeitige Prozesskontrolle
Die Beispiele in diesem Abschnitt stammen aus dem Java -Gleichzeit -Tutorial von Wen Shao und können geändert werden. Gruß an Mr. Wen.
Countdownlatch -Türstiftschalter
Starten Sie den Thread und warten Sie, bis der Thread endet. Das heißt, der gemeinsame Hauptfaden und andere untergeordnete Threads werden nach dem Ende des Hauptfadens ausgeführt.
public static void main(String[] args)throws Exception {// TODO Auto-generated method stub final int count=10;final CountDownLatch completeLatch = new CountDownLatch(count);//Define the number of door latches is 10 for (int i=0;i<count;i++){Thread thread = new Thread("worker thread"+i){public void run(){//do xxxx completeLatch.countdown (); // eine Türverriegelung reduzieren}}; thread.start ();} completeLatch.aawait (); // Wenn die Türverriegelung noch nicht reduziert wurde, warten Sie. }In JDK1.4 besteht die gemeinsame Methode darin, den Status des untergeordneten Threads und die Schleifenerkennung des Hauptfadens festzulegen. Benutzerfreundlichkeit und Effizienz sind nicht gut.
Starten Sie viele Themen und warten Sie, bis Benachrichtigungen beginnen
public static void main (String [] args) löst Ausnahme aus {// Todo automatisch generierte Methode Stub Final Countdownlatch startlatch = new Countdownlatch (1); // Definieren Sie einen Türriegel für (int i = 0; i <10; i ++) {thread = new thread ("Worker thread"+i). Warten Sie noch, warten Sie} catch (InterruptedException e) {} // do xxxx}}; thread.start ();} startLatch.countdown (); // eine Türverriegelung reduzieren}Cyclibarin. Erst nach allen Threads können sie eine Startlinie erreichen.
öffentliche Klasse cyclibarrierest implements runnable {private cyclibarrier barrier; public cyclibarrierest (Cyclibarrier -Barrier) {this.barrier = barrier;} public void run () {// do xxxx; probieren {this.barrier.await (); // Die Threads werden überprüft, ob andere Threads angekommen sind. Wenn Sie nicht ankommen, warten Sie weiter. When all is reached, execute the contents of the barrier's run function body}catch (Exception e) {}}/** * @param args */public static void main(String[] args) {//parameter 2 means that both threads have reached the starting line before they start to execute together CyclicBarrier barrier = new CyclicBarrier(2, new Runnable() {public void run() oderDies vereinfacht die traditionelle Möglichkeit, diese Funktion mit Counter + Wait/Notifyall zu implementieren.
10 Rechtsverkehr 3 Gesetz
Amdahls Gesetz. Angesichts der Problemskala macht der Parallelisierungsteil 12%aus. Selbst wenn die Parallelität auf das Extrem angewendet wird, kann die Leistung des Systems nur durch 1/(1-0,12) = 1,136-mal verbessert werden. Das heißt: Parallelität hat eine Obergrenze für die Verbesserung der Systemleistung.
Gustafsons Gesetz. Laut Gustafsons Gesetz wird das Amdahlsche Gesetz nicht davon ausgehen, dass mehr Rechenleistung mit zunehmender Anzahl von CPUs verwendet werden kann. Die Essenz besteht darin, die Skala des Problems so zu ändern, dass die verbleibenden 88% der seriellen Verarbeitung im Amdahlschen Gesetz parallelisiert werden können, wodurch die Leistungsschwelle durchbricht. Im Wesentlichen ist es eine Art Weltraumaustauschzeit.
Sonnen-NI-Gesetz. Es ist eine weitere Förderung der ersten beiden Gesetze. Die Hauptidee ist, dass die Rechengeschwindigkeit eher durch die Speichergeschwindigkeit als durch CPU begrenzt ist. Daher müssen wir die Rechenressourcen wie den Speicherplatz ausführlich nutzen und versuchen, das Problem zu erhöhen, um bessere/genauere Lösungen zu erstellen.
11 von gleichzeitig zu parallel
Computer müssen bei der Identifizierung von Objekten schnell berechnen, damit die Chips heiß und heiß werden. Wenn Menschen Objekte erkennen, sind sie auf einen Blick klar, aber sie verursachen keine bestimmte Gehirnzelle verbrannt (übertrieben) und fühlen sich unwohl. Dies liegt daran, dass das Gehirn ein verteiltes paralleles Betriebssystem ist. So wie Google einige billige Linux -Server verwenden kann, um riesige und komplexe Berechnungen durchzuführen, berechnen unabhängige Neuronen im Gehirn unabhängig, die Ergebnisse miteinander und vervollständigen sofort den Effekt, der Billionen von Operationen für eine einzelne CPU benötigt. Stellen Sie sich vor, es wird im Bereich der parallelen Verarbeitung erstellt, es wird sich unermessliche Auswirkungen auf die Entwicklung und die Zukunft von Computern haben. Natürlich können auch die Herausforderungen vorgestellt werden: Viele Probleme sind nicht leicht "unterteilt".
Zusammenfassen
Der oben genannte ist der gesamte Inhalt dieses Artikels über das Java -Parallelitätsproblem, und ich hoffe, dass es für alle hilfreich sein wird. Interessierte Freunde können weiterhin auf andere verwandte Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!