更多 Java 并发编程方面的文章，请参见文集《Java 并发编程》
synchronized 关键字
-
用在普通方法前
synchronized void func()：对象锁- 等价与
synchronized(this) {...}
- 等价与
-
用在
static方法前synchronized static void func()：类锁- 等价与
synchronized(A.class) {...}
- 等价与
synchronized(obj) {...}：对象锁
synchronized 的问题：
- 不区分读写。如果多个线程对同一个对象进行读操作，实际上不应该有冲突，但是 synchronized 会导致线程等待。
- 会导致线程无限等待。不可以中断等待。
Lock 接口 VS synchronized 关键字
-
类型：
- Lock 为接口，有不同的实现类
- synchronized 为关键字
-
锁的释放：
- Lock 需要手动释放锁，即
unLock() - synchronized 不需要手动释放锁，synchronized 代码块执行完，自动释放锁
- Lock 需要手动释放锁，即
-
等待的中断：
- Lock 可以中断等待，即
t.interrupt() - synchronized 会导致线程无限等待，不可中断
- Lock 可以中断等待，即
- Lock 可以知道线程有没有成功获得锁，即
tryLock()，synchronized不支持
Lock 接口
Java 5 的 concurrent 包开始提供。
提供的方法包括：
-
void lock();：获取锁，如果不能成功获取，则等待，与 synchronized 类似 -
void lockInterruptibly();：获取锁，如果不能成功获取，则等待，且能够响应中断t.interrupt() -
boolean tryLock();：获取锁，如果成功，返回 true，如果不成功，返回 false，不等待 -
boolean tryLock(long time, TimeUnit unit);：在一定的时间内，获取锁，如果成功，返回 true，如果不成功，返回 false，不等待 -
void unlock();：释放锁
可重入锁
可重入锁：锁基于线程分配，而不是基于方法分配。
synchronized 为可重入锁，例如：
在下面的代码中，在线程进入 f1() 方法时已经获得了对象的锁，因此在 f1() 中调用 f2() 时，不需要重新申请锁。
public synchronized void f1() {
// 不需要重新申请锁
f2();
}
public synchronized void f2() {
// to do
}
ReentrantLock 可重入锁
Java 5 的 concurrent 包开始提供，继承了 Lock 接口。
public class ReentrantLock implements Lock, java.io.Serializable {
关于 ReentrantLock 的实现原理，参见 Java AQS AbstractQueuedSynchronizer。
下面的例子中提供了两种方式来控制对共享变量 count 的并行读写操作：
-
incrementAndGetCount()：使用 ReentrantLock：- 记住：
unlock()操作不能忘记，应该放在 finally 中，确保在出现异常状况下也会被调用。
- 记住：
-
incrementAndGetCountWithSynchronized()：使用 synchronized 关键字。
public class Lock_Test {
private Lock lock = new ReentrantLock();
private int count = 0;
private int incrementAndGetCount() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " gets Count: " + count);
return count++;
} finally {
lock.unlock();
}
}
private synchronized int incrementAndGetCountWithSynchronized() {
System.out.println(Thread.currentThread().getName() + " gets Count: " + count);
return count++;
}
public static void main(String[] args) {
Lock_Test test = new Lock_Test();
for (int i = 0; i < 5; i++) {
new Thread() {
public void run() {
test.incrementAndGetCount();
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}.start();
}
}
}
可中断锁
在上文中已经提到过：
- synchronized 会导致线程无限等待，不可中断
- Lock 可以中断等待，即
t.interrupt()，示例如下：
线程t1获得了锁，但是并没有在 finally 中释放锁，因此可以通过t2.interrupt();使得线程t2停止等待。
注意：想要能够响应中断，需使用lock.lockInterruptibly();而不能是lock.lock();
public class Lock_Test2 {
private Lock lock = new ReentrantLock();
private int count = 0;
private int incrementAndGetCount() {
try {
// 想要能够响应中断，需使用 lock.lockInterruptibly(); 而不能是 lock.lock();
lock.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + " gets Count: " + count);
return count++;
} catch (Exception e) {
return 0;
} finally {
// 并没有在 finally 中释放锁
// lock.unlock();
}
}
public static void main(String[] args) {
Lock_Test2 test = new Lock_Test2();
Thread t1 = new Thread() {
public void run() {
test.incrementAndGetCount();
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
};
Thread t2 = new Thread() {
public void run() {
test.incrementAndGetCount();
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
};
t1.start();
t2.start();
t2.interrupt();
}
}
公平锁
- 公平锁：加锁前检查是否有排队等待的线程，先来先得 FIFO，即先排队，再尝试获取锁
- 非公平锁：加锁时不考虑排队等待问题，直接尝试获取锁，获取不到自动到队尾等待，即先尝试获取锁，再排队
ReentrantLock 默认是非公平锁，可以通过构造方法设置为公平锁：
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
公平锁可以被用来解决 饥饿 问题。什么是 饥饿 问题？举例说明：
- T1 锁定资源
- T2 请求资源，T2 等待
- T3 请求资源，T3 等待
- T1 释放资源，T3 获得
- T4 请求资源，T4 等待
- T3 释放资源，T4 获得
- T2 可能永远等待，出现饥饿
读写锁
- 若 读锁 被占用，则申请写锁的线程会等待，申请读锁的线程不用等待
- 若 写锁 被占用，则申请写锁或读锁的线程都会等待
ReadWriteLock 为读写锁的接口，ReentrantReadWriteLock 为一个实现类。
- 通过
Lock readLock();方法得到读锁 - 通过
Lock writeLock();方法得到写锁
在下面的例子中，输出如下：
Thread-4 is reading count: 0
Thread-0 is reading count: 0
Thread-3 is reading count: 0
Thread-2 is reading count: 0
Thread-1 is reading count: 0
Thread-5 is writing count: 0
Thread-6 is writing count: 1
Thread-7 is writing count: 2
Thread-8 is writing count: 3
Thread-9 is writing count: 4
可以看出：
- 在某个线程获得读锁后，其他申请读锁的线程不需等待，而其他申请写锁的线程需要等待。因此 writing 都在 reading 之后。
- 在某个线程获得写锁后，其他申请读锁或者写锁的线程都需要等待。因此 writing 按照 5，6，7，8，9 的顺序依次执行。
public class ReadWriteLock_Test {
private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private static int count = 0;
public static void readCount() {
// 申请读锁
lock.readLock().lock();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
System.out.println(Thread.currentThread().getName() + " is reading count: " + count);
// 申请读锁
lock.readLock().unlock();
}
public static void writeCount() {
// 申请写锁
lock.writeLock().lock();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
System.out.println(Thread.currentThread().getName() + " is writing count: " + count++);
// 释放写锁
lock.writeLock().unlock();
}
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
(new ReadThread()).start();
}
for (int i = 0; i < 5; i++) {
(new WriteThread()).start();
}
}
static class ReadThread extends Thread {
public void run() {
readCount();
}
}
static class WriteThread extends Thread {
public void run() {
writeCount();
}
}
}
