Thread synchronization requires that a running thread gain a "lock" on an object before it can access it. The thread will wait in line for another thread that is using the method/data member to be done with it. This is very important to prevent the corruption of program data if multiple threads will be accessing the same data. If two threads try to change a variable or execute the same method at the same, this can cause serious and difficult to find problems. Thread synchronization helps prevent this.
Why do we need Synchronization?
Threads are a powerful concept that we explained in the previous few chapters. Just as in the case of any programming scenario, the code works on a set of data and processes it. Lets imagine a scenario:
Assume that I have borrowed Rs. 10000/- from you and another Rs. 10000/- from an anonymous Mr. X last month. Now, both of you are chasing me for the money and I give you cheques worth the money I owe you guys, each worth Rs. 10000/- so, now I have given cheques worth Rs. 20000/- for payment. Unfortunately for you both, my account has a balance of only Rs. 12000/- and fortunately for me the banking application of my bank does not care about synchronization. So here is what will happen in a hypothetical situation wherein both the cheques are going to be submitted for payment at the same time.
Bank A (Your bank) and Bank B (Mr. X's bank) have both submitted the cheques for payment to my bank today morning at two different branches.
A teller is processing your cheque at branch 1 and another teller is processing Mr. X's cheque at branch 2. Both the tellers are simultaneously initiating the cheque clearance activity. Here is how it works:
Step 1: Teller 1 initiates a transfer at 10:30 AM and Teller 2 initiates a transfer at 10:30 AM as well
Step 2: Teller 1's system checks my bank balance at 10:31 AM and approves the payment because my account has Rs. 12,000 and Teller 2's system does the same at the same time and approves the payment because the money in my account is more than the value of the cheque I have given.
Step 3: Since both systems feel that there is enough balance in my account, they successfully make the payment.
2 cheques, each worth Rs. 10000/- got paid even though I had only Rs. 12000/- in my bank. Though I am happy about it, clearly the bank is not.
Guess what went wrong here?
There is no synchronization between the two tellers. Practically speaking, two tellers in two different branches don't need to talk to one another before processing a cheque but the banks application should handle such a situation.
All this happened because, the system allowed data related to one persons account to be accessed by two different processes(threads) and also allowed the data to be modified by both those processes at the same time.
This problem is known as a "race condition," where multiple threads can access the same Car (typically an object's instance variables), and can produce corrupted data if one thread "races in" too quickly before an operation that should be "atomic" has completed.
Practically speaking, only one of the cheques should have been cleared (whichever teller clicked "Transfer Funds" button first in milliseconds) and the other guys cheque must have bounced. This is exactly what would have happened if the first thread took a lock on the data and processed it, while all other threads that want access to the same data are in line "waiting". So, by the time the second teller clicked "Transfer funds" his process would have to wait until Teller 1's transfer is complete and then, the check balance logic would have come back stating "Hey buddy, this bum does not have enough cash to pay this cheque. Bounce this bad boy, will you?"
Now, I guess you know why we need synchronization (Only if you own a bank) but still, we now appreciate the need for synchronization.
by using synchronized class
synchornisation is the process where more than one thread can be accessed by accesssing the shared object of the class.By syncornisation we can have the communication between threads.if one thread works then another thread automatically stops
Because they are completely unrelated things? Synchronization can be implemented with semaphores or mutexes.
EUE thread is a pressure sealed thread as usual completion pup joints thread
No, a thread can't create aprocess, because the environment of the thread is a part of a process which created this thread.
by using synchronized class
The thread synchronization is done for sharing of a common resource, to find the no. of resources in use, its count ,maximum resources in use... To establish this the various synchronization tools used are.. Events Waitable Timer
Processes might need to communicate to each. Interprocess of synchronization is the?æ management of resource among process. It ensures only a single thread (process) access a resource at a particular time.
synchornisation is the process where more than one thread can be accessed by accesssing the shared object of the class.By syncornisation we can have the communication between threads.if one thread works then another thread automatically stops
Threads communicate primarily by sharing access to fields and the objects reference fields refer to. This form of communication is extremely efficient, but makes two kinds of errors possible: thread interference and memory consistency errors. The tool needed to prevent these errors is synchronization.
Synchronization is the process by which, access to the objects by threads are controlled and at at time only one thread can access an object. This is done to ensure that there are no dirty read/write operations. If multiple threads access the same data simultaneously, we may end up with inconsistent data. To avoid it, we place such code in synchronized blocks/methods to ensure integrity of data. Inter thread communication is the process by which java threads can communicate with one another. They communicate to one another through some commands like wait, notify, notifyall etc.
Transactional Synchronization Extensions was created in 2012.
current is load dependent,after synchronization only current will flow
SONET
synchronization mean arrange all process in sequence for that not occured no colusion in the system.
Because they are completely unrelated things? Synchronization can be implemented with semaphores or mutexes.
Thread safety is a term that is applied to a language's ability to safely modify the same memory location concurrently in multiple processes. A language that does not have thread safety cannot guarantee program correctness. Synchronization is one of the most common means of offering thread safety. To understand thread safety, you must first understand multitasking. A program running multiple tasks (called threads) at once does not actually run all of the threads at the exact same time. Instead, each task takes up a small sliver of the CPU's total processing time, and when it reaches a stopping point, or when an amount of time has elapsed, it is suspended, set aside, and the next task gets a chance to run. This happens so quickly that users have the appearance of many things running at once. However, when two threads are trying to use the same memory resource, bad things can happen if they are interrupted at the wrong time. Consider these two threads: Thread 1: Load x. Add 5 to x. Store this result in x. Thread 2: Load x. Add 10 to x. Store this result in x. Now, if thread 1 runs before or after thread 2, there is no problem. However, if thread 1 is interrupted, you might see a bug: X = 0 Thread 1: Load X (0) into reg1 (0). Thread 1: Add 5 to reg1 (5). Thread 2: Load x (0) into reg2 (0). Thread 2: Add 10 to reg2 (10). Thread 2: Store reg2 (10) into x (0 -> 10). Thread 1: Store reg1 (5) into x (10 -> 5). In case you missed it, you'll see that if 10 and 5 are added to x, the total should be 15. However, thread 2 preempted thread 1 at a critical point, and so thread 2 was unaware that x should have been 5, not 0. Since thread 1 had no idea that thread 2 was going to preempt the processing at that time, it didn't know that X changed to 10, and thus clobbered thread 2's work when it resumed. In order to fix this, you add a synchronization lock. This prevents a thread from starting after a critical point until the critical point has passed. It would look like this: Thread 1: Lock x. Load x. Add 5 to x. Store x. Unlock x. Thread 2: Lock x. Load x. Add 10 to x. Store x. Unlock x. Now, the logic might look like this: Thread 1: Lock x. Thread 1: Load x. Thread 1: Add 5 to x. Thread 2: Lock x. (Cannot lock, so wait). Thread 1: Store x. Thread 2: Lock x. Thread 2: Load x. Thread 2: Add 10 to x. Thread 2: Store x. In this example, thread 2 was forced to wait on the other thread. While overall processing speed is reduced, the system successfully added the numbers in order without losing any results; x would be 15 after those two threads were done.