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
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接口。该接口维护了一对锁,一个
针对写操作,一个针对读操作,读锁可以被多个线程持有,而写锁是互斥的,只允许一个线程
访问修改共享数据。
具体代码的实现参见我的另一篇微博:
https://blog.51cto.com/12222886/1964183