Shulou(Shulou.com)06/02 Report--

This article introduces the relevant knowledge of "what is the difference between synchronized locking this and class". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Synchronized is a common means to deal with concurrency problems in Java language, and it is also affectionately called "Java built-in lock", which shows its high status. However, synchronized has many uses, and when it modifies different objects, its meaning is also different, let's take a look at it together.

Synchronized usage

Synchronized can be used to decorate common methods, static methods, and code blocks.

Common method of ① modification

/ * synchronized modifies the common method * / public synchronized void method () {/ /.}

When synchronized modifies a normal method, the decorated method is called a synchronous method, and its scope is the entire method, and the object is the object that calls the method.

② modified static method

/ * * synchronized modifies the static method * / public static synchronized void staticMethod () {/ /.}

When synchronized modifies a static method, its scope is the entire method, and the object is all the objects that call the class.

③ decorated code block

To reduce the granularity of locks, we can choose to use synchronized to decorate (a code block) in some part of a method, so as to lock part of the code in a method. The implementation code is as follows:

Public void classMethod () throws InterruptedException {/ / precode. / / lock code synchronized (SynchronizedExample.class) {/ /. } / / Post Code.}

When the above code is executed, the modified code block is called the synchronous statement block, and its scope is the code block enclosed in curly braces "{}", and the object is the object that calls this code block.

However, in addition to locking class, you can also lock this in the above code. The specific example is as follows:

Public void classMethod () throws InterruptedException {/ / pre-processing code. Synchronized (this) {/ / } / / Post processing code.}

So the question is, what's the difference between using synchronized to lock this and class? Aren't they all locked in the same class?

The answer is really not. There is a big difference between locking this and class. Let's look at the difference between the two through the following four examples.

1. Locked class shares an instance of a class

First, we create five threads to call the class code locked by synchronized under the same object. The specific example is as follows:

Import java.util.Date;import java.util.concurrent.TimeUnit;public class SynchronizedExample {public static void main (String [] args) {/ / create the current class instance final SynchronizedExample example = new SynchronizedExample (); / / create 5 threads to execute the task for (int I = 0; I

< 5; i++) { new Thread(new Runnable() { @Override public void run() { try { // 调用 synchronized 修饰的 class 方法 example.classMethod(); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); } } /** * synchronized 修饰的 class 方法 * @throws InterruptedException */ public void classMethod() throws InterruptedException { synchronized (SynchronizedExample.class) { System.out.println(String.format("当前执行线程:%s,执行时间:%s", Thread.currentThread().getName(), new Date())); TimeUnit.SECONDS.sleep(1); } }} 以上程序的执行结果如下：

As can be seen from the above results, the five threads share the same lock.

two。 Lock class to create multiple instances

Next, we create five threads to call the class code locked by synchronized under different objects. The specific example is as follows:

Import java.util.Date;import java.util.concurrent.TimeUnit;public class SynchronizedExample {public static void main (String [] args) {/ / create 5 threads to execute task for (int I = 0; I

< 5; i++) { new Thread(new Runnable() { @Override public void run() { try { // 创建类实例 SynchronizedExample example = new SynchronizedExample(); // 调用 synchronized 修饰的 class 方法 example.classMethod(); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); } } /** * synchronized 修饰的 class 方法 * @throws InterruptedException */ public void classMethod() throws InterruptedException { synchronized (SynchronizedExample.class) { System.out.println(String.format("当前执行线程:%s,执行时间:%s", Thread.currentThread().getName(), new Date())); TimeUnit.SECONDS.sleep(1); } }} 以上程序的执行结果如下：

As can be seen from the above results, although they are different objects, they still use the same lock.

3. Locked this shares an instance of a class

Next, we create five threads that call the example of synchronized locked this. First, our five threads call the locking method of the same object. The sample code is as follows:

Import java.util.Date;import java.util.concurrent.TimeUnit;public class SynchronizedExample {public static void main (String [] args) {/ / create the current class instance final SynchronizedExample example = new SynchronizedExample (); / / create 5 threads to execute task for (int I = 0; I < 5) New Thread +) {new Thread (new Runnable () {@ Override public void run () {try {/ / call the synchronized-decorated this method example.thisMethod () } catch (InterruptedException e) {e.printStackTrace ();}) .start () }} / * synchronized modified this method * @ throws InterruptedException * / public void thisMethod () throws InterruptedException {synchronized (this) {System.out.println ("current execution thread:% s, execution time:% s", Thread.currentThread () .getName (), new Date () TimeUnit.SECONDS.sleep (1);}

The implementation results of the above procedures are as follows:

As can be seen from the above results, the above threads all use the same lock.

4. Lock this to create multiple class instances

The last example is the most special. We use synchronized to lock this and let these five threads call their respective methods to create objects. The specific example is as follows:

Import java.util.Date;import java.util.concurrent.TimeUnit;public class SynchronizedExample {public static void main (String [] args) {/ / create 5 threads to execute task for (int I = 0; I < 5) New Thread +) {new Thread (new Runnable () {@ Override public void run () {try {/ / create (multiple) class instances SynchronizedExample example = new SynchronizedExample () / / call the synchronized-modified this method example.thisMethod ();} catch (InterruptedException e) {e.printStackTrace ();}) .start () }} / * synchronized modified this method * @ throws InterruptedException * / public void thisMethod () throws InterruptedException {synchronized (this) {System.out.println ("current execution thread:% s, execution time:% s", Thread.currentThread () .getName (), new Date () TimeUnit.SECONDS.sleep (1);}

The implementation results of the above procedures are as follows:

As can be seen from the above results, when using synchronized to lock this, if the thread does not call the same object, then the locks used by these threads are their own independent locks, which is completely different from the result of synchronized locking class.

This is the end of the content of "what is the difference between synchronized locked this and class". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.