Java多线程并发编程(互斥锁Reentrant Lock)

2024-09-30 20:10:29

Java 中的锁通常分为两种：

通过关键字 synchronized 获取的锁，我们称为同步锁，上一篇有介绍到：Java 多线程并发编程 Synchronized 关键字。
java.util.concurrent（JUC）包里的锁，如通过继承接口 Lock 而实现的 ReentrantLock（互斥锁），继承 ReadWriteLock 实现的 ReentrantReadWriteLock（读写锁）。
本篇主要介绍 ReentrantLock（互斥锁）。

ReentrantLock（互斥锁）

ReentrantLock 互斥锁，在同一时间只能被一个线程所占有，在被持有后并未释放之前，其他线程若想获得该锁只能等待或放弃。

ReentrantLock 互斥锁是可重入锁，即某一线程可多次获得该锁。

公平锁 and 非公平锁

public ReentrantLock() {
    sync = new NonfairSync();
  }

  public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
  }

由 ReentrantLock 的构造函数可见，在实例化 ReentrantLock 的时候我们可以选择实例化一个公平锁或非公平锁，而默认会构造一个非公平锁。

公平锁与非公平锁区别在于竞争锁时的有序与否。公平锁可确保有序性（FIFO 队列），非公平锁不能确保有序性（即使也有 FIFO 队列）。

然而，公平是要付出代价的，公平锁比非公平锁要耗性能，所以在非必须确保公平的条件下，一般使用非公平锁可提高吞吐率。所以 ReentrantLock 默认的构造函数也是“不公平”的。

一般使用

DEMO1：

public class Test {

  private static class Counter {

    private ReentrantLock mReentrantLock = new ReentrantLock();

    public void count() {
      mReentrantLock.lock();
      try {
        for (int i = 0; i < 6; i++) {
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        }
      } finally {
	      // 必须在 finally 释放锁
        mReentrantLock.unlock();
      }
    }
  }

  private static class MyThread extends Thread {

    private Counter mCounter;

    public MyThread(Counter counter) {
      mCounter = counter;
    }

    @Override
    public void run() {
      super.run();
      mCounter.count();
    }
  }

  public static void main(String[] var0) {
    Counter counter = new Counter();
    // 注：myThread1 和 myThread2 是调用同一个对象 counter
    MyThread myThread1 = new MyThread(counter);
    MyThread myThread2 = new MyThread(counter);
    myThread1.start();
    myThread2.start();
  }
}

DEMO1 输出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5
Thread-1， i = 0
Thread-1， i = 1
Thread-1， i = 2
Thread-1， i = 3
Thread-1， i = 4
Thread-1， i = 5

DEMO1 仅使用了 ReentrantLock 的 lock 和 unlock 来提现一般锁的特性，确保线程的有序执行。此种场景 synchronized 也适用。

锁的作用域

DEMO2：

public class Test {

  private static class Counter {

    private ReentrantLock mReentrantLock = new ReentrantLock();

    public void count() {
      for (int i = 0; i < 6; i++) {
        mReentrantLock.lock();
        // 模拟耗时，突出线程是否阻塞
        try{
          Thread.sleep(100);
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        } catch (InterruptedException e) {
          e.printStackTrace();
        } finally {
	        // 必须在 finally 释放锁
          mReentrantLock.unlock();
        }
      }
    }

    public void doOtherThing(){
      for (int i = 0; i < 6; i++) {
        // 模拟耗时，突出线程是否阻塞
        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
      }
    }
  }

  public static void main(String[] var0) {
    final Counter counter = new Counter();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.count();
      }
    }).start();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.doOtherThing();
      }
    }).start();
  }
}

DEMO2 输出：

Thread-0， i = 0
Thread-1 doOtherThing， i = 0
Thread-0， i = 1
Thread-1 doOtherThing， i = 1
Thread-0， i = 2
Thread-1 doOtherThing， i = 2
Thread-0， i = 3
Thread-1 doOtherThing， i = 3
Thread-0， i = 4
Thread-1 doOtherThing， i = 4
Thread-0， i = 5
Thread-1 doOtherThing， i = 5

DEMO3:

public class Test {

  private static class Counter {

    private ReentrantLock mReentrantLock = new ReentrantLock();

    public void count() {
      for (int i = 0; i < 6; i++) {
        mReentrantLock.lock();
        // 模拟耗时，突出线程是否阻塞
        try{
          Thread.sleep(100);
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        } catch (InterruptedException e) {
          e.printStackTrace();
        } finally {
          // 必须在 finally 释放锁
          mReentrantLock.unlock();
        }
      }
    }

    public void doOtherThing(){
      mReentrantLock.lock();
      try{
        for (int i = 0; i < 6; i++) {
          // 模拟耗时，突出线程是否阻塞
          try {
            Thread.sleep(100);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
        }
      }finally {
        mReentrantLock.unlock();
      }

    }
  }

  public static void main(String[] var0) {
    final Counter counter = new Counter();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.count();
      }
    }).start();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.doOtherThing();
      }
    }).start();
  }
}

DEMO3 输出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5
Thread-1 doOtherThing， i = 0
Thread-1 doOtherThing， i = 1
Thread-1 doOtherThing， i = 2
Thread-1 doOtherThing， i = 3
Thread-1 doOtherThing， i = 4
Thread-1 doOtherThing， i = 5

结合 DEMO2 和 DEMO3 输出可见，锁的作用域在于 mReentrantLock，因为所来自于 mReentrantLock。

可终止等待

DEMO4：

public class Test {

  static final int TIMEOUT = 300;

  private static class Counter {

    private ReentrantLock mReentrantLock = new ReentrantLock();

    public void count() {
      try{
        //lock() 不可中断
        mReentrantLock.lock();
        // 模拟耗时，突出线程是否阻塞
        for (int i = 0; i < 6; i++) {
          long startTime = System.currentTimeMillis();
          while (true) {
            if (System.currentTimeMillis() - startTime > 100)
              break;
          }
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        }
      } finally {
        // 必须在 finally 释放锁
        mReentrantLock.unlock();
      }
    }

    public void doOtherThing(){
      try{
        //lockInterruptibly() 可中断，若线程没有中断，则获取锁
        mReentrantLock.lockInterruptibly();
        for (int i = 0; i < 6; i++) {
          // 模拟耗时，突出线程是否阻塞
          long startTime = System.currentTimeMillis();
          while (true) {
            if (System.currentTimeMillis() - startTime > 100)
              break;
          }
          System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
        }
      } catch (InterruptedException e) {
        System.out.println(Thread.currentThread().getName() + " 中断 ");
      }finally {
        // 若当前线程持有锁，则释放
        if(mReentrantLock.isHeldByCurrentThread()){
          mReentrantLock.unlock();
        }
      }
    }
  }

  public static void main(String[] var0) {
    final Counter counter = new Counter();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.count();
      }
    }).start();
    Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        counter.doOtherThing();
      }
    });
    thread2.start();
    long start = System.currentTimeMillis();
    while (true){
      if (System.currentTimeMillis() - start > TIMEOUT) {
        // 若线程还在运行，尝试中断
        if(thread2.isAlive()){
          System.out.println(" 不等了，尝试中断 ");
          thread2.interrupt();
        }
        break;
      }
    }
  }
}

DEMO4 输出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
不等了，尝试中断
Thread-1 中断
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5

线程 thread2 等待 300ms 后 timeout，中断等待成功。

若把 TIMEOUT 改成 3000ms，输出结果：（正常运行）

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5
Thread-1 doOtherThing， i = 0
Thread-1 doOtherThing， i = 1
Thread-1 doOtherThing， i = 2
Thread-1 doOtherThing， i = 3
Thread-1 doOtherThing， i = 4
Thread-1 doOtherThing， i = 5

定时锁

DEMO5：

public class Test {

  static final int TIMEOUT = 3000;

  private static class Counter {

    private ReentrantLock mReentrantLock = new ReentrantLock();

    public void count() {
      try{
        //lock() 不可中断
        mReentrantLock.lock();
        // 模拟耗时，突出线程是否阻塞
        for (int i = 0; i < 6; i++) {
          long startTime = System.currentTimeMillis();
          while (true) {
            if (System.currentTimeMillis() - startTime > 100)
              break;
          }
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        }
      } finally {
        // 必须在 finally 释放锁
        mReentrantLock.unlock();
      }
    }

    public void doOtherThing(){
      try{
        //tryLock(long timeout, TimeUnit unit) 尝试获得锁
        boolean isLock = mReentrantLock.tryLock(300, TimeUnit.MILLISECONDS);
        System.out.println(Thread.currentThread().getName() + " isLock:" + isLock);
        if(isLock){
          for (int i = 0; i < 6; i++) {
            // 模拟耗时，突出线程是否阻塞
            long startTime = System.currentTimeMillis();
            while (true) {
              if (System.currentTimeMillis() - startTime > 100)
                break;
            }
            System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
          }
        }else{
          System.out.println(Thread.currentThread().getName() + " timeout");
        }
      } catch (InterruptedException e) {
        System.out.println(Thread.currentThread().getName() + " 中断 ");
      }finally {
        // 若当前线程持有锁，则释放
        if(mReentrantLock.isHeldByCurrentThread()){
          mReentrantLock.unlock();
        }
      }
    }
  }

  public static void main(String[] var0) {
    final Counter counter = new Counter();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.count();
      }
    }).start();
    Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        counter.doOtherThing();
      }
    });
    thread2.start();
  }
}

DEMO5 输出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-1 isLock:false
Thread-1 timeout
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5

tryLock() 尝试获得锁，tryLock(long timeout, TimeUnit unit) 在给定的 timeout 时间内尝试获得锁，若超时，则不带锁往下走，所以必须加以判断。

ReentrantLock or synchronized

ReentrantLock 、synchronized 之间如何选择？

ReentrantLock 在性能上比 synchronized 更胜一筹。

ReentrantLock 需格外小心，因为需要显式释放锁，lock() 后记得 unlock()，而且必须在 finally 里面，否则容易造成死锁。
synchronized 隐式自动释放锁，使用方便。

ReentrantLock 扩展性好，可中断锁，定时锁，自由控制。
synchronized 一但进入阻塞等待，则无法中断等待。

详谈锁和监视器之间的区别_Java并发

在面试中你可能遇到过这样的问题:锁(lock)和监视器(monitor)有什么区别? 嗯,要回答这个问题,你必须深入理解Java的多线程底层是如何工作的. 简短的答案是,锁为实现监视器提供必要的支持.详细答案如下. 锁(lock) 逻辑上锁是对象内存堆中头部的一部分数据.JVM中的每个对象都有一个锁(或互斥锁),任何程序都可以使用它来协调对对象的多线程访问.如果任何线程想要访问该对象的实例变量,那么线程必须拥有该对象的锁(在锁内存区域设置一些标志).所有其他的线程试图访问该对象的变量必须等到拥有
java高并发锁的3种实现示例代码

初级技巧 - 乐观锁乐观锁适合这样的场景:读不会冲突,写会冲突.同时读的频率远大于写. 以下面的代码为例,悲观锁的实现: public Object get(Object key) { synchronized(map) { if(map.get(key) == null) { // set some values } return map.get(key); } } 乐观锁的实现: public Object get(Object key) { Object val = null; if((
java 并发中的原子性与可视性实例详解

java 并发中的原子性与可视性实例详解并发其实是一种解耦合的策略,它帮助我们把做什么(目标)和什么时候做(时机)分开.这样做可以明显改进应用程序的吞吐量(获得更多的CPU调度时间)和结构(程序有多个部分在协同工作).做过java Web开发的人都知道,Java Web中的Servlet程序在Servlet容器的支持下采用单实例多线程的工作模式,Servlet容器为你处理了并发问题. 原子性原子是世界上的最小单位,具有不可分割性.比如 a=0:(a非long和double类型) 这个操作是不
java ThreadPoolExecutor 并发调用实例详解

java ThreadPoolExecutor 并发调用实例详解概述通常为了提供任务的处理速度,会使用一些并发模型,ThreadPoolExecutor中的invokeAll便是一种. 代码 package test.current; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.concurrent.Callable; import java.util
Java并发之嵌套管程锁死详解

·嵌套管程死锁是如何发生的 ·具体的嵌套管程死锁的例子 ·嵌套管程死锁 vs 死锁嵌套管程锁死类似于死锁, 下面是一个嵌套管程锁死的场景: Thread 1 synchronizes on A Thread 1 synchronizes on B (while synchronized on A) Thread 1 decides to wait for a signal from another thread before continuing Thread 1 calls B.wait()
java并发编程_线程池的使用方法(详解)

一.任务和执行策略之间的隐性耦合 Executor可以将任务的提交和任务的执行策略解耦只有任务是同类型的且执行时间差别不大,才能发挥最大性能,否则,如将一些耗时长的任务和耗时短的任务放在一个线程池,除非线程池很大,否则会造成死锁等问题 1.线程饥饿死锁类似于:将两个任务提交给一个单线程池,且两个任务之间相互依赖,一个任务等待另一个任务,则会发生死锁:表现为池不够定义:某个任务必须等待池中其他任务的运行结果,有可能发生饥饿死锁 2.线程池大小注意:线程池的大小还受其他的限制,如其他资源池:
Java多线程并发编程(互斥锁Reentrant Lock)

Java 中的锁通常分为两种: 通过关键字 synchronized 获取的锁,我们称为同步锁,上一篇有介绍到:Java 多线程并发编程 Synchronized 关键字. java.util.concurrent(JUC)包里的锁,如通过继承接口 Lock 而实现的 ReentrantLock(互斥锁),继承 ReadWriteLock 实现的 ReentrantReadWriteLock(读写锁). 本篇主要介绍 ReentrantLock(互斥锁). ReentrantLock(互斥锁)
Java多线程并发编程和锁原理解析

这篇文章主要介绍了Java多线程并发编程和锁原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下一.前言最近项目遇到多线程并发的情景(并发抢单&恢复库存并行),代码在正常情况下运行没有什么问题,在高并发压测下会出现:库存超发/总库存与sku库存对不上等各种问题. 在运用了限流/加锁等方案后,问题得到解决. 加锁方案见下文. 二.乐观锁 & 悲观锁 1.乐观锁顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁
Java 多线程并发编程_动力节点Java学院整理

一.多线程 1.操作系统有两个容易混淆的概念,进程和线程. 进程:一个计算机程序的运行实例,包含了需要执行的指令:有自己的独立地址空间,包含程序内容和数据:不同进程的地址空间是互相隔离的:进程拥有各种资源和状态信息,包括打开的文件.子进程和信号处理. 线程:表示程序的执行流程,是CPU调度执行的基本单位:线程有自己的程序计数器.寄存器.堆栈和帧.同一进程中的线程共用相同的地址空间,同时共享进进程锁拥有的内存和其他资源. 2.Java标准库提供了进程和线程相关的API,进程主要包括表示进程的jav
Java多线程并发编程 Volatile关键字

volatile 关键字是一个神秘的关键字,也许在 J2EE 上的 JAVA 程序员会了解多一点,但在 Android 上的 JAVA 程序员大多不了解这个关键字.只要稍了解不当就好容易导致一些并发上的错误发生,例如好多人把 volatile 理解成变量的锁.(并不是) volatile 的特性: 具备可见性保证不同线程对被 volatile 修饰的变量的可见性. 有一被 volatile 修饰的变量 i,在一个线程中修改了此变量 i,对于其他线程来说 i 的修改是立即可见的. 如: vola
Go语言并发编程互斥锁详情

目录 1.互斥锁Mutex 1.1 Mutex介绍 1.2 Mutex使用实例 2.读写锁RWMutex 2.1 RWMutex介绍 2.2 RWMutex使用实例 1.互斥锁Mutex 1.1 Mutex介绍 Go 语言的同步工具主要由 sync 包提供,互斥锁 (Mutex) 与读写锁 (RWMutex) 就是sync 包中的方法. 互斥锁可以用来保护一个临界区,保证同一时刻只有一个 goroutine 处于该临界区内.主要包括锁定(Lock方法)和解锁(Unlock方法)两个操作,首先对进
Java 多线程并发编程提高数据处理效率的详细过程

工作场景中遇到这样一个需求:根据主机的 IP 地址联动更新其他模型的相关信息.需求很简单,只涉及一般的数据库联动查询以及更新操作,然而在编码实现过程中发现,由于主机的数量很多,导致循环遍历查询.更新时花费很长的时间,调用一次接口大概需要 30-40 min 时间才能完成操作. 因此,为了有效缩短接口方法的执行时间,便考虑使用多线程并发编程方法,利用多核处理器并行执行的能力,通过异步处理数据的方式,便可以大大缩短执行时间,提高执行效率. 这里使用可重用固定线程数的线程池 FixedThreadPo
Java多线程并发编程 Synchronized关键字

synchronized 关键字解析同步锁依赖于对象,每个对象都有一个同步锁. 现有一成员变量 Test,当线程 A 调用 Test 的 synchronized 方法,线程 A 获得 Test 的同步锁,同时,线程 B 也去调用 Test 的 synchronized 方法,此时线程 B 无法获得 Test 的同步锁,必须等待线程 A 释放 Test 的同步锁才能获得从而执行对应方法的代码. 综上,正确使用 synchronized 关键字可确保原子性. synchronized 关键字的特
深入探究Java多线程并发编程的要点

关键字synchronized synchronized关键可以修饰函数.函数内语句.无论它加上方法还是对象上,它取得的锁都是对象,而不是把一段代码或是函数当作锁. 1,当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一段时间只能有一个线程得到执行,而另一个线程只有等当前线程执行完以后才能执行这块代码. 2,当一个线程访问object中的一个synchronized(this)同步代码块时,其它线程仍可以访问这个object中是其它非synchr
Java多线程并发编程并发三大要素

一.原子性原子,一个不可再被分割的颗粒.原子性,指的是一个或多个不能再被分割的操作. int i = 1; // 原子操作 i++; // 非原子操作,从主内存读取 i 到线程工作内存,进行 +1,再把 i 写到朱内存. 虽然读取和写入都是原子操作,但合起来就不属于原子操作,我们又叫这种为"复合操作". 我们可以用synchronized 或 Lock 来把这个复合操作"变成"原子操作. 例子: private synchronized void increase
对python多线程中互斥锁Threading.Lock的简单应用详解

一.线程共享进程资源每个线程互相独立,相互之间没有任何关系,但是在同一个进程中的资源,线程是共享的,如果不进行资源的合理分配,对数据造成破坏,使得线程运行的结果不可预期.这种现象称为"线程不安全". 实例如下: #-*- coding: utf-8 -*- import threading import time def test_xc(): f = open("test.txt","a") f.write("test_dxc&quo

Java多线程并发编程(互斥锁Reentrant Lock)

相关推荐

随机推荐