[TOC]
声明
该系列文章只是记录本人回顾java多线程编程时候记录的笔记。文中所用语言并非严谨的专业术语(太严谨的术语其实本人也不会……)。难免有理解偏差的地方，欢迎指正。
另外，大神请绕路。不喜勿喷。
毕竟好记性不如烂笔头嘛，而且许多东西只要不是你经常用的最终都会一丢丢一丢丢地给忘记。
1 几个名词
1.1 读写锁
读写锁在同一时刻可以允许多个读线程访问。
但是在写线程访问时，所有的读线程和其他写线程均被阻塞。
2 Lock和synchronized
2.1 Lock简介
一般而言，java中锁是在多线程环境下访问共享资源的一种手段。
一般的锁可以防止多个线程同时访问共享资源，但是也有些锁可以允许多个线程并发的访问共享资源，比如读写锁。
在java5之前，要实现锁，只有依靠synchronized关键字来隐式的获取和释放锁。
在java5中，提供了另一种显式地获取和释放锁的技术。可以通过接口java.util.concurrent.locks.Lock来实现。
- Lock是一种控制多线程访问共享资源的工具
- 要访问共享资源，必先获取锁
- 同一时刻只能有一个线程获取锁
- 一般而言，lock都是排他性的访问共享资源
- 但是，也有一些锁可以允许对共享资源的并发访问,比如
ReadWriteLock
-
Lock的出现可以提供比使用synchronized关键字更广泛的锁操作方式 - 一般而言，
Lock的使用应该像下面这样:
Lock l = lockInstance;
l.lock();
try {
//TODO 访问共享资源
} finally {
//释放锁
l.unlock();
}
2.2 Lock接口的API简介
package java.util.concurrent.locks;
import java.util.concurrent.TimeUnit;
/**
* @since 1.5
* @author Doug Lea
*/
public interface Lock {
/**
* 获取锁.调用该方法的线程会得到锁。
*/
void lock();
/**
* 可中断的获取锁，该方法可以响应中断(可以中断当前线程)。
*/
void lockInterruptibly() throws InterruptedException;
/**
* 尝试非阻塞地获取锁。
* 调用后方法立即返回:
* 如果能正常获取到锁，则立即返回true
* 如果没能正常获取到锁，则立即返回false。
*
* 对该方法的调用可能是这样的:
* Lock lock = ...;
* if (lock.tryLock()) {
* try {
* // manipulate protected state
* } finally {
* lock.unlock();
* }
* } else {
* // perform alternative actions
* }
*
*/
boolean tryLock();
/**
* 在指定的超时时间内获取锁。
*
* 如果锁可以立即获得，则直接返回true。
* 否则，在以下三种情况下会返回:
* 1. 在指定的超时时间内获取到了锁(true)
* 2. 在指定的超时时间内线程被interrupt()了(false)
* 3. 超时(false)
*/
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
/**
* 释放锁.
*/
void unlock();
/**
* 返回和当前Lock对象绑定的Condition实例。
*/
Condition newCondition();
}
2.3 Lock的常用实现类
2.3.1 ReentrantLock
java.util.concurrent.locks.ReentrantLock是一种重入锁。也就是说该锁支持一个线程对资源的重复加锁。在调用lock()方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞。
我们常见的synchronized也是隐式地支持重复加锁的。比如用synchronized修饰的递归方法。
ReentrantLock同时还支持获取锁时的公平和非公平性选择。
所谓的公平性就是指：哪个线程先请求获取锁，就给哪个线程优先分配锁。也就是等待时间最长的线程优先获取锁。有点类似于队列的FIFO特性。
//fair：是否支持公平性获取锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
由于要维护公平性原则,公平性的锁效率不如非公平性的锁。
但是公平性的锁可以减少饥饿的发生，不至于导致某些线程被饿死。
ReentrantLock总结
- 排他性
- 可重入
- 公平/非公平性支持
2.3.2 ReentrantReadWriteLock
java.util.concurrent.locks.ReentrantReadWriteLock实际上是java.util.concurrent.locks.ReadWriteLock读写锁的实现类。
读写锁维护了一对锁，一个读锁和一个写锁。
一般情况下，读写锁的性能都会比排它锁好，因为大多数场景读是多于写的。在读多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量。
public interface ReadWriteLock {
/**
* 返回读锁
*/
Lock readLock();
/**
* 返回写锁
*/
Lock writeLock();
}
ReentrantReadWriteLock总结
- 可重入
- 公平/非公平性支持
- 读写锁
以下是《Java并发编程的艺术》一书中对ReentrantReadWriteLock的示例:
public class Cache {
private static final Map<String, Object> map = new HashMap<String, Object>();
private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private static final Lock readLock = lock.readLock();
private static final Lock writeLock = lock.writeLock();
public static final Object get(String key) {
readLock.lock();
try {
return map.get(key);
} finally {
readLock.unlock();
}
}
public static final Object put(String key, Object value) {
writeLock.lock();
try {
return map.put(key, value);
} finally {
writeLock.unlock();
}
}
public static final void clear() {
writeLock.lock();
try {
map.clear();
} finally {
writeLock.unlock();
}
}
}
2.4 Lock和synchronized示例
可以这么说：Lock就是synchronized的显式调用版本。
当然，Lock的功能要比synchronized强大的多，也更加灵活。
下面以一个简单多线程并发的示例来感受下分别用synchronized和Lock实现排他访问共享资源。
该示例中Printer类模拟一个打印机，简单实现如下:
import java.util.concurrent.TimeUnit;
public class Printer {
public void print(String str) {
for (char c : str.toCharArray()) {
System.out.print(c);
}
System.out.println();
}
}
单线程环境下，当然没有什么问题。
但是如果多线程共同访问这个打印机的话，问题就来了。比如向下面这样访问:
public static void main(String[] args) {
Printer printer = new Printer();
new Thread(() -> {
while (true) {
printer.print("abc");
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(() -> {
while (true) {
printer.print("123");
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
一个线程一直打印“abc”，另一个线程打印"123"。
正常情况下以上代码并不会按我们的目的来打印，我们期望的可能是这样的:
123
123
abc
123
但是，事实可能是这样的:
a123b
c
abc
123
1abc
不正常的原因就是这个共享资源打印机应该是被排他访问的。
synchronized版本
最直接的，给print方法同步即可：
public synchronized void print(String str) {
for (char c : str.toCharArray()) {
System.out.print(c);
}
System.out.println();
}
Lock版本
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class PrinterByLock {
private Lock lock = new ReentrantLock();
public void print(String str) {
lock.lock();//加锁
try {
for (char c : str.toCharArray()) {
System.out.print(c);
}
System.out.println();
} finally {
lock.unlock();//释放锁
}
}
}
3 Condition
3.1 Condition简介
在java5之前要实现线程同步(等待/通知)就只能使用定义在java.lang.Object类上的以下方法和synchronized配合使用了:
java.lang.Object.wait()java.lang.Object.wait(long)java.lang.Object.wait(long, int)java.lang.Object.notify()java.lang.Object.notifyAll()
在java5中提供了java.util.concurrent.locks.Condition来实现类似的功能
以下是《Java并发编程的艺术》一书中对Object的监视器方法和Condition接口的对比
3.2 Condition示例
在以前的文章：
《java多线程-02-基本操作及线程通信示例》：http://blog.csdn.net/hylexus/article/details/53446711和http://www.jianshu.com/p/e670c726a206
《java多线程-03-阻塞队列简介》：http://blog.csdn.net/hylexus/article/details/53451307和http://www.jianshu.com/p/b47a4a93a875
中都出现了生产者和消费者的示例级别的代码。
在此处就将以前使用synchronized+wait()/notify()/notifyAll()实现的生产者和消费者改写为使用Lock+Condition来实现。
其实也就是将示例中的Container类改写就可以了。以下是完整代码:
package cn.hylexus.concurrence;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ProducerConsumerByCondition {
public static void main(String[] args) {
Container container = new Container(5);
for (int i = 0; i < 10; i++) {
new Thread(new Producer(container), "P-" + i).start();
new Thread(new Consumer(container), "C-" + i).start();
}
}
public static class Product {
private String name;
public Product(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "[name=" + name + "]";
}
}
public static class Container {
private int nextIndex = 0;
Product[] products = null;
private Lock lock = new ReentrantLock();
private Condition condition = this.lock.newCondition();
public Container(int size) {
this.products = new Product[size > 0 ? size : 5];
}
public void push(Product product) {
this.lock.lock();
try {
while (this.nextIndex >= this.products.length) {
try {
// this.products.wait();
this.condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// this.products.notifyAll();
this.condition.signalAll();
this.products[nextIndex++] = product;
} finally {
this.lock.unlock();
}
}
public Product pop() {
this.lock.lock();
try {
while (this.nextIndex <= 0) {
try {
// this.products.wait();
this.condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// this.products.notifyAll();
this.condition.signalAll();
return this.products[--nextIndex];
} finally {
this.lock.unlock();
}
}
}
public static class Producer implements Runnable {
private Container container;
public Producer(Container container) {
super();
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < Integer.MAX_VALUE; i++) {
Product p = new Product(Thread.currentThread().getName() + "_" + i);
this.container.push(p);
System.out.println("生产者[" + Thread.currentThread().getName() + "]生产>>>>>>:" + p);
try {
Thread.sleep((long) (Math.random() * 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static class Consumer implements Runnable {
private Container container;
public Consumer(Container container) {
super();
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < Integer.MAX_VALUE; i++) {
Product product = this.container.pop();
System.out.println("消费者[" + Thread.currentThread().getName() + "]消费<<<<<<:" + product);
try {
Thread.sleep((long) (Math.random() * 2000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
4 总结
简单来说：
-
Lock和synchronized对应，可以实现线程同步 -
Condition和wait()/notify()等监视器方法对应，可以实现线程通信 -
synchronized是隐式地获取/释放锁，Lock是显式地获取释/放锁
参考资料
- 《java并发编程的艺术》
