Java多线程之锁的基本使用

最新推荐文章于 2024-08-30 08:56:18 发布
最新推荐文章于 2024-08-30 08:56:18 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： # java多线程 文章标签： java 后端 重入锁 读写锁 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38515961/article/details/120884256
版权

文章目录

一、重入锁

1、重入锁简介

重入锁是用于线程间协同工作的一种机制，可以完全替代synchronized关键字，在java中为java.util.concurrent.locks包下的ReentrantLock类。之所以叫重入锁，是因为该锁可以反复获取多次，在释放锁的时候也必须释放相同次数。
与synchronized相比，重入锁必须在程序中指出何时加锁，何时释放锁，因此对程序的逻辑控制灵活性要远远好于synchronized。

public class ReentrantLockTest implements Runnable{
  public static ReentrantLock lock = new ReentrantLock();
  public static int i = 0;
  @Override
  public void run(){
    for(int j=0;j<10000000;j++){
      // 获取锁，只有获取到了才会执行后续代码
      lock.lock();
      try{
        i++;
      }finally{
        // 释放锁
        lock.unlock();
      }
    }
  }
  public static void main(String[] args)throws InterruptedException{
    ReentrantLockTest lockTest = new ReentrantLockTest();
    Thread t1 = new Thread(lockTest);
    Thread t2 = new Thread(lockTest);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println(i);
  }
}

2、中断响应

使用synchronized时，一个线程要么获得锁继续执行，要么就会一直等待。而使用重入锁，则可以根据需要取消对锁的请求，也可以有效避免死锁。

public class IntRunable implements Runnable{
  public static ReentrantLock lock1 = new ReentrantLock();
  public static ReentrantLock lock2 = new ReentrantLock();
  int lock;
  public IntRunable(int lock){
    this.lock = lock;
  }
  @Override
  public void run(){
    try{
      if(lock == 1){
        // 获取锁lock1并设置为可响应中断的
        lock1.lockInterruptibly();
        try{
          Thread.sleep(500);
        } catch(InterruptedException e){
          e.printStackTrace();
        }  
        // 获取锁lock2并设置为可响应中断的    
        lock2.lockInterruptibly();
      } else {
        // 获取锁lock2并设置为可响应中断的 
        lock2.lockInterruptibly();
        try{
          Thread.sleep(500);
        } catch(InterruptedException e){
            e.printStackTrace();
        } 
        // 获取锁lock1并设置为可响应中断的 
        lock1.lockInterruptibly();
      }
    } catch(InterruptedException e){
          e.printStackTrace();
    }finally{
      if(lock1.isHeldByCurrentThread()){
        // 如果被中断了，就释放锁
        lock1.unlock();
      } 
      if(lock2.isHeldByCurrentThread()){
        lock2.unlock();
      }  
      System.out.println(Thread.currentThread().getId()+":线程退出");
    }
  }
  public static void main(String[] args)throws InterruptedException{
    IntRunable intRunableA = new IntRunable(1);
    IntRunable intRunableB = new IntRunable(2); 
    Thread tA = new Thread(intRunableA);
    Thread tB = new Thread(intRunableB);  
    tA.start();
    tB.start();
    Thread.sleep(1000);
    // 中断tB，打破tA、tB之间的死锁
    tB.interrupt();
  }
}

线程tA和tB启动后，tA先占用lock1，休眠0.5秒后再去尝试占用lock2，,tB则先抢占了lock2，休眠0.5秒后再去尝试占用lock1，因此两者之间就会形成互相等待的死锁。但由于主线程中对tB线程进行中断，故tB会放弃对lock1的申请，同时释放已获得lock2。tA线程就可以顺利得到lock2而继续执行下去了。

3、限时等待

除了等待外部通知外，避免死锁的另一个方法就是限时等待。也就是说给线程获取锁的时候加个时间限制，当超过这个时间后，线程仍未获取到锁，就放弃。重入锁的tryLock() 方法可进行一次限时的等待。tryLock()方法接收两个参数，一个等待时长，一个时间单位。ReentrantLock.tryLock()方法也可以不带参数直接运行。在这种情况下，当前线程会尝试获得锁，如果锁并未被其他线程占用，则申请锁会成功，并立即返回true。如果锁被其他线程占用，则当前线程不会进行等待，而是立即返回false。

public class LimitTimeRunnable implements Runnable{
  public static ReentrantLock lock = new ReentrantLock();
  @Override
  public void run(){
    try{
      // 尝试获取锁，5秒内没获取到就放弃
      if(lock.tryLock(5, TimeUnit.SECONDS){
        Thread.sleep(6000);
      }else{
        System.out.println(Thread.currentThread().getName() + "获取锁失败");
      }
    }catch(InterruptedException e){
      e.printStackTrace();
    }finally{
      if(lock.isHeldByCurrentThread()){
        lock.unlock();
      }
    }
  }
  public static void main(String[] args){
    LimitTimeRunnable ltRunnable = new LimitTimeRunnable();
    Thread t1 = new Thread(ltRunnable, "t1");
    Thread t2 = new Thread(ltRunnable, "t2");
    t1.start();
    t2.start();
  }
}

执行结果：
在这里插入图片描述
在本例中，两个线程会同时尝试去获取同一把锁，并且获取到后sleep6秒，所以未获取到锁的线程在等待5秒后就会自动放弃，从而获取失败。

4、公平锁

在大多数情况下，锁的获取都是非公平的，也就是说并不是按线程的先来后到给线程分配锁，系统只是会从这个锁的等待队列中随机挑选一个，后申请锁的线程可能会先获取到锁，并且更倾向于将锁分配给已经持有锁的线程。而公平的锁会按照时间的先后顺序，保证先到先得，因此公平锁的一大特点是它不会产生饥饿现象。
synchronized关键字产生的锁就是非公平的，而重入锁允许对其公平性进行设置。ReentrantLock有这样一个构造函数：

public ReentrantLock(boolean fair);

当参数fair为true时，就表示将重入锁设置为公平的。公平锁虽保障了公平，但也由此需要维护一个有序队列，实现成本比较高，性能相对也非常低下。所以默认情况下，锁是非公平的。

5、重入锁实现原理

在重入锁的实现中，主要包含三个要素：

  • 使用CAS（Compare And Swap，比较交换）来存储当前锁的状态，判断锁是否已经被别的线程持有；
  • 所有申请锁的线程在没有获取到锁时，会进入等待队列进行等待，直到有线程释放锁后，系统就从等待队列中选择一个线程；
  • 使用阻塞原语park()和unpark()，用来挂起和恢复线程，没有得到锁的线程将会被挂起。

二、Condition

Condition是与重入锁相关联的，通过Lock接口的newCondition()方法可以生成一个与当前重入锁相关联的COndition实例。Condition对象可以在某一个时刻通过其await()方法使线程等待或通过signal()方法通知其他线程继续执行，与Object.wait()和Object.notify()类似。具体来说：

  • await() 方法会使当前线程等待，同时释放当前锁，直到其他线程中使用了signal()或signalAll()方法时，才可能重新获取锁并继续执行；
  • awaitUninterruptibly() 方法与await()方法基本相同，但是不会在等待过程中响应中断；
  • signal() 方法用于唤醒一个在等待中的线程，signalAll() 方法则用于唤醒所有等待中的线程，不会释放锁，需要手动释放。
public class ConditionRunnable implements Runnable{
  public static ReentrantLock lock = new ReentrantLock();
  public static Condition condition = lock.newCondition();
  @Override
  public void run(){
    try{
      lock.lock();
      // 使当前线程等待
      condition.await();
      System.out.println("线程被唤醒，继续执行");
    }catch(InterruptedException e){
      e.printStackTrace();
    }finally{
      lock.unlock();
    }
  }
  public static void main(String[] args)throws InterruptedException{
    ConditionRunnable r = new ConditionRunnable();
    Thread t1 = new Thread(r);
    t1.start();
    Thread.sleep(2000);
    lock.lock();
    // 唤醒线程
    condition.signal();
    lock.unlock();
  }
}

与Object.wait()和notify()方法一样，当线程使用Condition.await()和signal()时，线程需持有相关的重入锁。

三、信号量Semaphore

无论是内部锁synchronized还是重入锁ReentrantLock，一次都只允许一个线程访问一个资源，而信号量可以指定多个线程同时访问某一个资源。

public Semaphore(int permits)
public Semaphore(int permits,boolean fair)

其中permits参数用于指定一次有多少个线程可以访问资源，fair参数指定锁是否是公平的。Semaphore的常用方法有：

// 尝试获取一个准入的许可，若无法获取，则一直等待
public void acquire()
// 与acquire()类似，但不响应中断
public void acquireUninterruptibly()
// 尝试获取一个许可，如果成功返回true，失败false，不会进行等待
public boolean tryAcquire()
// 在指定时间内尝试获取一个许可
public boolean tryAcquire(long timout, TimeUnit unit)
// 释放一个许可
public void release()

下面举例演示Semaphore的使用：

public class SemaphoreRunnable implements Runnable{
  // 每次允许5个线程同时访问资源执行
  final Semaphore semp = new Semaphore(5);
  @Override
  public void run(){
    try{
      // 获取执行许可
      semp.acquire();
      // 模拟耗时操作
      Thread.sleep(2000);
      System.out.println(Thread.currentThread().getId() + "线程执行完毕");
      // 释放许可
      semp.release();
    }catch(InterruptedException e){
      e.printStackTrace();
    }
  } 
  public static void main(String[] args){
    // 创建含有20个线程的线程池
    ExecutorService exe = Executors.newFixedThreadPool(20);
    final SemaphoreRunnable r = new SemaphoreRunnable();
    for(int i=0;i<20;i++){
      exe.submit(r);
    }
  }
}

执行结果：
在这里插入图片描述
可以看到，每一次输出是5个线程的执行结果。

四、读写锁ReadWriteLock

读写锁可以通过将读操作和写操作分离，减少锁竞争，进而有效的提高系统性能。因为如果使用重入锁或者内部锁，不管是读还是写操作，都需要先等待获取锁，但读操作并不会破坏数据的完整性，这种等待就显得没有意义。
总的来说，使用读写锁可以只对写操作进行加锁，而使读操作真正的并行执行。

public class ReadWriteLockExample{
  // 实例化一个重入锁，与读写锁进行对比
  private static Lock lock = new ReentrantLock();
  // 实例化一个读写锁
  private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  // 获取读锁
  private static Lock readLock = readWriteLock.readLock();
  // 获取写锁
  private static Lock writeLock = readWriteLock.writeLock();
  // 模拟的临界资源
  private int value;

  // 读操作
  public Object handleRead(Lock lock) throws InterruptedException{
    try{
      lock.lock();
      System.out.println("读操作：" + value);
      Thread.sleep(1000);
      return value;
    }finally{
      lock.unlock();
    }    
  }
  // 写操作
  public void handleWrite(Lock lock,int index) throws InterruptedException{
    try{
      lock.lock();
      System.out.println("写操作：" + index);
      Thread.sleep(1000);
      value = index;
    }finally{
      lock.unlock();
    }
  }
  public static void main(String[] args){
    final ReadWriteLockExample example = new ReadWriteLockExample();
    Runnable readRunnable = new Runnable(){
      @Override
      public void run(){
        try{
          // 通过在此处切换具体的锁，可以发现读写锁的执行时间会比重入锁短得多
          example.handleRead(readLock);
          // 或者 example.handleRead(lock);
        }catch(InterruptedException e){
          e.printStackTrace();
        }
      }
    }；
    Runnable writeRunnable = new Runnable(){
      @Override
      public void run(){
        try{
          example.handleWrite(writeLock,new Random().nextInt());
          // 或者 example.handleWrite(lock,new Random().nextInt());
        }catch(InterruptedException e){
          e.printStackTrace();
        }
      }
    }；  
    // 模拟18个读线程
    for(int i=0;i<18;i++){
      new Thread(readRunnable).start();
    }
    // 模拟2个写线程
    for(int i=18;i<20;i++){
      new Thread(writeRunnable).start();
    } 
  }
}

五、CountDownLatch

Count Down在英文中意为倒计数，Latch为阀门的意思，CountDownLatch可以让一个线程等待，直到给定的倒计数结束，再开始执行。在创建CountDownLatch对象时，必需传递一个整数，这个整数就是计数个数。

public class CountDownLatchRunnable implements Runnable{
  static final CountDownLatch latch = new CountDownLatch(10);
  static final CountDownLatchRunnable r = new CountDownLatchRunnable();
  @Override
  public void run(){
    try{
      Thread.sleep(new Random().nextInt(10)*1000);
      System.out.println(Thread.currentThread().getId() +"号线程任务完成"); 
      // 完成任务，使倒计数减一
      latch.countDown();
    }catch(InterruptedException e){
      e.printStackTrace();
    }
  }
  public static void main(String[] args)throws InterruptedException{
    ExecutorService exec = Executors.newFixedThreadPool(10);
    for(int i=0;i<10;i++){
      exec.submit(r);
    }
    // 使主线程等到倒计数倒计完毕后才能再继续执行
    latch.await();
    System.out.println("所有准备任务已完成，继续运行主线程");
    exec.shutdown();
  }
}

执行结果：
在这里插入图片描述

六、CyclicBarrier

CyclicBarrier中文意为循环栅栏，和CountDownLatch类似，也可以实现线程间的计数等待，但它的功能比CountDownLatch更加复杂强大。比如，假设我们将CyclicBarrier计数器设置为10，那么凑齐第一批10个线程后，计数器就会归零，然后接着凑齐下一批10个线程，这就是循环栅栏内在的含义。
CyclicBarrier可以接收一个参数作为barrierAction。所谓barrierAction就是当计数器一次计数完成后，系统会执行的动作。如我们现在对苹果进行装箱操作，每箱苹果6个，等有6个苹果送来后进行打包封装：

public class CyclicBarrierExample{
  public static class Apple implements Runnable{
    private int appleNo;
    private final CyclicBarrier cyclic;
    
    Apple(CyclicBarrier cyclic, int appleNo){
      this.cyclic = cyclic;
      this.appleNo = appleNo;
    }
  
    @Override
    public void run(){
      try{
        // await()方法会使当前线程阻塞，直到cyclic计数器计数完毕
        // 也就是说要求达到指定线程数时
        cyclic.await();
        putApple();
      }catch(InterruptedException  | BrokenBarrierException e){
        e.printStackTrace();
      } 
    }
    void putApple(){
      try{
        // 模拟放入苹果的操作耗时
        Thread.sleep(Math.abs(new Random().nextInt()%10000));
      }catch(InterruptedException e){
        e.printStackTrace();
      }
      System.out.println("放入" + appleNo +"号苹果");
    }
  }
  public static class PackageApple implements Runnable{
    int N;
    public PackageApple(int N){
      this.N = N;
    }
    @Override
    public void run(){
        System.out.println(N + "个苹果已全部送来，开始封装打包"); 
    }
  }
  public static void main(String[] args){
    final int N = 6;
    Thread[] allApple = new Thread[N];
    CyclicBarrier cyclic = new CyclicBarrier(N, new PackageApple(N));
    for(int i=0;i<N;i++){
       allApple[i] = new Thread(new Apple(cyclic,i));
       allApple[i].start();
     }
   }
 }

在这里插入图片描述

die_job
关注
专栏目录
【java高级】多线程---Lock锁的使用
v1xiaolin的博客
11-17 726
目录 一：Lock锁 三：synchronized与Lock的对比 四：常见面试题： 五：优先使用顺序 一：Lock锁 从JDK5.0开始，java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步，同步锁使用Lock对象充当。 ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现多线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁 二：Lock代码演示： class Windo.
java多线程之锁的应用
weixin_43747389的博客
06-11 1437
锁 锁应用于java多线程中的同步机制，我们知道线程安全的问题大部分是由于多个线程并发的访问共享变量或共享数据。于是我们想到将并发访问变为串行访问，既一次只能有一个线程访问共享数据。这就是锁的思想 如果你学过操作系统的多线程同步机制的话，相信你会对这部分有更好的理解。在操作系统中，多线程的同步是通过p,v原语，既waite(),signal()来解决线程同步问题，在访问临界区之前，所谓临界区就是p,v原语中间的代码,我们首先要对线程进行资源的申请操作p，访问结束后我们使用v归还资源。 java多线程中的锁的
多线程篇（基本认识 - 锁机制 - 乐观锁 & 悲观锁）（持续更新迭代）
最新发布
wlcass zhengge blog
08-30 1128
具体的解决思路是，A 和 B 同时将猪肉脯（id = 1 下面都说是 id = 1）的数据查出来，然后 A 先。买，A 将id = 1 和 version = 0 作为条件进行数据更新，即将数量减一，并且将版本号加一。我们经常使用的数据库是 mysql，mysql 中最常用的引擎是 Innodb，Innodb 默认使用的是行。2、事务 A 进行购买更新数据，然后再查询更新后的数据。其更新到表中时，会将之前取出的版本 v1 与数据中最新的版本 v2 相对比，如果 v1 = v2 ，那么。
Java多线程中锁的应用
weixin_34009794的博客
06-09 434
其实Java多线程中，锁只是一个很抽象的概念。锁是为了实现互斥和同步而设的。“锁”打个比方，获取锁可认为是“获取做某个事情的权限”，而“释放锁”可以认为是把做某件事情的权限交给别人了。也可以这样认为，“锁”锁住的是某个事物。获取锁指的是获得解开这个锁的钥匙，可以对这个事情进行操作，而释放锁是把这条钥匙给别人，或者放回某个钥匙柜子里，等别人...
线程 java中的几种锁_浅谈多线程中的锁的几种用法总结(必看)
weixin_39923137的博客
02-13 88
一、ReentrantLockpackage com.ietree.basicskill.mutilthread.lock;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/*** Created by Administrator on 2017/5/17.*/public...
Java多线程--锁使用
qq_43457781的博客
12-28 592
线程使用
java 多线程-锁详解及示例代码
09-01
Java 多线程编程中，锁机制是保证并发安全的关键技术。本文主要讲解了Java中锁的基本概念、使用方式以及示例代码，旨在帮助开发者...通过阅读本文和尝试相关示例代码，开发者可以深入理解Java多线程中锁的使用和原理。
Java多线程中Lock锁的使用总结
08-18
Java多线程中Lock锁的使用总结 Java多线程中Lock锁的使用总结主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 知识点1: Java多线程中的...
java基本教程之线程让步 java多线程教程
09-04
Java线程让步是多线程编程中一个重要的概念，主要体现在`Thread`类的`yield()`方法上。本文将详细讲解`yield()`方法的作用、示例以及与`wait()`方法的比较。 1. `yield()`介绍 `yield()`方法是Java中用于线程让步的...
java多线程加锁以及Condition类的使用实例解析
08-25
Java 多线程加锁以及 Condition 类的使用实例解析 摘要：本篇文章主要介绍了 Java 多线程加锁机制和 Condition 类的使用实例解析，通过示例代码详细介绍了多线程加锁和 Condition 类的使用方法，对大家的学习或者...
java基本教程之线程休眠 java多线程教程
09-04
`sleep()`方法是Java多线程中控制线程执行节奏的重要手段，它可以用于避免线程过度抢占CPU资源，或者实现简单的定时任务。与`wait()`相比，`sleep()`不会释放锁，适用于那些需要在特定时间后恢复执行的场景，而`wait...
java多线程_类锁的使用
weixin_30613343的博客
08-13 60
/* 类锁,类只有一个，所以锁是类级别的，只有一个. */ public class ThreadTest17 { public static void main(String[] args) throws Exception{ Thread t1 = new Thread(new Processor()); ...
Java多线程锁的使用简单总结
weixin_43548835的博客
08-12 98
主要列举ReentrantLock，ReentrantReadWriteLock以及相关API
java多线程——锁
m0_58479800的博客
06-25 295
前言 本篇主要内容: 线程安全的分类 线程同步的实现方式 锁优化 线程安全分类 线程安全并非是一个非真既假的二元世界，如果按照线程安全的“安全程度”来排序的话，java中可以分为以下几类 不可变。对数据类型修饰为final类型的，就可以保证其实不可变的（reference 对象除外，final对象属性不保证，只保证内存地址）。不可变的对象一定是线程安全，比如String类，它是一个典型的不可变对象，当调用它的subString（）、replace()和concat（）的方法都不会影响它原来的值，只
Java多线程专题-Lock锁的使用
一名coder
06-04 496
在 jdk1.5 之后，并发包中新增了 Lock 接口(以及相关实现类)用来实现锁功能，Lock 接口提供了与 synchronized 关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。 Lock写法 Lock lock = new ReentrantLock(); lock.lock(); try{ //可能会出现线程安全的操作 }finally{ //一定在finally中释放...
Java多线程中锁
Gorden的博客
08-15 419
锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等 ) 。  对象锁：在java中每个对象都有一个唯一的锁，对象锁用于对象实例方法或者一个对象实例上面的。 类锁：是用于一个类静态方法或者class对象的，一个类的实例对象可以有多个，但是只有一个class对象。 同步机制synchronized：synchronize...
java中锁的使用经验
weixin_38738049的博客
01-25 421
java 锁 锁竞争 面试
转载：总结java中使用多线程锁的使用 、实用
echo
12-06 459
线程锁的使用 本文内容 何时该使用线程锁. 线程锁的写法. 以线程锁的例子来理解线程的调度。 使用线程锁的场合 程序中经常采用多线程处理，这可以充分利用系统资源，缩短程序响应时间，改善用户体验；如果程序中只使用单线程，那么程序的速度和响应无疑会大打折扣。 但是，程序采用了多线程后，你就必须认真考虑线程调度的问题，如果调度不当，要么造成程序出错，要么造成
Java多线程学习（锁的使用 ）（三）
itman_cx的博客
05-02 324
Java线程中锁的使用 一、锁的作用 首先提出一个问题，如果两个线程A、B，同时去操作一个资源，比如C是一个20块钱的优惠吗，A、B在不知道的情况同时去使用，那么会出现什么问题？？ A使用了19，B使用了18，这样数据的完整性就不存在了，导致资源数据不同步，这就需要引出锁的概念，让A、B两个可以保证同时去操作C时还可以保证数据的安全性与完整性。所以让A先去操作、将读写操作完释放锁，然后让B继续操...
Java多线程深度解析：ReentrantLock互斥锁实战
"Java多线程ReentrantLock互斥锁详解" 在Java多线程编程中，ReentrantLock（可重入锁）是JDK提供的一个高级锁机制，它弥补了synchronized关键字的一些不足，提供了更丰富的锁操作。ReentrantLock在Java并发包`java....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值