Flertrådade program kan ofta komma till en situation där flera trådar försöker få åtkomst till samma resurser och till slut ger felaktiga och oförutsedda resultat.
Varför använda Java Synchronization?
Java-synkronisering används för att med någon synkroniseringsmetod säkerställa att endast en tråd kan komma åt resursen vid en given tidpunkt.
ascii-tabell i c
Java Synchronized Blocks
Java tillhandahåller ett sätt att skapa trådar och synkronisera deras uppgifter med hjälp av synkroniserade block.
Ett synkroniserat block i Java synkroniseras på något objekt. Alla synkroniserade block synkroniseras på samma objekt och kan bara ha en tråd exekverad inuti dem åt gången. Alla andra trådar som försöker komma in i det synkroniserade blocket blockeras tills tråden inuti det synkroniserade blocket lämnar blocket.
Notera: Synkroniserade block i Java är markerade med det synkroniserade nyckelordet.
Allmän form av synkroniserat block
// Only one thread can execute at a time. // sync_object is a reference to an object // whose lock associates with the monitor . // The code is said to be synchronized on // the monitor object synchronized(sync_object) { // Access shared variables and other // shared resources }>
Denna synkronisering är implementerad i Java med ett koncept som kallas monitorer eller lås. Endast en tråd kan äga en bildskärm vid en given tidpunkt. När en tråd får ett lås sägs den ha kommit in i monitorn. Alla andra trådar som försöker komma in i den låsta monitorn kommer att avbrytas tills den första tråden lämnar monitorn.
Typer av synkronisering
Det finns två synkroniseringar i Java som nämns nedan:
- Processsynkronisering
- Trådsynkronisering
1. Processsynkronisering i Java
Processsynkronisering är en teknik som används för att koordinera exekveringen av flera processer. Det säkerställer att de delade resurserna är säkra och i ordning.
2. Trådsynkronisering i Java
Trådsynkronisering används för att koordinera och ordna exekveringen av trådarna i ett flertrådigt program. Det finns två typer av trådsynkronisering som nämns nedan:
- Ömsesidigt exklusivt
- Samarbete (kommunikation mellan trådar i Java)
Ömsesidigt exklusivt
Mutual Exclusive hjälper till att förhindra att trådar stör varandra medan de delar data. Det finns tre typer av Mutual Exclusive som nämns nedan:
- Synkroniserad metod.
- Synkroniserat block.
- Statisk synkronisering.
Exempel på synkronisering
Nedan är implementeringen av Java Synchronization:
Java
länkad lista i java
// A Java program to demonstrate working of> // synchronized.> import> java.io.*;> import> java.util.*;> // A Class used to send a message> class> Sender {> > public> void> send(String msg)> > {> > System.out.println(> 'Sending '> + msg);> > try> {> > Thread.sleep(> 1000> );> > }> > catch> (Exception e) {> > System.out.println(> 'Thread interrupted.'> );> > }> > System.out.println(> '
'> + msg +> 'Sent'> );> > }> }> // Class for send a message using Threads> class> ThreadedSend> extends> Thread {> > private> String msg;> > Sender sender;> > // Receives a message object and a string> > // message to be sent> > ThreadedSend(String m, Sender obj)> > {> > msg = m;> > sender = obj;> > }> > public> void> run()> > {> > // Only one thread can send a message> > // at a time.> > synchronized> (sender)> > {> > // synchronizing the send object> > sender.send(msg);> > }> > }> }> // Driver class> class> SyncDemo {> > public> static> void> main(String args[])> > {> > Sender send => new> Sender();> > ThreadedSend S1 => new> ThreadedSend(> ' Hi '> , send);> > ThreadedSend S2 => new> ThreadedSend(> ' Bye '> , send);> > // Start two threads of ThreadedSend type> > S1.start();> > S2.start();> > // wait for threads to end> > try> {> > S1.join();> > S2.join();> > }> > catch> (Exception e) {> > System.out.println(> 'Interrupted'> );> > }> > }> }> |
>
fånga och prova java
>Produktion
Sending Hi Hi Sent Sending Bye Bye Sent>
Utgången är densamma varje gång vi kör programmet.
urfi javed
Förklaring
I exemplet ovan väljer vi att synkronisera Sender-objektet inuti run()-metoden för klassen ThreadedSend. Alternativt kan vi definiera hela send() blocket som synkroniserat , ger samma resultat. Då behöver vi inte synkronisera Message-objektet i run()-metoden i klassen ThreadedSend.
// An alternate implementation to demonstrate // that we can use synchronized with method also. class Sender { public synchronized void send(String msg) { System.out.println('Sending ' + msg); try { Thread.sleep(1000); } catch (Exception e) { System.out.println('Thread interrupted.'); } System.out.println(' ' + msg + 'Sent'); } }>
Vi behöver inte alltid synkronisera en hel metod. Ibland är det att föredra synkronisera endast en del av en metod . Java-synkroniserade block inuti metoder gör detta möjligt.
// One more alternate implementation to demonstrate // that synchronized can be used with only a part of // method class Sender { public void send(String msg) { synchronized(this) { System.out.println('Sending ' + msg ); try { Thread.sleep(1000); } catch (Exception e) { System.out.println('Thread interrupted.'); } System.out.println(' ' + msg + 'Sent'); } } }>
Exempel på den synkroniserade metoden genom att använda en anonym klass
Java
// Java Pogram to synchronized method by> // using an anonymous class> import> java.io.*;> class> Test {> > synchronized> void> test_function(> int> n)> > {> > // synchronized method> > for> (> int> i => 1> ; i <=> 3> ; i++) {> > System.out.println(n + i);> > try> {> > Thread.sleep(> 500> );> > }> > catch> (Exception e) {> > System.out.println(e);> > }> > }> > }> }> // Driver Class> public> class> GFG {> > // Main function> > public> static> void> main(String args[])> > {> > // only one object> > final> Test obj => new> Test();> > Thread a => new> Thread() {> > public> void> run() { obj.test_function(> 15> ); }> > };> > Thread b => new> Thread() {> > public> void> run() { obj.test_function(> 30> ); }> > };> > a.start();> > b.start();> > }> }> |
>
>
till strängmetoden javaProduktion
16 17 18 31 32 33>