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

This article mainly explains "how to use synchronized". The content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn how to use synchronized.

Talk about synchronized I. Preface

When it comes to java locks, the first thing that comes to mind is synchronized. This word is a mouthful, and the ability to read this word will get a lot of points in the future interview (I interviewed some people who can't read it, they said the word at the beginning of syn). It's a little unprofessional, but it's not a big problem, it can be used, and the most important thing is to understand the principle.

The content will go from simple to difficult, and sometimes you can give up some of the difficult things. It may be clearer to look back after marking it.

II. DEMO

Don't talk too much nonsense, write hello world first!

Example: Xiao Qiang and Xiao Ming live together, but there is only one toilet, and what they must do every day is to grab the pit space, so how to write it with code?

/ * * @ author day and night of Muzi *

* Human entity class * / public class Person {/ / name private String name; / / go to the toilet public void gotoWc () {Wc.useWc (this);} public String getName () {return name;} public void setName (String name) {this.name = name }} / * @ author day and night * * toilet entity class * / public class Wc {/ * people using toilet method * @ param p people using toilet * / public static void useWc (Person p) {try {System.out.println (p.getName ()) + "using toilet!") ; TimeUnit.SECONDS.sleep (10); System.out.println (p.getName () + "run out!") ;} catch (Exception e) {/ / if the toilet breaks down, you have to stop using System.out.println (p.getName () + "run out!") } / * * @ author the day and night of Muzi * this test is that Xiao Qiang negotiated with Xiao Ming that Xiao Qiang will come first and Xiao Ming will come again * this will not conflict because it is the agreed sequence of execution * everyone knows that the order will not go wrong * / public class SyncTest {public static void main (String) [] args) {/ / small strong object Person xiaoqiang = new Person () Xiaoqiang.setName ("Xiaoqiang"); / / Xiaoming object Person xiaoming = new Person (); xiaoming.setName ("Xiaoming"); / / toilet xiaoqiang.gotoWc (); xiaoming.gotoWc ();}}

Go to the toilet:

What if the two don't discuss it and go to their own?

/ * * @ author day and night * / public class SyncTest02 {public static void main (String [] args) {/ / Xiaoqiang object Person xiaoqiang = new Person (); xiaoqiang.setName ("Xiaoqiang"); / / Xiaoming object Person xiaoming = new Person (); xiaoming.setName ("Xiaoming") / / start two threads regardless of who does their own new Thread (()-> xiaoqiang.gotoWc ()). Start (); new Thread (()-> xiaoming.gotoWc ()). Start ();}}

Go to the toilet:

The picture above obviously shows that Xiao Qiang didn't finish it, and Xiao Ming went to do it. If the small ones make a living, what about the big ones? Think about the picture by yourself.

At this time, you may have thought, is the toilet door unlocked? Can't anyone just go in and lock it up?

Right!

/ * @ author day and night * * after the transformation of the toilet entity class * / public class Wc {/ * use the toilet method * synchronized: who goes first to the toilet will be locked immediately! * @ param p people using the toilet * / public static synchronized void useWc (Person p) {try {System.out.println (p.getName ()) + "using the toilet!") ; TimeUnit.SECONDS.sleep (10); System.out.println (p.getName () + "run out!") ;} catch (Exception e) {/ / if the toilet breaks down, you have to stop using System.out.println (p.getName () + "run out!") ;}} / * * @ author day and night * / public class SyncTest02 {public static void main (String [] args) {/ / Xiaoqiang object Person xiaoqiang = new Person (); xiaoqiang.setName ("Xiaoqiang"); / / Xiaoming object Person xiaoming = new Person (); xiaoming.setName ("Xiaoming") / / start two threads regardless of who does it himself, but this time the toilet has a lock, / / whoever goes in first will lock the lock new Thread (()-> xiaoqiang.gotoWc ()). Start (); new Thread (()-> xiaoming.gotoWc ()). Start ();}}

Go to the toilet:

As you can see, Xiaoqiang finished first, and Xiaoming went on again, so there won't be any problems.

Some people may ask, only see locked, unlocked, how did Xiao Ming get in?

This is a feature of synchronized, which automatically releases the lock, and the lock is automatically released after the code of the synchronized package is executed.

So avoid the embarrassment caused by forgetting to release the lock.

Third, pretend academic discussion 3.1 Why is it locked?

Take the toilet as an example, you want to go. Suggest that the word "shared resources" is right.

3.2 object lock class lock

1) object lock, as its name implies, is to lock an object.

/ * * @ author's round-the-clock * object lock * / public class SyncObject {/ * cumulative value (shared resource) * / int count = 0; / * * lock object * / private Object lock = new Object (); public static void main (String [] args) {SyncObject so = new SyncObject () / / Thread 1 new Thread (()-> {try {for (;;) {TimeUnit.SECONDS.sleep (2); so.increaseCount ();}} catch (Exception e) {System.err.println ("error") }}, Thread 1) .start (); / Thread 2 new Thread (()-> {try {for (;;) {TimeUnit.SECONDS.sleep (2); so.increaseCount () }} catch (Exception e) {System.err.println ("error");}}, "Thread 2") .start ();} / * count accumulation * / public void increaseCount () {/ / locked synchronized (lock) {count = count+1 System.out.println (Thread.currentThread (). GetName () + "count=" + count);}

In the example: two threads add count, and the object is locked by lock, which is called object lock.

Sometimes I see synchronized (this). What kind of lock is this? This refers to the current object, and also the object lock.

Synchronized (this) is equivalent to adding synchronized to a method, and the following two methods are the current objects of the lock

/ * count accumulation * / public void increaseCount () {/ / lock synchronized (this) {count= count+1; System.out.println (Thread.currentThread (). GetName () + "count=" + count);}} / * * count accumulation lock * / public synchronized void increaseCount02 () {count= count+1 System.out.println (Thread.currentThread (). GetName () + "count=" + count);}

2) A class lock, as its name implies, is to lock a class.

After each class load to memory, it is he who generates an object lock of type Class.

In fact, it also locks an object, but this object is special, it represents a class.

/ * * @ author's round-the-clock * object lock * / public class SyncObject03 {/ * cumulative value (shared resource) * / static int count = 0; / * * lock object * / private Object lock = new Object (); public static void main (String [] args) {SyncObject03 so = new SyncObject03 () / / Thread 1 new Thread (()-> {for (;;) {SyncObject03.increaseCount ();}}, Thread 1) .start (); / Thread 2 new Thread (()-> {for (;;) {SyncObject03.increaseCount () }}, "Thread 2"). Start ();} / * * count accumulation * / public synchronized static void increaseCount () {/ / locked try {count= count+1; System.out.println (Thread.currentThread (). GetName () + "count=" + count); TimeUnit.SECONDS.sleep (1) } catch (Exception e) {System.err.println ("error ~");}} / * count accumulation * / public void increaseCount02 () {synchronized (SyncObject03.class) {/ / locking try {count = count+1 System.out.println (Thread.currentThread (). GetName () + "count=" + count); TimeUnit.SECONDS.sleep (1);} catch (Exception e) {System.err.println ("error ~");}

Both of the above are class locks.

3.3 can the unlocked method of the current object be executed when the locked method is executed?

This is an answer that can be thought of with your toes, but many interviewers ask. After asking, you were fooled ~ can't you?

The answer is: yes!

Why can you? Love because of love ~ ~ wrong, start over.. Because you can, you can.

Xiaoming is eating, lock the bowl, others can't use it, can Xiaoming watch his idol Deng Ziqi sing at the same time?

If anyone says no, he will not be allowed to play with his cell phone, pad or computer after dinner. Just let him eat (that's a pig)

/ * * @ day and night of author Muzi * possible interview questions * / public class SyncObject04 {private Object lock = new Object (); public static void main (String [] args) throws InterruptedException {SyncObject04 so = new SyncObject04 (); / / Thread 1 new Thread (()-> {so.increaseCount ();}, Thread 1). Start (); Thread.sleep (2000) / / Thread 2 new Thread (()-> {so.lookMv ();}, "Thread 2") .start ();} / * eat * / public void increaseCount () {/ / locked synchronized (this) {try {System.out.println ("eat") / / you can also chat with girls here at dinner chatWithGirl (); TimeUnit.SECONDS.sleep (10);} catch (Exception e) {System.err.println ("the meal fell to the ground");} System.out.println ("finish the meal") }} / * watch concert video * / public void lookMv () {System.out.println ("watch concert video");} / * watch chat with beauties * / public void chatWithGirl () {System.out.println ("chat with beauties");}}

3.4 reentrant

Can you sum it up in one sentence?

Ahem: the same thread can call two methods with the same lock without blocking.

Example: the same person can use the same pair of chopsticks and eat different dishes.

When you get the lock when eating fish, you can call the eat salad method in the fish eating method, because the two methods use the same lock.

/ * * @ author day and night * / public class TestC {/ * A pair of chopsticks can only be used by one person at the same time (one thread) * / Object chopsticks = new Object (); public static void main (String [] args) {TestC c = new TestC (); new Thread (()-> {c.eatFish ();}) .start () } / * eat * / public void eatFish () {synchronized (chopsticks) {try {System.out.println ("eat fish"); Thread.sleep (2000); eatSalad () } catch (Exception e) {}} / * eat salad * / public void eatSalad () {synchronized (chopsticks) {try {System.out.println ("eat salad"); Thread.sleep (2000); eatFish () } catch (Exception e) {} 3.5 underlying implementation (1) simple version

Before jdk1.6, synchronized was a heavyweight lock. What is a heavyweight lock? That is, every time the lock goes to the operating system to apply for the lock.

Jdk1.6 and later improvements to lock upgrades

The simple idea is:

Synchronized (object)

Thread A first to access

The bias lock only records the thread ID of thread An in the markword of object

If thread A comes in again to visit markword and see that the thread number of thread is itself, then use the

At this time thread B came, thread B looked at me to wipe? Someone took the lock!

Thread B will loop to death, etc., similar to at the toilet door, knock on the door and ask thread An if you are ready? Knock on the door and ask thread An are you ready? Knock on the door and ask thread An are you ready? Knock on the door and ask thread An are you ready?

This operation of thread B will be called, in technical terms, spin lock

Thread B asks 10 times and does not get the lock, it will be upgraded to a heavy lock (go to the operating system to apply for resources)

No lock-> bias lock-> spin lock-> weight lock

The lock is ordinary. Only upgrade but not demotion

(2) introduction to the simple description of the complex version of CAS

What is the ABA problem? if you have a wife, I say take stealing pocket money as an example.

Https://www.processon.com/view/link/603c96ca07912913b4f2c55f

This is a story: the story of Xiao Qiang stealing pocket money and inviting Xiao Ming to dinner.

ABA is:

The money for Xiaoqiang's wife to go out to see is 100000 (A)

Xiao Qiang stole 10,000 and left 90,000 (B)

Xiaoqiang borrowed 10,000 from Xiaoyue and put it back for a total of 100000 (A)

Xiaoqiang's wife came back to see that it was 100000, very satisfied. But she didn't know it was a change of post.

Later, Xiaoqiang's wife read my blog and found the secret. How should she solve it?

Keyword: version version number

Before she went to work, she wrote a version with a pen on her family's savings. If Xiaoqiang steals money again and gives it back, this version will change (+ 1).

This solves the ABA problem.

two。 Locking process

Heavy competition: too much time-consuming, too much wait, etc.

The new object may be anonymously biased directly (if the bias lock is turned on by default), because it is not biased towards any thread, so it is anonymous biased

JVM defaults to enable bias lock only after a delay of 4 seconds

3. New what does an object look like? What is markword?

1. Viewing tool: JOL (Java Object Layout)

Directly introduce maven and you can use it.

Day and night of org.openjdk.jol jol-core 0.9 / * @ author wood * / public class Person {long money; public long getMoney () {return money;} public void setMoney (long money) {this.money = money Day and night of author wood * / public class JolTest {public static void main (String [] args) {Person p = new Person (); System.out.println (ClassLayout.parseInstance (p). ToPrintable ()) }} / / output result Person object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 01 00 00 00 4 4 (object header) 00 00 00 8 4 (object header) 43 c1 00 f8 12 4 (alignment/padding gap) 16 8 long Person.money 0Instance size: 24 bytesSpace losses: 4 bytes internal + 0 bytes external = 4 bytes total

Huh? Aren't you going to write synchronized?

2. Markword

I lock the object p and output the layout to see that the markword has changed

So ~ ~ the lock information is recorded in markword.

/ * * @ author day and night * / public class JolTest {public static void main (String [] args) {Person p = new Person (); System.out.println (ClassLayout.parseInstance (p). ToPrintable ()); synchronized (p) {System.out.println (ClassLayout.parseInstance (p). ToPrintable ());}

Is markword so good? Oh, no! It could be better. Let's see what information is recorded in it.

Let's take a look at the last 3bit for the time being. At this time, you can compare the output of the layout above.

At first it was 01 and then it became 00 (without opening the bias lock directly to the lightweight lock)

Let's take a look at the last 2bit:

00: lightweight lock spin lock

Spin lock, consumption of CPU resources is in user mode operation unrelated kernel state

Two threads compete to put their own Lock Record in the markword

Who put it in first, who gets the lock first, and the other person then cas to put it.

What does Lock Record point to? it's an unlocked markword.

This explains why hashcode is not lost because there are backup records.

Here lock reentry: as mentioned above, lock reentry, every time the lock is entered, a LR is added, which points to a null from the second LR.

When the lock exits, that is, when monitorexit (lock code block executes or throws an exception), LR-1, LR-1, LR-1 keep decreasing, one at a time.

10: heavyweight lock

Apply to OS for a lock, and after entering the kernel state, C++ created a new object monitor object, which is the pointer in the markword (java is an address or ID).

Heavyweight locks, all waiting in a queue, consume less CPU resources

Reentrant lock: the heavyweight is the record on an attribute of object moniter

When does the optional lock rise to heavyweight lock:

1. The number of selections is more than 10 or the number of threads is more than half of CPU. Before jdk1.6-XX:PreBlockSpin can adjust how many upgrades can be selected. 3. Adaptive Adapative Self Sping JVM is added after jdk1.6.

11:GC Recycling Mark

01: let's look at the third to last place.

0: no lock

1: prefer to lock the thread ID, the C++ implementation is used by the pointer

3. When synchronized is compiled into bytecode, there are two words monitorenter monitorexit.

When is the monitorexit, when the code is executed, or when an exception occurs? that's how synchronized automatically releases locks.

4. Why do you need a heavy lock with a spin lock?

(1) spin consumes CPU resources. If the lock time is long, or if there are many spin threads, CPU will be consumed in large quantities.

(2) the heavyweight lock has a waiting queue, and all those who cannot get the lock enter the waiting queue without consuming CPU resources.

5. Is the bias lock necessarily more efficient than the spin lock?

(1) not necessarily when you know that there must be multithreaded competition, the preferred lock will involve lock revocation, and spin lock will be better at this time.

(2) during the startup process of JVM, there will be a lot of thread competition, so the bias lock is not turned on by default and will be opened after a period of time.

(3)-XX:BiasedLockingStartupDelay = 0 defaults to 4 seconds

Thank you for your reading, the above is the content of "how to use synchronized", after the study of this article, I believe you have a deeper understanding of how to use synchronized, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

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.