Java线程与并发编程实践----锁框架

Posted 2020-10-21

    Java.util.concurrent.locks包提供了一个包含多种接口和类的框架，它

针对条件进行加锁和等待。不同于对象的内置加锁同步以及java.lang.Object的等

待/通知机制，包含锁框架的并发工具类通过轮询锁、显示等待及其它方式改善这种

机制。

    锁框架包含了经常使用的锁、重入锁、条件、读写锁以及冲入读写锁等类别。

一、锁（Lock）

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实

现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。

锁是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问。

一次只能有一个线程获得锁，对共享资源的所有访问都需要首先获得锁。不过，某些锁

可能允许对共享资源并发访问，如 ReadWriteLock 的读取锁。

synchronized 方法或语句的使用提供了对与每个对象相关的隐式监视器锁的访问，但却

强制所有锁获取和释放均要出现在一个块结构中：当获取了多个锁时，它们必须以相反的

顺序释放，且必须在与所有锁被获取时相同的词法范围内释放所有锁。

虽然 synchronized 方法和语句的范围机制使得使用监视器锁编程方便了很多，而且还

帮助避免了很多涉及到锁的常见编程错误，但有时也需要以更为灵活的方式使用锁。

例如，某些遍历并发访问的数据结果的算法要求使用 "hand-over-hand" 或 "chain locking"：

获取节点 A 的锁，然后再获取节点 B 的锁，然后释放 A 并获取 C，然后释放

 B 并获取 D，依此类推。Lock 接口的实现允许锁在不同的作用范围内获取和释放，

并允许以任何顺序获取和释放多个锁，从而支持使用这种技术。 

二、重入锁

    类ReentrantLock实现了接口Lock，描述了一个可重入的互斥锁。这个锁和一个持有量

相关联。当一个线程持有这个锁并且调用lock()、lockUninterruptibly()或者任意一个trylock()

方法重新获取锁，这个持有量就递增一。当线程调用unlock()方法，持有量就递减1。当持有量

降为零，锁就会被释放。

    ReentrantLock提供了与通过同步方法、代码块得以访问的隐士监听锁同样的并发语义

及内存语义。不过它具备可扩展的功能并且在高线程争用的环境下（线程频繁地请求获取已经

被其它线程持有的锁）具有更好地性能。

使用重入锁实现同步块：

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

public class Test {

	public static void main(String[] args) {
		
		final Lock lock = new ReentrantLock();
		ExecutorService execute = Executors.newFixedThreadPool(2);
		class Worker implements Runnable {
			
			private final String name;
			public Worker(String name) {
				this.name = name;
			}

			@Override
			public void run() {
				lock.lock();
				System.out.println(Thread.currentThread().getName() +"---"+ name);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				} finally {
					lock.unlock();
				}
			}
		}
		execute.execute(new Worker("jiaxx"));
		execute.execute(new Worker("jiadd"));
		execute.shutdown();
	}
}

三、条件

    接口Condition把Object的wait和notification方法分解到不同的条件对象中。

通过把这些条件和任意Lock实现的使用组合起来，起到让每个对象上具有多重等待集合

的作用。这里Lock取代了同步方法、代码块，Condition取代了Object的wait、notification

方法。

使用重入锁和条件实现生产者和消费者：

package xiancheng;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PC {

	public static void main(String[] args) {
		Shared s = new Shared();
		Thread t1 = new Thread(new Product(s,s.lock,s.condition));
		Thread t2 = new Thread(new Consumer(s,s.lock,s.condition));
		t1.start();
		t2.start();
	}
}

class Shared {

	private char c;
	private volatile boolean writeable = true;
	final Lock lock;
	final Condition condition;

	public Shared() {
		this.lock = new ReentrantLock();
		this.condition = lock.newCondition();
	}

	public void setChar(char ch) {
		lock.lock();
		while (!writeable) {
			try {
				condition.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.c = ch;
		writeable = false;
		condition.signal();
		lock.unlock();
	}

	public char getChar() {
		lock.lock();
		while (writeable) {
			try {
				condition.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		writeable = true;
		condition.signal();
		lock.unlock();
		return c;
	}
}

class Product implements Runnable {

	private final Shared s;
	private final Lock lock;
	private final Condition condition;

	public Product(Shared s, Lock lock, Condition condition) {
		this.s = s;
		this.lock = lock;
		this.condition = condition;
	}

	@Override
	public void run() {
		for (char i = 'A'; i < 'Z'; i++) {
			lock.lock();
			s.setChar(i);
			System.out.println("生产者生产了一个" + i);
			lock.unlock();
		}
	}

}

class Consumer implements Runnable {

	private final Lock lock;
	private final Condition condition;
	private final Shared s;

	public Consumer(Shared s, Lock lock, Condition condition) {
		this.s = s;
		this.lock = lock;
		this.condition = condition;
	}

	@Override
	public void run() {
		char ch;
		do {
			lock.lock();
			ch = s.getChar();
			System.out.println("消费者消费了一个" + ch);
			lock.unlock();
		} while (ch != 'Z');
	}
}

四、读写锁

    读写锁适用于对数据结构频繁读而较少修改的场景。

    锁框架针对这些场景提供了读--写锁机制，在读取时具有更好地并发性，而写入时

保证安全的互斥访问。这一机制基于接口ReadWriteLock接口。该接口维护了一对锁，一个

针对写操作，一个针对读操作，读锁可以被多个线程持有，而写锁是互斥的，只允许一个线程

访问修改共享数据。

具体代码的实现参见我的另一篇微博：

http://blog.51cto.com/12222886/1964183