Sample code sharing of Java synchronization lock (synchronized)

This article mainly introduces the detailed explanation and examples of Java synchronization lock (synchronized). Friends who need it can refer to

Java synchronization lock (synchronized) detailed explanation and examples

The time slice allocated by the CPU to each thread in Java is random, and many threads in Java share a resource. For example, when selling train tickets, the train ticket is certain, but the window for selling train tickets is It's everywhere. Each window is equivalent to a thread. So many threads share the resource of all train tickets. If two threads use this resource at the same time at one point in time, the train tickets they take out will be the same (same seat number), which will cause trouble for passengers. For example, the following program:

package com.pakage.ThreadAndRunnable; 
 
public class Runnable_demo implements Runnable{ 
  private int ticket=10; 
  public Runnable_demo(){    
  } 
  @Override 
  public void run() { 
    for(int i=0;i<20;i++){ 
        if(this.ticket>0){ 
          //休眠1s秒中，为了使效果更明显，否则可能出不了效果 
          try { 
            Thread.sleep(1000); 
          } catch (Exception e) { 
            e.printStackTrace(); 
          } 
          System.out.println(Thread.currentThread().getName()+"号窗口卖出："+this.ticket--+"号票"); 
        } 
       
    } 
  } 
   
   public static void main(String args[]){ 
     Runnable_demo demo=new Runnable_demo(); 
     //基于火车票创建三个窗口 
     new Thread(demo,"a").start(); 
     new Thread(demo,"b").start(); 
     new Thread(demo,"c").start(); 
   } 
   
}

Program running result:

We can see that both window C and window B have sold 10 Ticket number, and tickets numbered 0 and -1 were sold at windows a and b respectively. The reason for this situation is 1. When the c thread and the b thread have ticket=10, after the c thread takes out the ticket No. 10, the ticket has not yet come and is reduced by 1, and the b thread takes out the ticket. At this time, the ticket is still equal to 10. ; 2. When ticket=1, thread c takes out ticket No. 1. Before the ticket comes, it is decremented by 1. Threads a and b enter the ifjudgment statement successively. At this time, the ticket is decremented by 1. , then when threads a and b get tickets, they get tickets No. 0 and -1.

How to change the above situation? We can do this: When a thread wants to use the resource of train tickets, we give it a lock and wait for it to do the thing. After that, give the lock to another thread that wants to use this resource. In this way, the above situation will not occur. To implement this lock function, you need to use the synchronized keyword.

synchronized keyword has two uses1. Put it before the method name to form a synchronized method; 2. Put it before the block to form a synchronized block.

1. Use the synchronization method to change the above example to:

package com.pakage.ThreadAndRunnable; 
 
public class Runnable_demo implements Runnable{ 
  private int ticket=10; 
  public Runnable_demo(){    
  } 
  @Override 
  public void run() { 
    for(int i=0;i<20;i++){ 
        if(this.ticket>0){ 
          //休眠1s秒中，为了使效果更明显，否则可能出不了效果 
          try { 
            Thread.sleep(1000); 
          } catch (Exception e) { 
            e.printStackTrace(); 
          } 
          this.sale(); 
        } 
       
    } 
  } 
   
  public synchronized void sale(){ 
    if(this.ticket>0){ 
      System.out.println(Thread.currentThread().getName()+"号窗口卖出："+this.ticket--+"号票"); 
    } 
  } 
   
   public static void main(String args[]){ 
     Runnable_demo demo=new Runnable_demo(); 
     //基于火车票创建三个窗口 
     new Thread(demo,"a").start(); 
     new Thread(demo,"b").start(); 
     new Thread(demo,"c").start(); 
   } 
   
}

The output result of the program is:

2. Use synchronization block to modify the above example:

package com.pakage.ThreadAndRunnable; 
 
public class Runnable_demo implements Runnable{ 
  private int ticket=10; 
  public Runnable_demo(){    
  } 
  @Override 
  public void run() { 
    for(int i=0;i<20;i++){ 
      <span style="color:#ff0000">synchronized</span>(this){ 
        if(this.ticket>0){ 
          //休眠1s秒中，为了使效果更明显，否则可能出不了效果 
          try { 
            Thread.sleep(1000); 
          } catch (Exception e) { 
            e.printStackTrace(); 
          } 
          System.out.println(Thread.currentThread().getName()+"号窗口卖出："+this.ticket--+"号票"); 
        } 
      } 
       
    } 
  } 
   
   public static void main(String args[]){ 
     Runnable_demo demo=new Runnable_demo(); 
     //基于火车票创建三个窗口 
     new Thread(demo,"a").start(); 
     new Thread(demo,"b").start(); 
     new Thread(demo,"c").start(); 
   } 
   
}

The output result of the program:

The above is the detailed content of Sample code sharing of Java synchronization lock (synchronized). For more information, please follow other related articles on the PHP Chinese website!