Synchronized for Java Thread Synchronization

Summary:

1. the synchronized keyword has two scopes:
1) In an object instance, synchronized amethod () {} can prevent multiple threads from simultaneously accessing the Synchronized Method of the object (if an object has multiple synchronized methods, as long as a thread accesses one of the synchronized methods, other threads cannot simultaneously access any of this object's synchronized methods ). At this time, the synchronized methods of different object instances are irrelevant. That is to say, other threads can access the Synchronized Method in another object instance of the same class at the same time;

2) is the scope of a class. Synchronized static astaticmethod {} prevents multiple threads from simultaneously accessing the synchronized static method in this class. It can work on all object instances of the class.

2. In addition to using the synchronized keyword before the method, the synchronized keyword can also be used in a block in the method, indicating that only the resources in this block are mutually exclusive. Usage: synchronized (this) {/* block */}. Its scope is the current object;

3. the synchronized keyword cannot be inherited. That is to say, the method of the base class synchronized F () {} is not automatically synchronized F () {} in the inheritance class (){}, instead, it becomes F (){}. You need to explicitly specify a method of the inherited class as the synchronized method;

Java keywords. When used to modify a method or code block, it can ensure that at most one thread can execute the code segment at the same time.

1. When two concurrent threads access the synchronized (this) synchronization code block of the same object, only one thread can be executed within a time period. The other thread must wait until the current thread finishes executing this code block before executing this code block.

2. However, when a thread accesses a synchronized (this) synchronization code block of the object, the other thread can still access the non-synchronized (this) synchronization code block of the object.

3. When a thread accesses a synchronized (this) synchronization code block of the object, other threads perform synchronization on all other synchronized (this) access to the synchronization code block will be blocked.

4. The third example also applies to other synchronous code blocks. That is to say, when a thread accesses a synchronized (this) synchronization code block of an object, it obtains the object lock of this object. As a result, access by other threads to all the synchronized code parts of the object is temporarily blocked.

5. The above rules apply to other Object locks.

 

 

I used synchronization not long ago. Now I will go back and summarize the synchronization in Java to summarize the previous work and self-technical statements. The synchronized keyword of Java can be used as the modifier of the function or as the statement in the function, that is, the synchronization method and synchronization statement block. For further classification, synchronized can act on instance variables, object reference, static functions, and class literals (literal constants of class names.

Before further elaboration, we need to clarify several points

A. no matter whether the synchronized keyword is added to the method or object, the lock he acquires is an object, instead of using a piece of code or function as a lock, and the synchronization method is likely to be accessed by objects in other threads.

B. Each object has only one lock associated with it.

C. Implementing synchronization requires a large amount of system overhead as a cost, and may even cause deadlocks. Avoid unnecessary synchronization control as much as possible.

Next we will discuss the impact of synchronized on code in different places.

Suppose P1 and P2 are different objects of the same class. This class defines synchronization blocks or Synchronization Methods in the following situations, and P1 and P2 can call them.

Java synchronized usage Summary

1. When synchronized is used as a function modifier, the sample code is as follows:

Public synchronized void method (){

//....

}

This is the synchronization method. Which object is synchronized locked at this time? The lock is to call this synchronization method object. That is to say, when an object P1 executes this synchronization method in different threads, they form mutual exclusion to achieve synchronization. However, the other object P2 generated by the class to which this object belongs can call the method with the synchronized keyword.

The above sample code is equivalent to the following code:

Public void method ()

{

Synchronized (this) // (1)

{

//.....

}

}

(1) What does this mean? It refers to the object that calls this method, such as P1. It can be seen that the synchronization method essentially acts on the object reference. The thread that obtains the P1 object lock in zookeeper can call the synchronization method of P1. For P2, the P1 lock has nothing to do with it, in this case, the program may also get rid of the control of the synchronization mechanism, resulting in data confusion.
2. Synchronization block. The sample code is as follows:

Public void method (someobject so ){

Synchronized (SO)

{

//.....

}

}

In this case, the lock is the so object. Whoever gets the lock can run the code that he controls. When a specific object is used as a lock, the program can be written in this way, but when there is no clear object as a lock, just want to synchronize a piece of code, you can create a special instance variable (which must be an object) to act as a lock.

Class Foo implements runnable

{

Private byte [] Lock = new byte [0]; // special instance variable

Public void method ()

{

Synchronized (LOCK ){//... }

}

//.....

}

Note: creating a zero-Length byte array object is more economical than any other object. Please refer to the compiled bytecode: only three operation codes are required for generating a zero-Length byte [] object, object lock = new object () requires seven lines of operation code.
3. apply synchronized to the static function. The sample code is as follows:

Class foo

{

Public synchronized static void Method1 () // synchronized static function

{

//....

}

Public void method2 ()

{

Synchronized (FOO. Class) // class literal (Class Name literal constant)

}

}

The method2 () method in the Code uses class literal as the lock. It produces the same effect as the synchronized static function, and the obtained lock is very special, is the class of the object currently calling this method (class, instead of a specific object generated by this class ).

I remember that I saw in objective Java that Foo. Class and p1.getclass () are used for synchronization locks. p1.getclass () cannot be used to lock this class. P1 refers to the object generated by the foo class.

It can be inferred that a class defines a static function a of synchronized, and also defines the instance function B of synchronized, when the same object OBJ of this class accesses Methods A and B in multiple threads, the synchronization will not be formed because their locks are different. The lock of method A is the class to which OBJ belongs, and the lock of Method B is the object to which OBJ belongs.

The usage of Java synchronized is summarized as follows:

Figuring out which object synchronized is locked can help us design safer multi-threaded programs.

Some other tips can make the synchronized access to shared resources more secure.

1. Define the private instance variable + its get method, instead of the public/protected instance variable. If the variable is defined as public, the object can bypass the control of the synchronization method and directly obtain and change it. This is also one of the standard implementations of JavaBean.

2. if the instance variable is an object, such as an array or an arraylist, the above method is still insecure, because after the External Object obtains the reference of this instance object through the get method, and direct it to another object, so this private variable also changes, it is not very dangerous. At this time, you need to add the get method and synchronized synchronization, and only return the clone () zookeeper of this private object. In this way, the caller obtains the reference of the object copy.