How Java uses Synchronized to achieve multi-thread synchronization

Reasons for using synchronization

1. Multi-threads must be used to access classes in the system;

2. There are class variables in the class, or methods in the class There is access to public resources (such as reading and writing an external file).

What is the content locked by synchronization lock?

Whether you add Synchronized before a method or a variable, it locks a class object. Each object has only one lock associated with it.

The following example lists the synchronization effects in various situations

1. Synchronized is added to the method, (synchronization method, lock class instance)

Java code

public class Demo1 {             public synchronized void m1(){             //...............         }             public void m2(){             //............                 synchronized(this){                 //.........             }                 //........         }     }

The effect of these two writing methods is the same, and they lock all class instance objects. If there is a class instance object: demo = new Demo1(), and there are two threads: thread1, thread2, both calling the demo object, then, at the same time, if thread1 calls demo.m1(), then thread2 is in the demo.m1() and demo.m2() cannot be accessed within the time; because thread1 uses the lock of the demo object, it cannot be distributed to other threads for use

However, if thread1 calls demo1.m1() , thread2 can call demo2.m1() at the same time, because they call different Demo1 class object instances.

2. Synchronized is added to the variable, (synchronized block, lock class instance)

Java code

public class Demo2 {         Object a = new Object();         Object b = new Object();             public void m1(){             //............                 synchronized(a){                 //.........             }                 //........         }             public void m2(){             //............                 synchronized(b){                 //.........             }                 //........         }     }

In this case, it is implemented Code block locking, the locked object is variable a or b; (note that a and b are non-static) If there is a class instance object: demo = new Demo2(), and there are two other threads: thread1, thread2, both are called demo object, then, at the same time, if thread1 calls demo.m1(), thread2 can access demo.m2() within that time; but cannot access the synchronization block of demo.m1(), because a is blocked by thread1 Locked.

3. Synchronized locks class variables, that is, static variables (may be attributes, may be methods) (locking class objects)

Java code

public class Demo3 {         static Object o = new Object();             public static synchronized void m1() {             //....         }             public static void m2() {             //...             synchronized (Demo3.class) {                 //.....             }             //.....         }             public static void m3() {             //..........             try {                 synchronized (Class.forName("Demo3")) {                   //............                 }             } catch (ClassNotFoundException ex) {             }             //.............         }             public static void m4() {             //............            synchronized(o){              //........            }             //..........         }     }

The effects achieved in the above four methods are the same. The locked objects are all class Demo3, not class instance objects. That is, in multi-threads, the shared resources belong to the class, not the class. object. In this case, if thread1 accesses any of these four methods, no other thread can access these four methods at the same time.

4. The class method accesses a resource common to multiple threads, and the resource is variable. In this case, synchronization is also required

Java code

public class Demo4 {         static String path = "file path";             public void readConfiFile() {             synchronized (path) {                // 读取该path指定的文件。             }             }             public void writeConfiFile() {             synchronized (path) {                 //写信息到该path指定的文件。             }         }     }

In this case, it must be locked as a class variable instead of a class instance object, because this is a kind of class resource sharing of variable image, not class instance object resource sharing.

Threads have their successes and failures. If they are used well, they can improve performance. If they are not used well, they will cause endless troubles for the system.

PS: Thread synchronization requires a lot of system overhead, so when using it, if it is not necessary, try not to use the synchronization function.

The above is the detailed content of How Java uses Synchronized to achieve multi-thread synchronization. For more information, please follow other related articles on the PHP Chinese website!