java多线程-07-Lock和Condition

• 声明
• 几个名词
  • 1 读写锁
• Lock和synchronized
  • 1 Lock简介
  • 2 Lock接口的API简介
  • 3 Lock的常用实现类
    • 31 ReentrantLock
    • 32 ReentrantReadWriteLock
  • 4 Lock和synchronized示例
• Condition
  • 1 Condition简介
  • 2 Condition示例
• 总结
• 参考资料

声明

该系列文章只是记录本人回顾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并发编程的艺术》