java并发包中的Lock

目录

一、Lock接口：

概述：

Lock与synchronized的区别

Condition：

二、Lock接口的实现：

2.1可重入锁ReentrantLock

重入：

原理：

支持获取锁时的公平性和非公平性选择：

2.2可重入读写锁ReentrantReadWriteLock

概念：

源码：

原理：

读写状态的设计：

优点：

三、java中常用的并发工具

---

一、Lock接口：

概述：

• Lock接口的实现是通过聚合了一个同步器的子类来完成线程访问控制的。

Lock与synchronized的区别

• Lock显示地获取和释放锁：
  • void lock(); // 获取锁。
  • void unlock(); // 释放锁。
• 可以非阻塞的获取锁：
  • boolean tryLock(); // 调用该方法后立刻返回，如果能获取到锁则返回true，否则返回false;
• 可以中断地获取锁：
  • void lockInterruptibly() throws InterruptedException; // 在锁的获取过程中，如果获取锁的线程被中断，则抛出中断异常并返回。
• 可以超时地获取锁：
  • boolean tryLock(long time, TimeUnit unit) throws InterruptedException; // 在time时间内，获取到锁返回true，如果获取锁的线程被中断则返回false；超出time时间，返回false。

Condition：

结构：

• 每个Condition对象都包含着一个等待队列，该队列是Condition对象实现等待/通知功能的关键。
• 等待队列是一个FIFO的队列，在队列中的每个节点都包含了一个线程引用，该线程就是在Condition对象上等待的线程。
• 如果一个线程调用了Condition.await()方法，那么该线程将会释放锁，并且构造成节点加入等待队列并进入等待状态。
• 同步队列(获取Lock排队)和等待队列(获取Condition排队)中节点的类型都是同步器的静态内部类AbstractQueuedSynchronizer.Node

注意：

• 在condition.await()方法调用之前，必须先用lock.lock()方法获取到锁。

多路通知功能：

• 在一个Lock对象里面创建多个Condition实例，线程对象可以注册在指定的Condition中，从而可以有选择地进行线程通知。可以先对线程进行分组，然后再唤醒指定组中的线程。

二、Lock接口的实现：

2.1可重入锁ReentrantLock

重入：

• 重入是指任意线程在获取到锁之后能够再次获取该锁而不会被阻塞。
• 在调用lock()方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞。

原理：

• 线程再次获取锁：锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。
• 锁的最终释放：
  • 获取锁时需要进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经成功释放。
  • 线程重复n次获取了锁，随后在释放n次该锁后，其它线程能够获取到该锁。
  • ReentrantLock类中封装的AQS的同步状态表示锁被一个线程重复获取的次数。

支持获取锁时的公平性和非公平性选择：

• 公平锁保证了锁的获取按照FIFO原则，其代价是需要进行大量的线程切换。
• 非公平锁虽然可能造成线程“饥饿”，但是极少的线程切换，保证了其更大的吞吐量。

例子：

// 实现等待/通知的service类
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MessageService {
	
	private Lock lock = new ReentrantLock();
	public Condition conditionA = lock.newCondition();
	public Condition conditionB = lock.newCondition();
	
	public void awaitA() {
		try {
			lock.lock();
			System.out.println("start awaitA, time:" + System.currentTimeMillis() + " ThreadName:" + Thread.currentThread().getName());
			conditionA.await();
			System.out.println("end awaitA, time:" + System.currentTimeMillis() + " ThreadName:" + Thread.currentThread().getName());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void awaitB() {
		try {
			lock.lock();
			System.out.println("start awaitB, time:" + System.currentTimeMillis() + " ThreadName:" + Thread.currentThread().getName());
			conditionB.await();
			System.out.println("end awaitB, time:" + System.currentTimeMillis() + " ThreadName:" + Thread.currentThread().getName());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void signalAllforA() {
		try {
			lock.lock();
			System.out.println("signalAllforA, time:" + System.currentTimeMillis() + " ThreadName:" + Thread.currentThread().getName());
			conditionA.signalAll();
		} finally {
			lock.unlock();
		}
	}
	
	public void signalAllforB() {
		try {
			lock.lock();
			System.out.println("signalAllforB, time:" + System.currentTimeMillis() + " ThreadName:" + Thread.currentThread().getName());
			conditionB.signalAll();
		} finally {
			lock.unlock();
		}
	}
}

//线程A
public class ThreadA extends Thread{

	private MessageService messageService;
	
	public ThreadA(MessageService messageService) {
		this.messageService = messageService;
	}
	
	@Override
	public void run() {
		this.messageService.awaitA();
	}
}

//线程B
public class ThreadB extends Thread{

	private MessageService messageService;
	
	public ThreadB(MessageService messageService) {
		this.messageService = messageService;
	}
	
	@Override
	public void run() {
		this.messageService.awaitB();
	}
}


//测试类：
	public class LockTest {

		public static void main(String[] args) {
			try {
				MessageService messageService = new MessageService();
				ThreadA threadA = new ThreadA(messageService);
				threadA.setName("Thread-A");
				threadA.start();
				ThreadB threadB = new ThreadB(messageService);
				threadB.setName("Thread-B");
				threadB.start();
				
				Thread.sleep(5000);
				messageService.signalAllforA(); // 运行后，只有ThreadA被唤醒了
				
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	结果：
		start awaitA, time:1497603307947 ThreadName:Thread-A
		start awaitB, time:1497603307947 ThreadName:Thread-B
		signalAllforA, time:1497603312947 ThreadName:main
		end awaitA, time:1497603312947 ThreadName:Thread-A

2.2可重入读写锁ReentrantReadWriteLock

概念：

• 读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的独占锁有了很大提升。

源码：

package java.util.concurrent.locks;
	
public interface ReadWriteLock {

	/** Returns the lock used for reading. */
	Lock readLock();

	/** Returns the lock used for writing. */
	Lock writeLock();
}

原理：

读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，其它的读线程和写线程均被阻塞：

• 获取写锁的前提：写锁和读锁都没有被其它线程获取到。
• 获取读锁的前提：写锁没有被其它线程获取。

读写状态的设计：

• 在一个整型变量上维护多种状态，就需要“按位切割使用”这个变量，读写锁将变量切分成了两个部分，高16位表示读，低16位表示写。

优点：

• 一般情况下，读写锁的性能都会比独占锁好，因为大多数场景读是多于写的，在读多于写的情况下，读写锁能够提供比独占锁更好的并发性和吞吐量。
• 支持公平性选择、支持读锁和写锁的重入
• 支持锁降级：
  • 锁降级的概念：先获取到写锁后，再获取到读锁，随后才释放写锁，最后只持有读锁的过程。
  • 按照获取写锁、获取读锁、释放写锁的顺序进行操作，从而将写锁降级为读锁。       

三、java中常用的并发工具