Java多线程--12 Lock、ReentrantLock等相关锁


1、Lock

        Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构,可以具有差别很大的属性,可以支持多个相关的 Condition 对象。

        锁是控制多个线程对共享资源进行访问的工具。通常,锁提供了对共享资源的独占访问。一次只能有一个线程获得锁,对共享资源的所有访问都需要首先获得锁。不过,某些锁可能允许对共享资源并发访问,如 ReadWriteLock 的读取锁。

        synchronized 方法或语句的使用提供了对与每个对象相关的隐式监视器锁的访问,但却强制所有锁获取和释放均要出现在一个块结构中:当获取了多个锁时,它们必须以相反的顺序释放,且必须在与所有锁被获取时相同的词法范围内释放所有锁。虽然 synchronized 方法和语句的范围机制使得使用监视器锁编程方便了很多,而且还帮助避免了很多涉及到锁的常见编程错误,但有时也需要以更为灵活的方式使用锁。例如,某些遍历并发访问的数据结果的算法要求使用 "hand-over-hand" 或 "chain locking":获取节点 A 的锁,然后再获取节点 B 的锁,然后释放 A 并获取 C,然后释放 B 并获取 D,依此类推。Lock 接口的实现允许锁在不同的作用范围内获取和释放,并允许以任何顺序获取和释放多个锁,从而支持使用这种技术。

        随着灵活性的增加,也带来了更多的责任。不使用块结构锁就失去了使用 synchronized 方法和语句时会出现的锁自动释放功能。在大多数情况下,应该使用以下语句: 

Lock lock = new XxxLock() ; 

lock.lock();

try {

// access the resource protected by this lock

} finally {

lock.unlock();

}

        锁定和取消锁定出现在不同作用范围中时,必须谨慎地确保保持锁定时所执行的所有代码用 try-finally 或 try-catch 加以保护,以确保在必要时释放锁。 



2、ReentrantLock

        ReentrantLock(可重入锁),也叫做递归锁,当一个线程请求得到一个对象锁后再次请求此对象锁,可以再次得到该对象锁。

        ReentrantLock 构造函数中提供了两种锁:创建公平锁和非公平锁(默认)。当参数设置为 true 时,在多个线程的争用下,这些锁倾向于将访问权授予等待时间最长的线程。否则此锁将无法保证任何特定访问顺序。(在公平的锁上,线程按照请求的顺序获取锁,FIFO 先进先出顺序,但在非公平锁上,则允许插队)

        与采用默认设置(使用不公平锁)相比,使用公平锁的程序在许多线程访问时表现为很低的总体吞吐量(即速度很慢,常常极其慢),但是在获得锁和保证锁分配的均衡性时差异较小。不过要注意的是,公平锁不能保证线程调度的公平性。因此,使用公平锁的众多线程中的一员可能获得多倍的成功机会,这种情况发生在其他活动线程没有被处理并且目前并未持有锁时。还要注意的是,未定时的 tryLock 方法并没有使用公平设置。因为即使其他线程正在等待,只要该锁是可用的,此方法就可以获得成功。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo implements Runnable {

	private ReentrantLock lock;

	public ReentrantLockDemo(ReentrantLock lock) {
		this.lock = lock;
	}

	@Override
	public void run() {
		try {
			System.out.println("当前线程:" + Thread.currentThread().getName() + "准备获取锁..");
			lock.lock(); // 获取锁
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method..");
			Thread.sleep(1000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method..");
			Thread.sleep(1000);
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();// 释放锁
		}
	}
	public static void main(String[] args) {
		ReentrantLock lock = new ReentrantLock();

		ExecutorService threadPools = Executors.newFixedThreadPool(2);
		// 第一个线程需要释放锁后,第二个线程才能执行,否则永久处于线程阻塞状态。
		threadPools.execute(new ReentrantLockDemo(lock));
		threadPools.execute(new ReentrantLockDemo(lock));

		threadPools.shutdown();
	}
}


当前线程:pool-1-thread-2准备获取锁..

当前线程:pool-1-thread-1准备获取锁..   

当前线程:pool-1-thread-2进入method..

当前线程:pool-1-thread-2退出method..

当前线程:pool-1-thread-1进入method..

当前线程:pool-1-thread-1退出method.. 



2.1、可重入锁

        “可重入”是指任意线程在获取到锁之后,再次获取该锁而不会被该锁所阻塞。关联一个线程持有者+计数器,重入意味着锁操作的颗粒度为“线程”。

        1、 线程再次获取锁:锁需要识别获取锁的现场是否为当前占据锁的线程,如果是,则再次成功获取;

        2、锁的最终释放:线程重复n次获取锁,随后在第n次释放该锁后,其他线程能够获取该锁。要求对锁对于获取进行次数的自增,计数器对当前锁被重复获取的次数进行统计,当锁被释放的时候,计数器自减,当计数器值为0时,表示锁成功释放。

import java.util.concurrent.locks.ReentrantLock;
/**
 * lock.getHoldCount()方法:只能在当前调用线程内部使用,不能再其他线程中使用
 * 那么我可以在m1方法里去调用m2方法,同时m1方法和m2方法都持有lock锁定即可 测试结果holdCount数递增
 *
 */
public class LockCountDemo {

	//重入锁
	private ReentrantLock lock = new ReentrantLock();
	
	public void m1(){
		try {
			lock.lock();
			System.out.println("进入m1方法,holdCount数为:" + lock.getHoldCount());
			//调用m2方法
			m2();
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
		System.out.println("m1方法 end,holdCount数为:" + lock.getHoldCount());
	}
	
	public void m2(){
		try {
			lock.lock();
			System.out.println("进入m2方法,holdCount数为:" + lock.getHoldCount());
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
		System.out.println("m2方法 end,holdCount数为:" + lock.getHoldCount());
	}
	
	public static void main(String[] args) {
		LockCountDemo thc = new LockCountDemo();
		thc.m1();
	}
}

进入m1方法,holdCount数为:1

进入m2方法,holdCount数为:2

m2方法 end,holdCount数为:1

m1方法 end,holdCount数为:0



3、ReentrantReadWriteLock

        可重入读写锁。

ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

// 获取读取锁,是多个线程共享锁,允许对共享资源并发访问

ReadLock readLock = rwLock.readLock(); 

// 获去写入锁,是一个互斥锁,一个时刻只能有一个线程获取该锁。

WriteLock writeLock = rwLock.writeLock();


读取锁和写入锁是互斥的,同一时刻只能读或只能写

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class UseReentrantReadWriteLock {
	
	//  
	private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
	// 多个线程可以同时获取read锁  ,  public Condition newCondition() 因为 ReadLocks 不支持条件,所以将抛出 UnsupportedOperationException。
	private ReadLock readLock = rwLock.readLock();
	// 只能有1个线程同时获取write锁
	private WriteLock writeLock = rwLock.writeLock();

	public void read() {
		try {
			/**
			 *  public void lock()
			 * 	获取读取锁。如果另一个线程没有保持写入锁,则获取读取锁并立即返回,
			 * 	(即 如果另一个线程保持读取锁,当前线程仍可以获得读取锁)
			 * 	如果另一个线程保持该写入锁,出于线程调度目的,将禁用当前线程,并且在获取读取锁之前,该线程将一直处于休眠状态。
			 */
			readLock.lock();  


			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...read");
			Thread.sleep(3000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...read");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			readLock.unlock();
		}
	}

	public void write() {
		try {
			writeLock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...write");
			Thread.sleep(3000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...write");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			writeLock.unlock();
		}
	}

	public static void main(String[] args) {

		final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();

		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.read();
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.read();
			}
		}, "t2");
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.write();
			}
		}, "t3");
		Thread t4 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.write();
			}
		}, "t4");

		t1.start();
		t2.start();

		t3.start();
		t4.start();
	}
}

t1和t2先启动:

当前线程:t1进入...read

当前线程:t2进入...read

当前线程:t1退出...read

当前线程:t2退出...read

当前线程:t3进入...write

当前线程:t3退出...write

当前线程:t4进入...write

当前线程:t4退出...write

t3和t4先启动:

当前线程:t4进入...write

当前线程:t4退出...write

当前线程:t3进入...write

当前线程:t3退出...write

当前线程:t1进入...read

当前线程:t2进入...read

当前线程:t1退出...read

当前线程:t2退出...read

读的时候不能写,写的时候不能读;只能一个线程同时写,但是可以多个线程一起读。



多线程 lock ReentrantLock

2020.11.18 00:22

https://www.meihaocloud.com.com/318.html , 欢迎转载,请在文章页标出原文连接 !


Copyright © 2020 千夕网 联系站长

粤公网安备 44030302001408号 粤ICP备19099833号-1