[Java] Java synchronized keyword explanation

The Java language keyword, which can be used to lock objects and methods or blocks of code, when it locks a method or a block of code, at most one thread at a time executes the code. When two concurrent threads access the same object in the same lock synchronization code block, only one thread can be executed within a single time. The other thread must wait for the current thread to finish executing the block before it can execute the code block. However, when a thread accesses one of the lock code blocks of object, another thread can still access the non-locking code block in the object.

One, synchronized synchronization method

1.synchronized synchronization method, for object lock

 Public classExceptionreleaselock { Public  synchronized  voidtestlockexception () {if(Thread.CurrentThread (). GetName (). Equals ("A") {System.out.println ("Thread Name:" +thread.currentthread (). GetName () + "Start run time:" +System.currenttimemillis ());  for(inti=0;i<200;i++){                 while(i>20) {System.out.println ("I=" +i); Integer.parseint ("ABCD"); }            }        }Else{System.out.println ("B Thread Run Time:" +System.currenttimemillis ()); }    }}

2.synchronized Lock re-entry

When a thread requests an object lock held by another thread, the thread blocks, and when the thread requests a lock on an object held by itself, if the lock is a re-entry lock, the request succeeds or is blocked.

Let's take a look at synchronized, which has a built-in locking mechanism that enforces atomicity, is a re-entry lock, so when using synchronized, when a thread requests an object lock and then requests the object lock again, the object lock can be obtained again. This means that when a synchronized method/block is called inside the other synchronized methods/blocks of this class, it is always possible to get the lock. Otherwise, it will cause a deadlock.

/*** Created by Administrator on 2015/12/30 0030. * Lock re-entry mechanism*/ Public classLocksyn { Public synchronized  voidA () {System.out.println ("A ()");    b (); }     Public synchronized  voidB () {System.out.println ("B ()");    C (); }     Public synchronized  voidC () {System.out.println ("C ()"); }}

 Public class Testlocksyn {    publicstatic  void  main (string[] args) {          New Locksyn (). A ();    }}

Output Result:

A () b () C ()

When there is an inheritance relationship, subclasses can invoke the synchronization method of the parent class through a reentrant lock.

 public  class   Animal { public  void   Eat () {System.out.println (         "Animal Eat Foods" );  try   {Thread.Sleep ( 3000);  catch   (Interruptedexception e) {e.        Printstacktrace (); }    }}

 Public class extends   Animal {   synchronizedpublic    void  eatfish () {       System.out.println ("Cat eatfish ...");        Try {           Thread.Sleep (+);             This . Eat ();        Catch (interruptedexception e) {           e.printstacktrace ();    }}}

Test:

 Public class Testanimal {    publicstatic  void  main (string[] args) {        New Cat ();        Cat.eatfish ();    }}

Output:

Cat Eatfish ... Animal Eat foods

Let's take a look at how the entry lock implements Reentrant, which is implemented by associating a thread holder and a counter for each lock, indicating that the lock is not held by any thread when the counter is 0, and that any thread may acquire the lock and invoke the appropriate method; When a thread request succeeds, the JVM will note the lock's holding threads , and the counter is set to 1, when another thread requests the lock, it must wait, and the thread holding the lock, if requested again, can get the lock again, the counter will increment, and when the thread exits the synchronization code block, the counter decrements, and if the counter is 0, the lock is freed.

3. Exception occurred, lock automatic release

 Public classExceptionreleaselock { Public  synchronized  voidtestlockexception () {if(Thread.CurrentThread (). GetName (). Equals ("A") {System.out.println ("Thread Name:" +thread.currentthread (). GetName () + "Start run time:" +System.currenttimemillis ());  for(inti=0;i<200;i++){                 while(i>20) {System.out.println ("I=" +i); Integer.parseint ("ABCD"); }            }        }Else{System.out.println ("B Thread Run Time:" +System.currenttimemillis ()); }    }}

 public  class     ExceptionReleaseThread1 extends   Thread {  private   Exceptionreleaselock    Exceptionreleaselock;  public   ExceptionReleaseThread1 ( Exceptionreleaselock lock) { this . Exceptionreleaselock=lock; } @Override  public  void   run () {exceptionreleaselock.testlockexception (); }}

 Public class extends   Thread {    private  exceptionreleaselock exceptionreleaselock;      Public ExceptionReleaseThread2 (Exceptionreleaselock lock) {        this.exceptionreleaselock=  lock;    }    @Override    publicvoid  run () {       exceptionreleaselock.testlockexception () ;    }}

Test:

/*** Created by Administrator on 2015/12/30 0030. * * After an exception occurs, the lock is automatically released*/ Public classTestexceptionrelease { Public Static voidMain (string[] args) {Exceptionreleaselock lock=NewExceptionreleaselock (); ExceptionReleaseThread1 a=NewExceptionReleaseThread1 (lock); ExceptionReleaseThread2 b=NewExceptionReleaseThread2 (lock); A.setname (A); B.setname (B);        A.start ();    B.start (); }}

Output Result:

A thread has released a lock after an exception has occurred, and thread B executes normally.

4. Synchronization does not have inheritance.

 Public class extends   Animal {      @Override    public  void  eat () {        System.out.println ("nosynchronized ....");}    }

You need to add synchronized synchronization before the method.

Second, synchronized synchronous statement block

[Java] Java synchronized keywords