java concurrency

>synchronized

synchronized keyword, which includes two usages: synchronized method and synchronized block.

1>synchronized method: Declare the synchronized method by adding the synchronized keyword to the method declaration.

public synchronized void accessVal(int newVal);
The synchronized method controls access to class member variables: each class instance corresponds to a lock, and each synchronized method must obtain the lock of the class instance that calls the method. Execution, otherwise the thread to which it belongs is blocked. Once the method is executed, it will exclusively occupy the lock. The lock will not be released until returning from the method. After that, the blocked thread can obtain the lock and re-enter the executable state. This mechanism ensures that for each class instance at the same time, at most one of all its member functions declared as synchronized is in the executable state (because at most one can obtain the lock corresponding to the class instance), thus effectively avoiding the need for class members to Access conflicts of variables (as long as all methods that may access class member variables are declared as synchronized)
In Java, not only class instances, each class also corresponds to a lock, so we can also declare static member functions of the class is synchronized to control its access to the static member variables of the class. Defects of the synchronized method: If a large method is declared as synchronized, the efficiency will be greatly affected. Typically, if the thread class method run() is declared as synchronized, it will continue to run during the entire life cycle of the thread. Will cause its calls to any synchronized methods of this class to never succeed. Of course, we can solve this problem by putting the code that accesses class member variables into a special method, declaring it as synchronized, and calling it in the main method, but Java provides us with a better solution, that is synchronized block.

2> synchronized block: declare synchronized block through synchronized keyword. The grammar is as follows:

n Synchronized (Syncobject) {

// Allowed code}}
Synchronized block is such a code block, where the code must obtain the object Syncobject (as mentioned earlier, it can be a class instance or class) The lock can be executed, and the specific mechanism is the same as mentioned above. Because it can target any code block and specify the locked object arbitrarily, it has high flexibility.
Some understanding of synchronized(this):
1. When two concurrent threads access the synchronized(this) synchronization code block in the same object object, only one thread can be executed at a time. Another thread must wait for the current thread to finish executing this code block before it can execute this code block.
2. However, when a thread accesses a synchronized (this) synchronized code block of object, another thread can still access the non-synchronized (this) synchronized code block in the object.
3. What is particularly critical is that when a thread accesses a synchronized (this) synchronized code block of object, other threads will be blocked from accessing all other synchronized (this) synchronized code blocks in object.