内置锁
Java提供了一种内置的锁机制来支持原子性：同步代码块（Synchronized Block）。
|
1
2
3
4
5
6
|
/*
*原文出处：http://liuxp0827.blog.51cto.com/5013343/1414349
*/
synchronzied (lock){
//访问或修改由锁保护的共享状态
}
|
每个Java独享都可以用作一个实现同步的锁，这些锁被称为内置锁(Itrinsic Lock)或者监事锁(Monitor Lock)。线程在进入同步代码块之前会自动获得锁，并且在退出同步代码块时自动释放锁。Java的内置锁相当于一种互斥体，这意味着最多只有一个线程能持有这种锁。当线程1尝试获取一个由线程2持有的锁时，线程1必须等待或者阻塞，知道线程2释放这个锁。由于这个锁保护的同步代码块会以原子方式执行(一组语句作为一个不可分割的单元被执行)，多个线程在执行改代码块时互不干扰。我们再来改善下上篇博客 Java并发编程学习笔记（一）线程安全性 1 最后那段Servlet处理因数分解的代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
/*
*原文出处：http://liuxp0827.blog.51cto.com/5013343/1414349
*/
@ThreadSafe
//并非好的代码
public
class
SynchronizedFactorizer
implements
Servlet {
@GuardedBy
(
"this"
)
private
BigInteger lastNumber;
@GuardedBy
(
"this"
)
private
BigInteger[] lastFactors;
public
synchronized
void
service(ServletRequest req,ServletResponse resp) {
BigInteger i = extractFromRequest(req);
if
(i.equals(lastNumber))
encodeIntoResponse(resp,lastNumber.get());
else
{
BigInteger[] factors = factor(i);
lastNumber = i;
lastFactors = factors;
encodeIntoResponse(resp,factors);
}
}
}
|
这个Servlet能正确地缓存最新的计算结果，但并发性却非常糟糕，服务的响应性非常低，无法令人接受。这是一个性能问题，并不是线程安全的问题。
可重入
线程安全：被多个并发的线程反复调用时，他会产生正确的结果。可重入：当被多个线程调用的时候，不会引用任何共享数据。
当某个线程请求一个由其他线程持有的锁时，发出请求的线程就会阻塞。不过，内置锁是可重入的，因此如果某个线程试图获得一个已经由它自己持有的锁，那么这个请求就会成功。可重入的一种实现方法，是为每个锁关联一个获取计数值和一个所有者线程。当计数值为0时，这个锁就认为是没有被任何线程持有。当线程请求一个未被持有的锁时，JVM将记下锁的持有者，并且将获取计数值置为1.如果同一个线程再次获取这个锁，计数值将递增，而当线程退出同步代码块时，计数值会相应地递减。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/*
*原文出处：http://liuxp0827.blog.51cto.com/5013343/1414349
*/
public
class
Widget {
public
synchronized
void
doSomething() {
...
}
}
public
class
LoggingWidget
extends
Widget {
public
synchronized
void
doSomething() {
System.out.println(toString() +
": calling doSomething"
);
super
.doSomething();
}
}
|
上面代码中，子类改写了父类的synchronized方法，然后调用父类中的方法，此时如果没有可重入的锁，那么这段代码将死锁。每个doSomething方法在执行前都会获取Widget上的锁，如果这个内置锁不是可重入的，那么在调用super.doSomething时将无法获得Widget上的锁。重入则避免了这样的情况。可重入函数一定是线程安全的；线程安全的函数可能是重入的，也可能是不重入的；线程不安全的函数一定是不可重入的。
用锁来保护状态
由于锁能使其保护的代码路径以串行形式(多个线程依次以独占的方式访问对象，而不是并发的访问)来访问，因此可以通过锁来构造一些协议已实现对共享状态的独占访问。
访问共享状态的复合操作，例如上篇博客中提到的命中计数器的递增操作或者延迟初始化，都必须是原子操作。但仅仅将复合操作封装到同步代码块是不够的。如果用同步来协调对某个变量的访问，那么在访问这个变量的所有位置上都需要使用同步，而且，使用锁来协调对某个变量的访问时，在访问变量的所有位置上都要使用同一个锁。对于可能被多个线程同时访问的可变状态变量，在访问它时都需要持有同一个锁，在这种情况下，称状态变量是由这个锁保护的。
上述代码SynchronizedFactorizer中，lastNumber和lastFactors都是有Servlet的内置锁保护的，对象的内置锁与其状态之间没有内在的关联。虽然大多数类都将内置锁用作一种有效的加锁机制，但对象的域并不一定要通过内置所来保护。当线程获取与对象关联的锁时，并不能阻止其他线程访问对象，只能阻止其他线程获得同一个锁。
一种常见的加锁约定，将所有的可变状态都封装在对象内部，并通过对象的内置锁对所有访问可变状态的代码路径进行同步，使得在该对象上不会发生并发访问。但是，如果在添加新的方法或者代码路径忘记了同步，那么这种加锁协议会很容易被破坏。
当某个变量由锁保护时，每次访问这个变量时都需要首先获得锁，这样就保证了同一时刻只有一个线程可以访问这个变量。当类的不变形条件涉及到多个状态变量的时候，每个变量都必须由同一个锁来保护。因此可以在单个原子操作中访问这些变量。
