Java Synchronized锁的使用详解

Synchronized的用法

在多线程并发问题中，常用Synchronized锁解决问题。Synchronized锁通常用于同步示例方法，同步静态方法，同步代码块等。

同步示例方法

我们可能自己使用过在方法前加Synchronized锁修饰，在多线程并发同时调用同一个实例化对象时，如果这个方法加上了Synchronized锁，那么也是线程安全的。
举个栗子：

package Thread;

import java.util.stream.IntStream;

public class ThreadTest {
   private Long count=0L;
   public void incrementCount(){
       count++;
   }
   public Long execute() throws InterruptedException {
       Thread thread1=new Thread(()->{
           IntStream.range(0,1000).forEach((i)->incrementCount());//线程1循环1000次
       });
       Thread thread2=new Thread(()->{
           IntStream.range(0,1000).forEach((i)->incrementCount());//线程2循环1000次
       });
       thread1.start();//开启线程
       thread2.start();
       thread1.join();//等待线程1和线程2执行完毕
       thread2.join();
       return count;
   }

public static void main(String[] args) throws InterruptedException {
       ThreadTest threadTest=new ThreadTest();
       Long count = threadTest.execute();
       System.out.println(count);
   }
}

在上面的程序中，count变量为成员变量，在多线程同时使用时极大可能会发生错误，在前面也讲到过count++包含三个步骤：1.将变量count从主内存中加载到CPU的寄存器中；2.在CPU的寄存器中执行count++或++count的操作；3.将运算的count++的结果写入缓存或内存中。两个线程都会更新count的值到内存中，当其中一个线程再从内存中读取数据时，可能读到的成员变量会与当前的变量不一致，从而使得最终count的结果不为2000，因此会发生错误。

如何能解决这种错误？就是为incrementCount方法加锁：

public synchronized void incrementCount(){
       count++;
   }

这样就能保证所得到的count最终值为2000了。

同步静态方法

当一个类的某个静态方法加了synchronized锁时，就相当于给这个类的class对象加锁。所以无论创建多少个当前类的对象调用这个被synchronized锁修饰的静态方法时，都是线程安全的。

如上面的例子，修改如下：

package Thread;

import java.util.stream.IntStream;

public class ThreadTest {
   private static Long count=0L;
   public static synchronized void incrementCount(){
       count++;
   }
   public static Long execute() throws InterruptedException {
       Thread thread1=new Thread(()->{
           IntStream.range(0,1000).forEach((i)->incrementCount());
       });
       Thread thread2=new Thread(()->{
           IntStream.range(0,1000).forEach((i)->incrementCount());
       });
       thread1.start();
       thread2.start();
       thread1.join();
       thread2.join();
       return count;
   }

public static void main(String[] args) throws InterruptedException {
       ThreadTest threadTest=new ThreadTest();
       Long count = threadTest.execute();
       System.out.println(count);
   }
}

因此，当多个线程并发执行调用被synchronized锁修饰的静态方法时，这个静态方法是线程安全的。

同步代码块

前面提到加了synchronized锁的方法在多线程并发条件下是线程安全的，但是在执行业务逻辑过多的代码块时，可能会影响程序的执行效率。对于此时，可以把一个方法分成多个小的临界区。

举个栗子：

private Long count1=0L;
   private Long count2=0L;
   public synchronized void incrementCount(){
       count1++;
       count2++;
   }

在上面的代码中，count1和count2为两个不同的自增操作，因此对于count1和count2来说是两个不同的临界区资源。当一个线程进入incrementCount方法中时，会对整个方法进行加锁，在对count1进行自增操作时，也会占用count2的资源，相当于占用全部的资源。只有等到这个线程执行完count1++和count2++的操作时，释放锁时，其它线程才能拿到锁资源进入incrementCount方法。

但是这样会影响程序的性能。因为count1++和count2++为两个互不影响的两个临界区资源，当线程拿到锁，会占用两个资源，使得临界区资源进行闲置等待，因此可以优化代码，让synchronized锁修饰代码块。

修改后的代码：

private Long count1=0L;
   private Long count2=0L;
   public Object count1Lock=new Object();
   public Object count2Lock=new Object();
   public void incrementCount(){
       synchronized (count1Lock){
           count1++;
       }
       synchronized (count2Lock){
           count2++;
       }
   }

上面代码中，对count1和count2分别建立了对象锁count1Lock和count2Lock，而没有对incrementCount加锁，意为当一个线程进入incrementCount方法时，其他线程也能进入此方法，当线程1拿到count1Lock对象锁时，不影响线程2拿到count2Lock对象锁来对count2执行自增操作。

这样既提高了程序的执行效率，同时，由于临界区资源都加了锁，incrementCount方法也是线程安全的。

来源：https://blog.csdn.net/qq_53847859/article/details/127520451