【多线程学习笔记】sychronized关键字底层原理、sychronized与ReentrantLock的对比和使用实例

红太狼 2022-08-28 12:53 120阅读 0赞

### 文章目录 ###

*  sychronized释义
 *  synchronized关键字最主要的三种使用方式：
 *  synchronized底层原理：
 *   *  同步代码块：
     *  同步方法
     *  当前类的class对象作为锁
 *  Synchronized与Reentrantlock的区别
 *   *  关于可重入锁 可中断锁 公平锁和非公平锁的概念
     *  ReentrantLock是如何实现可重入性的？

# sychronized释义 #

synchronized关键字解决的是【多个线程之间访问资源的同步性】，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，**Java的线程是映射到操作系统的原生线程之上的**。  
如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的 synchronized 效率低的原因。庆幸的是在 Java 6之后 Java 官方对从 JVM 层面对synchronized 较大优化，所以现在的 synchronized 锁效率也优化得很不错了。  
JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。

# synchronized关键字最主要的三种使用方式： #

☛修饰实例方法: 作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁  
☛修饰静态方法: 也就是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管new了多少个对象，只有一份）。所以如果一个线程A调用一个实例对象的非静态 synchronized 方法，而线程B需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁。  
☛修饰代码块: 指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。

在使用同步synchronized（this）代码块时需要注意的是,**当一个线程访问object的一个synchronized（this）同步代码块时，其他线程对同一个object中所有其他synchronized（this）同步代码块的访问将被阻塞**，这说明synchronized使用的“对象监视器”个数是1。

public class ObjectService { 
        public void serviceMethodA() { 
            try { 
                synchronized (this) { 
                    System.out.println("A begin time=" + System.currentTimeMillis());
                    Thread.sleep(2000);
                    System.out.println("A end end=" + System.currentTimeMillis());
                }
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
        public void serviceMethodB() { 
            synchronized (this) { 
                System.out.println("B begin time=" + System.currentTimeMillis());
                System.out.println("B end end=" + System.currentTimeMillis());
            }
        }
    }
    
    public class ThreadA extends Thread{ 
        private ObjectService objectService;
        public ThreadA(ObjectService objectService){ 
            this.objectService = objectService;
        }
        @Override
        public void run(){ 
            super.run();
            objectService.serviceMethodA();
        }
    }
    class ThreadB extends Thread{ 
        private ObjectService objectService;
        public ThreadB(ObjectService objectService){ 
            this.objectService = objectService;
        }
        @Override
        public void run(){ 
            super.run();
            objectService.serviceMethodB();
        }
    }
    
    
    /** * @Author * @Description 运行类 * @Date 8.21 **/
    public class Run { 
        public static void main(String[] args) { 
            ObjectService objectService = new ObjectService();
            ThreadA threadA = new ThreadA(objectService);
            ThreadB threadB = new ThreadB(objectService);
            threadA.setName("a");
            threadB.setName("b");
            threadA.start();
            threadB.start();
        }
    }

输出：  
A begin time=1629769384466  
A end end=1629769386478  
B begin time=1629769386478  
B end end=1629769386478

# synchronized底层原理： #

**Synchronized 是非公平锁**。 Synchronized 在线程进入ContentionList 时，等待的线程会先尝试自旋获取锁，如果获取不到就进入ContentionList，这明显对于已经进入队列的线程是不公平的，还有一个不公平的事情就是自旋获取锁的线程还可能直接抢占OnDeck 线程的锁资源。

synchronized 是一个重量级操作，需要调用操作系统相关接口，性能是低效的，有可能给线程加锁消耗的时间比有用操作消耗的时间更多。

每个对象都有个monitor 对象，加锁就是在竞争monitor 对象，**代码块加锁是在前后分别加上monitorenter 和monitorexit 指令来实现的，方法加锁是通过一个标记位来判断的**

## 同步代码块： ##

public class SynchronizedDemo { 
    public void method() { 
    synchronized (this) { 
    System.out.println("synchronized 代码块");
    }
    }
    }

通过javap -c -s -v -l查看字节码文件：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbWFyY2ggb2YgVGltZQ_size_20_color_FFFFFF_t_70_g_se_x_16]  
synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。 当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因 ) 的持有权.当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

## 同步方法 ##

public class SynchronizedDemo2 { 
    public synchronized void method() { 
    System.out.println("synchronized 方法");
    }
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbWFyY2ggb2YgVGltZQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
用ACC\_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC\_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

例如：

方法一

public synchronized void method()
    { 
       // todo
    }

方法二

public void method()
    { 
       synchronized(this) { 
          // todo
       }
    }

写法一修饰的是一个方法，写法二修饰的是一个代码块，但写法一与写法二是等价的，都是锁定了整个方法时的内容。

## 当前类的class对象作为锁 ##

//this,当前实例对象锁
    synchronized(this){ 
    for(int j=0;j<1000000;j++){ 
    i++;
    }
    }
    //class对象锁
    synchronized(Demo5.class){ 
    for(int j=0;j<1000000;j++){ 
    i++;
    }
    }

**指定要给某个对象加锁**

/** * 银行账户类 */
    class Account { 
       String name;
       float amount;
     
       public Account(String name, float amount) { 
          this.name = name;
          this.amount = amount;
       }
       //存钱
       public  void deposit(float amt) { 
          amount += amt;
          try { 
             Thread.sleep(100);
          } catch (InterruptedException e) { 
             e.printStackTrace();
          }
       }
       //取钱
       public  void withdraw(float amt) { 
          amount -= amt;
          try { 
             Thread.sleep(100);
          } catch (InterruptedException e) { 
             e.printStackTrace();
          }
       }
     
       public float getBalance() { 
          return amount;
       }
    }
     
    /** * 账户操作类 */
    class AccountOperator implements Runnable{ 
       private Account account;
       public AccountOperator(Account account) { 
          this.account = account;
       }
     
       public void run() { 
          synchronized (account) { 
             account.deposit(500);
             account.withdraw(500);
             System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
          }
       }
    }
     
    public class Demo00{ 
        
        //public static final Object signal = new Object(); // 线程间通信变量
        //将account改为Demo00.signal也能实现线程同步
        public static void main(String args[]){ 
            Account account = new Account("zhang san", 10000.0f);
            AccountOperator accountOperator = new AccountOperator(account);
     
            final int THREAD_NUM = 5;
            Thread threads[] = new Thread[THREAD_NUM];
            for (int i = 0; i < THREAD_NUM; i ++) { 
               threads[i] = new Thread(accountOperator, "Thread" + i);
               threads[i].start();
            }
        }
    }

在AccountOperator 类中的run方法里，我们用synchronized 给account对象加了锁。这时，当一个线程访问account对象时，其他试图访问account对象的线程将会阻塞，直到该线程访问account对象结束。也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。

synchronized 的常见问题：一个静态成员函数和一个非静态成员函数，都加了synchronized关键字，分别被两个线程调用，它们是否互斥？很显然，因为是两把不同的锁，所以不会互斥。

**synchronized关键字不能继承。**  
虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。这两种方式的例子代码如下：

在子类方法中加上synchronized关键字

class Parent { 
       public synchronized void method() {  }
    }
    class Child extends Parent { 
       public synchronized void method() {  }
    }

在子类方法中调用父类的同步方法

class Parent { 
       public synchronized void method() {    }
    }
    class Child extends Parent { 
       public void method() {  super.method();   }
    }

1.  在定义接口方法时不能使用synchronized关键字。
2.  构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

# Synchronized与Reentrantlock的区别 #

其实，锁的实现原理基本是为了达到一个目的：让所有的线程都能看到某种标记。  
Synchronized通过在对象头中设置标记实现了这一目的，是一种JMM原生的锁实现方式，而 ReentrantLock以及所有的基于Lock接口的实现类，**都是通过用一个 volitile修饰的int型变量，并保证每个线程都能拥有对该it的可见性和原子修改，其本质是基于所谓的AQS框架**。

ReentrantLock 类实现了Lock ，它拥有与synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。（换句话说，当许多线程都想访问共享资源时，JVM可以花更少的时候来调度线程，把更多时间用在执行线程上。）

**synchronized是和if、else、for、while一样的关键字，ReentrantLock是类**，这是二者的本质区别。既然ReentrantLock是类，那么它就提供了比synchronized更多更灵活的特性，可以被继承、可以有方法、可以有各种各样的类变量，ReentrantLock比synchronized的扩展性体现在几点上：  
1、ReentrantLock可以对获取锁的等待时间进行设置，这样就避免了死锁  
2、ReentrantLock可以获取各种锁的信息  
3、ReentrantLock可以灵活地实现多路通知

## 关于可重入锁 可中断锁 公平锁和非公平锁的概念 ##

1.  可重入锁：可重入锁是指同一个线程可以多次获得同一把锁；ReentrantLock和关键字Synchronized都是可重入锁
2.  可中断锁：可中断锁时子线程在获取锁的过程中，是否可以相应线程中断操作。synchronized是不可中断的，ReentrantLock是可中断的
3.  公平锁和非公平锁：公平锁是指多个线程尝试获取同一把锁的时候，获取锁的顺序按照线程到达的后顺序获取，而不是随机插队的方式获取。synchronized是非公平锁，而ReentrantLock是两种都可以实现，不过默认是非公平锁

公平锁的一大特点是：它不会产生饥饿现象，只要你排队，最终还是可以等到资源的；synchronized关键字默认是有jvm内部实现控制的，是非公平锁。而ReentrantLock运行开发者自己设置锁的公平性。

公平锁看起来很不错，不过要实现公平锁，系统内部肯定需要维护一个有序队列，因此公平锁的实现成本比较高，性能相对于非公平锁来说相对低一些。因此，在默认情况下，锁是非公平的，如果没有特别要求，则不建议使用公平锁。

ReentrantLock的使用过程：

1.  创建锁：ReentrantLock lock = new ReentrantLock();
2.  获取锁：lock.lock()
3.  释放锁：lock.unlock();

上面代码需要注意lock.unlock()一定要放在finally中，否则，若程序出现了异常，锁没有释放，那么其他线程就再也没有机会获取这个锁了。

来验证一下ReentrantLock是可重入锁，实例代码：

public class Demo4 { 
    private static int num = 0;
    private static ReentrantLock lock = new ReentrantLock();
    private static void add() { 
    lock.lock();
    lock.lock();
    try { 
    num++;
    } finally { 
    lock.unlock();
    lock.unlock();
    }
    }
    public static class T extends Thread { 
    @Override
    public void run() { 
    for (int i = 0; i < 10000; i++) { 
    Demo4.add();
    }
    }
    }
        
        public static void main(String[] args) throws InterruptedException { 
    T t1 = new T();
    T t2 = new T();
    T t3 = new T();
    t1.start();
    t2.start();
    t3.start();
    t1.join();
    t2.join();
    t3.join();
    System.out.println(Demo4.num);
    }

上面代码中add()方法中，当一个线程进入的时候，会执行2次获取锁的操作，运行程序可以正常结束，并输出和期望值一样的30000，假如ReentrantLock是不可重入的锁，那么同一个线程第2次获取锁的时候由于前面的锁还未释放而导致死锁，程序是无法正常结束的。Reentrant Lock，和其名字一样，可重入锁。

关于获取锁的过程中被中断，注意几点:

1.  ReentrankLock中必须使用实例方法lockInterruptibly() 获取锁时，在线程调用interrupt()方法之后，才会引发InterruptedException 异常
2.  线程调用interrupt()之后，线程的中断标志会被置为true
3.  触发InterruptedException异常之后，线程的中断标志会被清空，即置为false
4.  所以当线程调用interrupt()引发InterruptedException异常，中断标志的变化是:false->true->->false
5.  实例方法tryLock()会尝试获取锁，会立即返回，返回值表示是否获取成功
6.  实例方法tryLock(long timeout, TimeUnit unit)会在指定的时间内尝试获取锁，指定的时间内是否能够获取锁，都会返回，返回值表示是否获取锁成功，该方法会响应线程的中断

与synchronized 会被JVM 自动解锁机制不同，ReentrantLock 加锁后需要手动进行解锁。为了避免程序出现异常而无法正常解锁的情况，使用ReentrantLock 必须在finally 控制块中进行解锁操作。

Reentrant 锁意味着什么呢？  
简单来说，它有一个与锁相关的获取计数器，如果拥有锁的某个线程再次得到锁，那么获取计数器就加1，然后锁需要被释放两次才能获得真正释放。这模仿了synchronized 的语义；如果线程进入由线程已经拥有的监控器保护的synchronized 块，就允许线程继续进行，当线程退出第二个（或者后续）  
synchronized块的时候，不释放锁，只有线程退出它进入的监控器保护的第一个synchronized 块时，才释放锁。

1.  ReentrantLock 通过方法lock()与unlock()来进行加锁与解锁操作，与synchronized 会被JVM 自动解锁机制不同，ReentrantLock 加锁后需要手动进行解锁。为了避免程序出现异常而无法正常解锁的情况，使用ReentrantLock 必须在finally 控制块中进行解锁操作。
2.  ReentrantLock 相比synchronized 的优势是可中断、公平锁、多个锁。这种情况下需要使用ReentrantLock。

public class MyService { 
    private Lock lock = new ReentrantLock();
    //Lock lock=new ReentrantLock(true);//公平锁
    //Lock lock=new ReentrantLock(false);//非公平锁
    private Condition condition=lock.newCondition();//创建Condition
    public void testMethod() { 
    try { 
    lock.lock();//lock 加锁
    //1：wait 方法等待：
    //System.out.println("开始wait");
    condition.await();
    //通过创建Condition 对象来使线程wait，必须先执行lock.lock 方法获得锁
    //:2：signal 方法唤醒
    condition.signal();//condition 对象的signal 方法可以唤醒wait 线程
    for (int i = 0; i < 5; i++) { 
    System.out.println("ThreadName=" + Thread.currentThread().getName()+ (" " + (i + 1)));
    }
    } catch (InterruptedException e) { 
    e.printStackTrace();
    }
    finally
    { 
    lock.unlock();
    }
    }
    }

1.  Condition 类的awiat 方法和Object 类的wait 方法等效
2.  Condition 类的signal 方法和Object 类的notify 方法等效
3.  Condition 类的signalAll 方法和Object 类的notifyAll 方法等效
4.  ReentrantLock 类可以唤醒指定条件的线程，而object 的唤醒是随机的

## ReentrantLock是如何实现可重入性的？ ##

ReentrantLock内部自定义了同步器Sync（Sync既实现了AQS,又实现了AOS,而AOS提供了一种互斥锁持有的方式），其实就是加锁的时候通过CAS算法，将线程对象放到一个双向链表中，每次获取锁的时候，看下当前维护的那个线程D和当前请求的线程ID是否一样，一样就可重入了。

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbWFyY2ggb2YgVGltZQ_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/80bc43d1d71a49ee83aa1bf3df5a79f7.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbWFyY2ggb2YgVGltZQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/bf338e0bd7954bda925f1180a191fc71.png