为了解决竞争条件带来的问题，我们可以对资源上锁。多个线程共同读写的资源称为共享资源，也叫临界资源。涉及操作临界资源的代码区域称为临界区(Critical Section)。同一时刻，只能有一个线程进入临界区。我们把这种情况称为互斥，即不允许多个线程同时对共享资源进行操作，在同一时间只能被一个线程所占有的锁称之为Java多线程互斥锁。
 
互斥锁在java中的实现就是 ReetranLock , 在访问一个同步资源时，它的对象需要通过方法 tryLock() 获得这个锁，如果失败，返回 false，成功返回true。根据返回的信息来判断是否要访问这个被同步的资源。ReentrantLock 互斥锁是可重入锁，即某一线程可多次获得该锁。
 
进入临界区前，需要先获得互斥锁。如果已经有线程正在使用资源，那么需要一直等待，直到其它线程归还互斥锁。
 
操作完共享资源之后，即退出临界区时，需要归还互斥锁，以便其它等待使用该资源的线程能够进入临界区。
 
伪代码示例：
 
wait(lock); //获得互斥锁
 
{
 
临界区，操作共享资源
 
}
 
signal(lock); //归还互斥锁
 
Java 中可以使用 ReentrantLock 对临界区上锁，防止多个线程同时进入临界区：
 
private static Lock bufferLock = new ReentrantLock();
 
public static void print(String msg) {
 
bufferLock.lock();
 
//临界区，操作临界资源 globalBuffer
 
bufferLock.unlock();
 
}
 
这里我们只需要在临界区前使用 lock() 上锁，在临界区后使用 unlock() 解锁即可，java.util.concurrent 帮我们实现了临界区前判断锁状态的工作，会自己决定是阻塞还是进入临界区。
 
synchronized 关键字
 
java 为我们提供了更加简便的方式，用于实现临界区的互斥。
 
例如，我们可以为操作共享资源的函数加上 synchronized 关键字：
 
public synchronized void myFunction() {
 
//操作共享资源 A
 
}
 
通过这种方式，能够确保同一时刻最多只有一个线程在执行该函数。如果资源 A 只在该函数中读写，那么可以保证资源 A 不会出现被多个线程同时读写的情况。
 
但是，如果在其它函数中也对共享资源 A 进行操作，那么就不能使用这种方式来实现资源的使用互斥。因为即使这些函数都声明为 synchronized，也只是说明同一时刻不能有多个线程执行同一个函数，但允许多个线程同时执行不同的函数，而这些函数都在操作同一个资源 A。
 
下面我们给出另一种方法来实现资源使用的互斥锁。
 
synchronized 代码块
 
通过声明函数为 synchronized 的方式，只能实现函数体的互斥。要确保资源使用的互斥，即同一时刻只能有一个线程使用该资源，可以将操作资源 A 的语句放入 synchronized 代码块：
 
public void function1() {
 
......
 
synchronized (A) {
 
//操作资源 A
 
}
 
......
 
}
 
public void function2() {
 
......
 
synchronized (A) {
 
//操作资源 A
 
}
 
......
 
}
 
这样，对于资源 A 来说，同一时刻，只能有一个对应的 synchronized 代码块执行。因此，无论是在哪个地方使用资源 A，都不会出现多个线程竞争该资源的情况。
 
由ReentrantLock 的构造函数可见，在实例化 ReentrantLock 的时候我们可以选择实例化一个公平锁或非公平锁，而默认会构造一个非公平锁。公平锁与非公平锁区别在于竞争锁时的有序与否。Java多线程互斥锁ReentrantLock是通过继承接口Lock而实现的，类似的还有继承 ReadWriteLock 实现的 ReentrantReadWriteLock(读写锁)，对此，在本站的Java多线程教程中有进一步的讲解。

 
假设这样一个情景：在银行的营业厅内先后进来3个人，他们都要进行存款，若是只有一个营业窗口的话，通常的情况是每人都需要先领取顺序条，然后按序排队办理业务，而营业厅会根据号码的顺序依次叫号来处理顾客的问题。
 
在这里银行的窗口就可以看做共享的资源，它每次只能接待一个顾客，而不同的顾客则可以看做是多个线程，他们都需要办理业务，但是又必须遵守先来后到的原则，排队等待前面的顾客办理完业务才能轮到自己独占窗口办理自己的业务(当然也可能存在插队现象，后面会讲到)。
 
为了简化银行处理业务的过程，我们假设每个客户只是办理简单的存款业务，银行窗口只需清点出存款数额就代表业务处理完成。
 
(1)首先我们定义一个银行类Bank，用它来模拟银行。为了能够让整个过程可视化，我们让这个类继承自Applet。而这个银行的主业务--存款(其实就是点钱)，我们用方法countMoney来模拟，由于这是个临界资源，所以我们要给他加上互斥锁synchronize，以保证每次只有一个顾客能够使用这个功能。
 
public class Bank extendsApplet{
 
......public synchronized void countMoney(String name, inttotal){int count = 1;while(count <=total){
 
t.setText("(" + name + ") " + Integer.toString(count++));
 
}
 
notifyAll();
 
}
 
......
 
}
 
为了能够看清楚这个排队等待数钱的过程，我们需要两个文本区域，一个用来显示当前正在办理业务的客户数钱的过程，另一个显示等待数钱的客户队列。
 
public TextField counting= new TextField(10);public TextField deque = new TextField(100);
 
另外我们给该银行模拟了三个用户，他们分别是马云、雷军和马化腾--。
 
private MaYun maYun = null;private LeiJun leiJun = null;private MaHuaTeng maHuaTeng = null;
 
整个Bank类如下所示，其中方法setDeque表示向排队队列中加入顾客。
 

 

 
public class Bank extendsApplet{public TextField counting = new TextField(10);public TextField deque = new TextField(100);private MaYun maYun = null;private LeiJun leiJun = null;private MaHuaTeng maHuaTeng = null;public voidinit() {
 
add(counting);
 
add(deque);
 
maYun= new MaYun(Bank.this);
 
leiJun= new LeiJun(Bank.this);
 
maHuaTeng= new MaHuaTeng(Bank.this);
 
}public voidsetDequeue(String person){
 
String list=deque.getText();
 
list= list + person + "->";
 
deque.setText(list);
 
}public synchronized void countMoney(String name, inttotal){int count = 1;while(count <=total){
 
counting.setText("(" + name + ") " + Integer.toString(count++));
 
}
 
notifyAll();
 
}public static void main(intargc, String args[]){
 
Bank applet= newBank();
 
Frame aFrame= new Frame("Counter2");
 
aFrame.add(applet, BorderLayout.CENTER);
 
aFrame.setSize(300, 200);
 
applet.init();
 
applet.start();
 
aFrame.setVisible(true);
 
}
 
}
 
View Code
 
(2)定义三个线程类，在每个线程类的run方法中都调用银行类中的countMoney方法。由于countMoney加了互斥锁，所以每次只有一个线程可以执行这个方法，而其他的线程都处于阻塞状态。一旦一个县城执行完了countMoney方法，他就会调用notifyAll方法，唤醒其他阻塞的线程。这个过程就模仿了顾客在营业厅排队办理业务的场景。
 

 

 
public class MaYun extendsThread {private static int money = 10000;private static String name = "马云";
 
Bank c= null;
 
Button start= newButton(name);publicMaYun(Bank c){this.c =c;
 
start.addActionListener(newStartListener());
 
c.add(start);
 
}public voidrun() {
 
c.setDequeue(name);
 
c.countMoney(name, money);
 
}public class StartListener implementsActionListener{public voidactionPerformed(ActionEvent e) {
 
MaYun.this.start();
 
}
 
};
 
}
 
View Code
 

 

 
public class LeiJun extendsThread {private static int money = 8000;private static String name = "雷军";
 
Bank c= null;
 
Button start= newButton(name);publicLeiJun(Bank c){this.c =c;
 
start.addActionListener(newStartListener());
 
c.add(start);
 
}public voidrun() {
 
c.setDequeue(name);
 
c.countMoney(name, money);
 
}public class StartListener implementsActionListener{public voidactionPerformed(ActionEvent e) {
 
LeiJun.this.start();
 
}
 
};
 
}
 
View Code
 

 

 
public class MaHuaTeng extendsThread {private static int money = 20000;private static String name = "马化腾";
 
Bank c= null;
 
Button start= newButton(name);publicMaHuaTeng(Bank c){this.c =c;
 
start.addActionListener(newStartListener());
 
c.add(start);
 
}public voidrun() {
 
c.setDequeue(name);
 
c.countMoney(name, money);
 
}public class StartListener implementsActionListener{public voidactionPerformed(ActionEvent e) {
 
MaHuaTeng.this.start();
 
}
 
};
 
}
 
View Code
 
(3)下面给出实验过程中运行的界面结果。我们依次点击马云、雷军、马化腾三个按钮，表示这3个人依次来银行办理业务。由于马云是最先来到的，所以他可以立即到窗口办理点钱业务。而由于处理业务的窗口只有一个，雷军和马化腾只能等马云结束，他们才能办理自己的业务。但是在实际的运行过程中，我们发现马云办理完业务后，紧接着办理业务的不是雷军而是马化腾。这主要是因为当马云办理完业务后，雷军和马化腾并没有按照先来后到的排队顺序来，马化腾插队了。这说明使用notifyAll方法，所有阻塞的线程在获得临近资源的机会上是均等的，谁先抢到，谁先用。
 

 

 

 
public class Bank {
 
private int money;
 
private String name;
 
public Bank(String name, int money) {
 
this.money = money;
 
this.name = name;
 
}
 
//存款
 
public synchronized void deposit(int m) {
 
money += m;
 
}
 
//取款
 
public synchronized boolean withdraw(int m) {
 
if (money >= m) {
 
money -= m;
 
return true; //取款成功
 
} else {
 
return false; //余额不足
 
}
 
}
 
public String getName() {
 
return name;
 
}
 
}
 
如上所述，如果有一个线程正在运行Bank实例的deposit方法，那么其他线程无法运行这个实例中的deposit方法和withdraw方法，但未加锁的getName方法不受影响。当使用完syncharonized的方法运行完这个线程后，就会释放锁
 
线程的互斥机制称之为监视(monitor)，另外，获取锁有时候也叫做拥有(own)监视或者持有(hold)锁。
 
当前线程是否已获得某一个对象的锁可以通过Thread.holdsLock方法来确定。当前线程已经获得对象obj的锁时，可使用assert像下面来表示
 
assert Thread.holdsLock(obj);

 
两种互斥锁机制：
 
1、synchronized
 
2、ReentrantLock
 
ReentrantLock是jdk5的新特性，采用ReentrantLock可以完全替代替换synchronized传统的锁机制，而且采用ReentrantLock的方式更加面向对象，也更加灵活，网上有很多关于对比两者锁方式的文章，这里就不多口舌了，大家baidu、google一下就水落石出了。在本博客中也写关于这两种锁方式实现的经典例子《生产者消费者》。
 
关于读写锁，用语言解释不如直接用代码诠释，以下通过两个例子讲述读写锁以及读写锁的使用：
 
例子1：
 
import java.util.HashMap;
 
import java.util.Map;
 
import java.util.concurrent.locks.ReadWriteLock;
 
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 
* @author amber2012
 
*
 
* 读写锁：ReadWriteLock
 
*
 
* 在多线程的环境下，对同一份数据进行读写，会涉及到线程安全的问题。比如在一个线程读取数据的时候，另外一个线程在
 
* 写数据，而导致前后数据的不一致性；一个线程在写数据的时候，另一个线程也在写，同样也会导致线程前后看到的数据的
 
* 不一致性。
 
*
 
* 这时候可以在读写方法中加入互斥锁，任何时候只能允许一个线程的一个读或写操作，而不允许其他线程的读或写操作，这
 
* 样是可以解决这样以上的问题，但是效率却大打折扣了。因为在真实的业务场景中，一份数据，读取数据的操作次数通常高
 
* 于写入数据的操作，而线程与线程间的读读操作是不涉及到线程安全的问题，没有必要加入互斥锁，只要在读-写，写-写期
 
* 间上锁就行了。
 
*
 
* 对于这种情况，读写锁则最好的解决方案！
 
*
 
* 读写锁的机制：
 
* "读-读"不互斥
 
* "读-写"互斥
 
* "写-写"互斥
 
*
 
* 即在任何时候必须保证：
 
* 只有一个线程在写入；
 
* 线程正在读取的时候，写入操作等待；
 
* 线程正在写入的时候，其他线程的写入操作和读取操作都要等待；
 
*
 
* 以下是一个缓存类：用于演示读写锁的操作：重入、降级
 
*/
 
public class CachedData {
 
// 缓存都应该是单例的，在这里用单例模式设计：
 
private static CachedData cachedData = new CachedData();
 
private final ReadWriteLock lock = new ReentrantReadWriteLock();//读写锁
 
private Map cache = new HashMap();//缓存
 
private CachedData(){
 
}
 
public static CachedData getInstance(){
 
return cachedData;
 
}
 
// 读取缓存：
 
public Object read(String key) {
 
lock.readLock().lock();
 
Object obj = null;
 
try {
 
obj = cache.get(key);
 
if (obj == null) {
 
lock.readLock().unlock();
 
// 在这里的时候，其他的线程有可能获取到锁
 
lock.writeLock().lock();
 
try {
 
if (obj == null) {
 
obj = "查找数据库"; // 实际动作是查找数据库
 
// 把数据更新到缓存中：
 
cache.put(key, obj);
 
}
 
} finally {
 
// 当前线程在获取到写锁的过程中，可以获取到读锁，这叫锁的重入，然后导致了写锁的降级，称为降级锁。
 
// 利用重入可以将写锁降级，但只能在当前线程保持的所有写入锁都已经释放后，才允许重入 reader使用
 
// 它们。所以在重入的过程中，其他的线程不会有获取到锁的机会(这样做的好处)。试想，先释放写锁，在
 
// 上读锁，这样做有什么弊端？--如果这样做，那么在释放写锁后，在得到读锁前，有可能被其他线程打断。
 
// 重入————>降级锁的步骤：先获取写入锁，然后获取读取锁，最后释放写入锁(重点)
 
lock.readLock().lock();
 
lock.writeLock().unlock();
 
}
 
}
 
} finally {
 
lock.readLock().unlock();
 
}
 
return obj;
 
}
 
}
 
例子2：
 
import java.util.Map;
 
import java.util.TreeMap;
 
import java.util.concurrent.locks.Lock;
 
import java.util.concurrent.locks.ReadWriteLock;
 
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
import javax.xml.crypto.Data;
 
/**
 
* @author amber2012
 
*
 
* jdk文档中关于ReentrantReadWriteLock类使用的一个很好的例子，以下是具体的介绍：
 
*
 
* 在使用某些种类的 Collection 时，可以使用 ReentrantReadWriteLock 来提高并发性。通常，在预期 collection
 
* 很大，读取者线程访问它的次数多于写入者线程，并且 entail 操作的开销高于同步开销时，这很值得一试。例如，以下
 
* 是一个使用 TreeMap 的类，预期它很大，并且能被同时访问。
 
*/
 
public class RWDictionary {
 
private final Map map = new TreeMap();
 
private final ReadWriteLock rwl = new ReentrantReadWriteLock();
 
private final Lock readLock = rwl.readLock();
 
private final Lock writeLock = rwl.writeLock();
 
public Data get(String key) {
 
readLock.lock();
 
try {
 
return map.get(key);
 
} finally {
 
readLock.unlock();
 
}
 
}
 
public String[] allKeys() {
 
readLock.lock();
 
try {
 
return (String[]) map.keySet().toArray();
 
} finally {
 
readLock.unlock();
 
}
 
}
 
public Data put(String key, Data value) {
 
writeLock.lock();
 
try {
 
return map.put(key, value);
 
} finally {
 
writeLock.unlock();
 
}
 
}
 
public void clear() {
 
writeLock.lock();
 
try {
 
map.clear();
 
} finally {
 
writeLock.unlock();
 
}
 
}
 
}