java线程锁的基本使用详解

最新推荐文章于 2024-05-20 06:45:00 发布
最新推荐文章于 2024-05-20 06:45:00 发布
阅读量546 收藏 2
点赞数 1
分类专栏： 学习java之路 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39565641/article/details/132104175
版权
一…锁的基本使用方式
1. Lock锁说明

首先要说明的就是Lock，通过查看Lock的源码可知，Lock是一个接口。

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;

public interface Lock {
    
    void lock();

    void lockInterruptibly() throws InterruptedException;

    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();

    Condition newCondition();
}

下面来逐个讲述Lock接口中每个方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的。newCondition()这个方法暂且不在此讲述，会在后面的线程协作一文中讲述。

在Lock中声明了四个方法来获取锁，那么这四个方法有何区别呢？

​ 首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

​ 采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

​ tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

​ tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

Lock lock = ...;

if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){

     }finally{

         lock.unlock();   //释放锁
     }  
}else {
    //如果不能获取锁，则直接做其他事情
}

​

lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。

因此lockInterruptibly()一般的使用形式如下：

public void method() throws InterruptedException {
    lock.lockInterruptibly();
    try {   
     //.....
    }
    finally {
        lock.unlock();
    }   
}

注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程。

因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。

而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

2. ReentrantLock

ReentrantLock，意思是“可重入锁”，关于可重入锁的概念在下一节讲述。ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。下面通过一些实例看具体看一下如何使用ReentrantLock。

例子1，lock()的正确使用方法

public class Test {

	private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    
	private ReentrantLock lock = new ReentrantLock(); // 注意这个地方
    
	public static void main(String[] args) {
		final Test test = new Test();
		new Thread() {
			public void run() {
				test.insert(Thread.currentThread());
			};
		}.start();
		new Thread() {
			public void run() {
				test.insert(Thread.currentThread());
			};
		}.start();
	}

	public void insert(Thread thread) {
		lock.lock();
		try {
			System.out.println(thread.getName() + "得到了锁");
			for (int i = 0; i < 5; i++) {
				arrayList.add(i);
			}
		} catch (Exception e) {
			// TODO: handle exception
		} finally {
			System.out.println(thread.getName() + "释放了锁");
			lock.unlock();
		}
	}
}

例子2，tryLock()的使用方法

public void insert(Thread thread) {
    if (lock.tryLock()) {
        try {
            System.out.println(thread.getName() + "得到了锁");
            for (int i = 0; i < 5; i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            System.out.println(thread.getName() + "释放了锁");
            lock.unlock();
        }
    } else {
        System.out.println(thread.getName() + "获取锁失败");
    }
}

例子3，lockInterruptibly()响应中断的使用方法：

public class Test {

	private ReentrantLock lock = new ReentrantLock();

	public static void main(String[] args) {

		Test test = new Test();

		MyThread thread1 = new MyThread(test);

		MyThread thread2 = new MyThread(test);

		thread1.start();

		thread2.start();

		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		thread2.interrupt();
	}

	public void insert(Thread thread) throws InterruptedException {

		lock.lockInterruptibly(); // 注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
		try {
			System.out.println(thread.getName() + "得到了锁");
			long startTime = System.currentTimeMillis();
			for (;;) {
				if (System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
					break;
				// 插入数据
			}
        }catch（Exception e）{
            
        }finally {
			System.out.println(Thread.currentThread().getName() + "执行finally");
			lock.unlock();
			System.out.println(thread.getName() + "释放了锁");
		}
	}

}

class MyThread extends Thread {

	private Test test = null;

	public MyThread(Test test) {
		this.test = test;
	}

	@Override
	public void run() {
		try {
			test.insert(Thread.currentThread());
		} catch (InterruptedException e) {
			System.out.println(Thread.currentThread().getName() + "被中断");
		}
	}
}

运行之后，发现thread2能够被正确中断。

3.ReadWriteLock

ReadWriteLock也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock {

    Lock readLock();

    Lock writeLock();
}

一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的ReentrantReadWriteLock实现了ReadWriteLock接口。

4.ReentrantReadWriteLock

ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。

下面通过几个例子来看一下ReentrantReadWriteLock具体用法。

假如有多个线程要同时进行读操作的话，先看一下synchronized达到的效果：

public class Test {

	private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

	public static void main(String[] args) {
		final Test test = new Test();

		new Thread() {
			public void run() {
				test.get(Thread.currentThread());
			};
		}.start();

		new Thread() {
			public void run() {
				test.get(Thread.currentThread());
			};
		}.start();
	}

	public synchronized void get(Thread thread) {
		long start = System.currentTimeMillis();
		while (System.currentTimeMillis() - start <= 1) {
			System.out.println(thread.getName() + "正在进行读操作");
		}
		System.out.println(thread.getName() + "读操作完毕");
	}
}

这段程序的输出结果会是，直到thread1执行完读操作之后，才会打印thread2执行读操作的信息。

而改成用读写锁的话：

public class Test {

	private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

	public static void main(String[] args) {

		final Test test = new Test();

		new Thread() {
			public void run() {
				test.get(Thread.currentThread());
			};
		}.start();

		new Thread() {
			public void run() {
				test.get(Thread.currentThread());
			};
		}.start();
	}

	public void get(Thread thread) {
		rwl.readLock().lock();
		try {
			long start = System.currentTimeMillis();
			while (System.currentTimeMillis() - start <= 1) {
				System.out.println(thread.getName() + "正在进行读操作");
			}
			System.out.println(thread.getName() + "读操作完毕");
		} finally {
			rwl.readLock().unlock();
		}
	}
}

说明thread1和thread2在同时进行读操作，这样就大大提升了读操作的效率。

不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

5.CountDownLatch

CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，用来作为线程间的通信而不是互斥作用。

CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现，计数器初始值就是线程的数量。

当每个被计数的线程完成任务后，计数器值减一，当计数器的值为0时，表示所有线程都已经完成了任务，然后在CountDownLatch上等待的线程就可以恢复执行。

CountDownLatch(int count)：count为计数器的初始值（一般需要多少个线程执行，count就设为几）。

countDown(): 每调用一次计数器值-1，直到count被减为0，代表所有线程全部执行完毕。

getCount()：获取当前计数器的值。

await(): 等待计数器变为0，即等待所有异步线程执行完毕。

boolean await(long timeout, TimeUnit unit)： 此方法与await()区别：
1.此方法至多会等待指定的时间，超时后会自动唤醒，若 timeout 小于等于零，则不会等待
2.boolean 类型返回值：若计数器变为零了，则返回 true；若指定的等待时间过去了，则返回 false

CountDownLatch应用场景：

  1. 某个线程需要在其他n个线程执行完毕后再向下执行

  2. 多个线程并行执行同一个任务，提高响应速度

    CountDownLatch代码示例

/**
 * @author liuhuifang
 * @date 2022/5/26 11:31
 */
public class CountDownLaunchTest {

    public static void main(String[] args) throws InterruptedException {
        List list = new ArrayList();
        for(int i = 1; i<=100; i++){
            list.add(i);
        }
        Long start = System.currentTimeMillis();
        for(int i = 0; i<list.size(); i++){
            Thread.sleep(100);
        }
        System.out.println("=====同步执行：耗时"+(System.currentTimeMillis()-start)+"毫秒======");
        Long start1 = System.currentTimeMillis();
        CountDownLatch latch = new CountDownLatch(10);
        for(int i = 0; i<latch.getCount(); i++){
            new Thread(new Test(latch, i, list)).start();
        }
        latch.await();
        System.out.println("=====异步执行：耗时"+(System.currentTimeMillis()-start1)+"毫秒======");
    }

    static class Test implements Runnable{
        private CountDownLatch latch;
        private int i;
        private List list;
        Test(CountDownLatch latch, int i, List list){
            this.latch = latch;
            this.i = i;
            this.list = list;
        }

        @SneakyThrows
        @Override
        public void run() {
            for(int a = i*10; a<(i+1)*10; a++){
                // 执行任务逻辑
                Thread.sleep(100);
            }
            latch.countDown();
        }
    }
}
二、锁的相关概念介绍

在前面介绍了Lock的基本使用，这一节来介绍一下与锁相关的几个概念。

1.可重入锁

如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁，可重入性在我看来实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

class MyClass {
    public synchronized void method1() {
        method2();
    }
    public synchronized void method2() {

    }
}

上述代码中的两个方法method1和method2都用synchronized修饰了，假如某一时刻，线程A执行到了method1，此时线程A获取了这个对象的锁，而由于method2也是synchronized方法，假如synchronized不具备可重入性，此时线程A需要重新申请锁。但是这就会造成一个问题，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。

而由于synchronized和Lock都具备可重入性，所以不会发生上述现象。

2.可中断锁

可中断锁：顾名思义，就是可以相应中断的锁。

在Java中，synchronized就不是可中断锁，而Lock是可中断锁。

如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。

在前面演示lockInterruptibly()的用法时已经体现了Lock的可中断性。

3.公平锁

公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。

非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。

在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。

而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。

在ReentrantLock中定义了2个静态内部类，一个是NotFairSync，一个是FairSync，分别用来实现非公平锁和公平锁。

另外在ReentrantLock类中定义了很多方法，比如：

isFair() //判断锁是否是公平锁

isLocked() //判断锁是否被任何线程获取了

isHeldByCurrentThread() //判断锁是否被当前线程获取了

hasQueuedThreads() //判断是否有线程在等待该锁

在ReentrantReadWriteLock中也有类似的方法，同样也可以设置为公平锁和非公平锁。不过要记住，ReentrantReadWriteLock并未实现Lock接口，它实现的是ReadWriteLock接口。

4.读写锁

读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。

正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。

ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。

可以通过readLock()获取读锁，通过writeLock()获取写锁。

LJiaWang
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 锁的使用
KEEP CODING
03-13 800
悲观锁：总是假设最坏的情况，认为共享资源每次被访问的时候就会出现问题（比如共享数据被修改），所以每次在获取资源操作的时候都会上锁。 乐观锁：总是假设最好的情况，认为共享资源每次访问的时候不会出现问题，线程可以不停执行，无需加锁，只是在提交修改的时候去验证对应的资源是否被其他线程修改了。
java中的锁(基础篇)
jikeyeka的博客
08-14 988
java中基本锁 乐观锁 悲观锁 可重入锁 死锁 公平锁非公平锁 Synchronized关键字
掌握Java并发：读写锁与独占锁的运用技巧
最新发布
逆流的小鱼
05-20 1627
在锁的实现上，公平锁和非公平锁是两个常见的概念。所谓公平锁，是指在多个线程竞争锁的情况下，锁的获取按照线程请求的顺序来分配——即先来先得。而非公平锁则不保证这种顺序，允许某些线程插队，可能会导致其他等待时间较长的线程处于饥饿状态较长时间，但一般情况下会有更高的执行效率。重量级锁，也称为互斥锁（Mutex），是一种提供独占访问的锁。在Java中，当一个线程试图进入一个由其他线程持有的synchronized代码块或方法时，就会产生一个重量级锁。重量级锁在JVM内部依赖于操作系统的Mutex。
JavaSE进阶 多线程(7)--死锁、Lock锁
Sucker的博客
08-14 249
死锁 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有两个以上对象的锁时，就可能发生死锁问题 例子： package com.Sucker.thread; //死锁：多个线程互相抱着对方需要的资源，然后形成僵持 public class DeadLock { public static void main(String[] args) { Makeup g1 = new
JAVA三种线程锁
小冷在努力~
01-07 3145
内置锁：synchriozed，关键字，同步代码块，object.wait和object.notify/notifyall 显示锁：Lock，JUC包下的类，同步代码块，condition.await和condition.signal/signalall 原子类：Atomic，JUC包下的类，原理CAS，注意ABA问题 Lock接口方法有lock、unlock、trylock、newCondition try { lock.lock(); System.out.println( lock....
Java锁的基本用法
daijianzhou的专栏
05-18 2568
文章目录Java锁的基本用法synchronized和locksynchronized首先在没有加锁的情况下加锁的情况Lock首先在没有加锁的情况下加锁的情况下线程的通信synchronized 通过wait和notifyAll进行通信synchronized 需求唤醒问题使用Lock定向唤醒线程 Java锁的基本用法 synchronized和lock synchronized synchronized是方法锁，可自动加锁和释放锁，因为其是方法级锁，也就是说将锁定整个方法的内容，所以对于业务逻辑较为复杂的
Java多线程 ReentrantLock互斥锁详解
08-25
Java多线程ReentrantLock互斥锁详解 ReentrantLock是Java多线程编程中的一种锁机制，它可以实现线程之间的同步访问资源。ReentrantLock的主要特点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制...
java锁详解.pdf
12-31
Java 锁详解 Java 锁是 Java 并发编程中的一种基本机制，用于确保线程安全和避免竞争条件。Java 锁可以分为两大类：synchronized 锁和 ReentrantLock 锁。 一、Synchronized 锁 1. 锁的原理：synchronized 锁是...
java线程同步操作实例详解
08-27
Java线程同步操作实例详解 Java线程同步操作是指在多线程编程中，为了避免线程之间的数据不一致和混乱，采取的一种机制，以确保线程安全。Java提供了多种方式来实现线程同步，包括synchronized关键字、Lock接口、...
Java多线程编程中使用Condition类操作锁的方法详解
09-02
在Java多线程编程中，Condition类是Java并发包`java.util.concurrent.locks`中的一个核心组件，它提供了比传统`synchronized`关键字更细粒度的锁控制机制。Condition允许我们创建独立的等待集合，这使得线程可以更加...
详解Java同步—线程锁和条件对象
08-27
线程锁，通常指的是Java中的`synchronized`关键字以及`java.util.concurrent`包中的`ReentrantLock`类。`synchronized`关键字提供了隐式锁，它能够确保同一时间只有一个线程执行特定的代码块或方法。例如，以下代码...
多线程的使用与线程锁的两种实现
05-08
了解更多访问https://blog.csdn.net/qq_37651267/article/details/89978759
Java锁的正确使用
灵药的博客
09-22 646
使用JVM锁只对某个用户锁
聊聊JAVA 中 13 种锁的实现方式
LoveSummer
08-08 2万+
最近有很多小伙伴给我留言，分布式系统时代，线程并发，资源抢占，慢慢变得很重要。那么常见的锁都有哪些？
Java中的Lock详解
向上的"狼"的博客
04-28 2万+
简介 java.util.concurrent.locks.Lock 是一个类似于synchronized 块的线程同步机制。但是 Lock比 synchronized 块更加灵活。Lock是个接口，有个实现类是ReentrantLock。 Lock和syncronized的区别
java中锁的使用经验
weixin_38738049的博客
01-25 406
java 锁 锁竞争 面试
JAVA如何在线程中加锁（四种方法）
热门推荐
weixin_43907440的博客
04-22 2万+
JAVA多线程锁 线程的生命周期 ​ 总共六种状态，可归结为五种，线程的最终是死亡，阻塞不是最终状态，只是一个临时状态。只有调用了start方法，线程才进入就绪阶段。 //新生 ​ NEW, //运行​ RUNNABLE, //阻塞​ BLOCKED, //等待，死死地等​ WAITING, //超时等待​ TIMED_WAITING, //终止​ ...
java 线程lock,《Java 并发编程》ThreadLock详解
weixin_27015733的博客
03-14 298
前言在并发开发的过程中，我们都知道需要保证共享资源的的读写有序。加锁是我们比较常用的一种方式。ThreadLock则是从另外一个角度出发，每一个线程都独立资源，这样同样可以解决资源的问题。这样讲可能不是很好理解，下面我们通过案例来说明这个情况。案例我们在使用日期格式转换的时候，会出现日期转换出错，或者日期不是自己想要的结果。importjava.text.ParseException;import...
java基础(十一)操作系统中锁机制
xqhadoop的博客
03-17 1898
前言:前几天阿里电面被问到了关于jvm锁机制的底层原理,说实话当时只是简单的了解基础api,真正内部实现确实不懂。所以在查阅大量资源的情况下,简单记录下我学习这方面的资料。 一.操作系统级别的锁机制实现原理 我们知道jvm是属于运行在操作系统上的程序虚拟机。要想真正理解jvm是如何实现锁机制的,底层操作系统的锁机制是必须要了解的。 我们知道在多线程编程中，为了保证数据操作的一致性，操作系统引...
Java多线程编程详解
"这份资料详细介绍了Java多线程编程的相关知识，包括线程的创建、线程安全和锁机制，以及线程池的使用。" 在Java编程中，多线程技术是核心概念之一，它允许程序同时执行多个任务，提高了程序的效率和响应性。Java多...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值