Java 语言通过 synchronized 关键字来保证原子性，这是因为每一个 ob ject 都有一个隐含的锁，这个也称作监视器对象。在进入 synchronized 之前自动获取此内部锁，而一旦离开此方式，无论是完成或者中断都会自动释放锁。显然这是一个独占锁，每个锁请求之间是互斥的。相对于众多高级锁 (Lock/ReadWriteLock 等)，synchronized 的代价都比后者要高。但是 synchronzied 的语法比较简单，而且也比较容易使用和理解。Lock 一旦调用了 lock() 方法获取到锁而未正确释放的话很有可能造成死锁，所以 Lock 的释放操作总是跟在 finally 代码块里面，这在代码结构上也是一次调整和冗余。Lock 的实现已经将硬件资源用到了极致，所以未来可优化的空间不大，除非硬件有了更高的性能，但是 synchronized 只是规范的一种实现，这在不同的平台不同的硬件还有很高的提升空间，未来 Java 锁上的优化也会主要在这上面。既然 synchronzied 都不可能避免死锁产生，那么死锁情况会是经常容易出现的错误，下面具体描述死锁发生的原因及解决方法。

 

　　死锁描述

　　死锁是操作系统层面的一个错误，是进程死锁的简称，最早在 1965 年由 Dijkstra 在研究银行家算法时提出的，它是计算机操作系统乃至整个并发程序设计领域最难处理的问题之一。

　　事实上，计算机世界有很多事情需要多线程方式去解决，因为这样才能最大程度上利用资源，才能体现出计算的高效。但是，实际上来说，计算机系统中有很多一次只能由一个进程使用的资源的情况，例如打印机，同时只能有一个进程控制它。在多通道程序设计环境中，若干进程往往要共享这类资源，而且一个进程所需要的资源还很有可能不止一个。因此，就会出现若干进程竞争有限资源，又推进顺序不当，从而构成无限期循环等待的局面。我们称这种状态为死锁。简单一点描述，死锁是指多个进程循环等待它方占有的资源而无限期地僵持下去的局面。很显然，如果没有外力的作用，那么死锁涉及到的各个进程都将永远处于封锁状态。

　　系统发生死锁现象不仅浪费大量的系统资源，甚至导致整个系统崩溃，带来灾难性后果。所以，对于死锁问题在理论上和技术上都必须予以高度重视。

 

　　银行家算法

　　一个银行家如何将一定数目的资金安全地借给若干个客户，使这些客户既能借到钱完成要干的事，同时银行家又能收回全部资金而不至于破产。银行家就像一个操作系统，客户就像运行的进程，银行家的资金就是系统的资源。

　　银行家算法需要确保以下四点：

　　当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;

　　顾客可以分期贷款, 但贷款的总数不能超过最大需求量;

　　当银行家现有的资金不能满足顾客尚需的贷款数额时，对顾客的贷款可推迟支付，但总能使顾客在有限的时间里得到贷款;

　　当顾客得到所需的全部资金后，一定能在有限的时间里归还所有的资金。

 

　　清单 1. 银行家算法实现

　　/*一共有5个进程需要请求资源，有3类资源*/

　　public class BankDemo {

　　// 每个进程所需要的最大资源数

　　public static int MAX[][] = { { 7, 5, 3 }, { 3, 2, 2 }, { 9, 0, 2 },

　　{ 2, 2, 2 }, { 4, 3, 3 } };

　　// 系统拥有的初始资源数

　　public static int AVAILABLE[] = { 10, 5, 7 };

　　// 系统已给每个进程分配的资源数

　　public static int ALLOCATION[][] = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 },

　　{ 0, 0, 0 }, { 0, 0, 0 } };

　　// 每个进程还需要的资源数

　　public static int NEED[][] = { { 7, 5, 3 }, { 3, 2, 2 }, { 9, 0, 2 },

　　{ 2, 2, 2 }, { 4, 3, 3 } };

　　// 每次申请的资源数

　　public static int Request[] = { 0, 0, 0 };

　　// 进程数与资源数

　　public static int M = 5, N = 3;

　　int FALSE = 0;

　　int TRUE = 1;

　　public void showdata() {

　　int i, j;

　　System.out.print("系统可用的资源数为:/n");

　　for (j = 0; j < N; j++) {

　　System.out.print("资源" + j + ":" + AVAILABLE[j] + " ");

　　}

　　System.out.println();

　　System.out.println("各进程还需要的资源量:");

　　for (i = 0; i < M; i++) {

　　System.out.print("进程" + i + ":");

　　for (j = 0; j < N; j++) {

　　System.out.print("资源" + j + ":" + NEED[i][j] + " ");

　　}

　　System.out.print("/n");

　　}

　　System.out.print("各进程已经得到的资源量: /n");

　　for (i = 0; i < M; i++) {

　　System.out.print("进程");

　　System.out.print(i);

　　for (j = 0; j < N; j++) {

　　System.out.print("资源" + j + ":" + ALLOCATION[i][j] + " ");

　　}

　　System.out.print("/n");

　　}

　　}

　　// 分配资源，并重新更新各种状态

　　public void changdata(int k) {

　　int j;

　　for (j = 0; j < N; j++) {

　　AVAILABLE[j] = AVAILABLE[j] - Request[j];

　　ALLOCATION[k][j] = ALLOCATION[k][j] + Request[j];

　　NEED[k][j] = NEED[k][j] - Request[j];

　　}

　　};

　　// 回收资源，并重新更新各种状态

　　public void rstordata(int k) {

　　int j;

　　for (j = 0; j < N; j++) {

　　AVAILABLE[j] = AVAILABLE[j] + Request[j];

　　ALLOCATION[k][j] = ALLOCATION[k][j] - Request[j];

　　NEED[k][j] = NEED[k][j] + Request[j];

　　}

　　};

　　// 释放资源

　　public void free(int k) {

　　for (int j = 0; j < N; j++) {

　　AVAILABLE[j] = AVAILABLE[j] + ALLOCATION[k][j];

　　System.out.print("释放" + k + "号进程的" + j + "资源!/n");

　　}

　　}

　　public int check0(int k) {

　　int j, n = 0;

　　for (j = 0; j < N; j++) {

　　if (NEED[k][j] == 0)

　　n++;

　　}

　　if (n == 3)

　　return 1;

　　else

　　return 0;

　　}

　　// 检查安全性函数

　　//所以银行家算法其核心是：保证银行家系统的资源数至少不小于一个客户的所需要的资源数。在安全性检查函数 chkerr() 上由这个方法来实现

　　//这个循环来进行核心判断，从而完成了银行家算法的安全性检查工作。

　　public int chkerr(int s) {

　　int WORK;

　　int FINISH[] = new int[M], temp[] = new int[M];// 保存临时的安全进程序列

　　int i, j, k = 0;

　　for (i = 0; i < M; i++)

　　FINISH[i] = FALSE;

　　for (j = 0; j < N; j++) {

　　WORK = AVAILABLE[j]; // 第 j 个资源可用数

　　i = s;

　　// 判断第 i 个进程是否满足条件

　　while (i < M) {

　　if (FINISH[i] == FALSE && NEED[i][j] <= WORK) {

　　WORK = WORK + ALLOCATION[i][j];

　　FINISH[i] = TRUE;

　　temp[k] = i;

　　k++;

　　i = 0;

　　} else {

　　i++;

　　}

　　}

　　for (i = 0; i < M; i++)

　　if (FINISH[i] == FALSE) {

　　System.out.print("/n 系统不安全!!! 本次资源申请不成功!/n");

　　return 1;

　　}

　　}

　　System.out.print("/n 经安全性检查，系统安全，本次分配成功。/n");

　　System.out.print("本次安全序列：");

　　for (i = 0; i < M - 1; i++) {

　　System.out.print("进程" + temp[i] + "->");

　　}

　　System.out.print("进程" + temp[M - 1]);

　　System.out.println("/n");

　　return 0;

　　}

　　}

 

　　死锁示例

　　死锁问题是多线程特有的问题，它可以被认为是线程间切换消耗系统性能的一种极端情况。在死锁时，线程间相互等待资源，而又不释放自身的资源，导致无穷无尽的等待，其结果是系统任务永远无法执行完成。死锁问题是在多线程开发中应该坚决避免和杜绝的问题。

　　一般来说，要出现死锁问题需要满足以下条件：

　　1. 互斥条件：一个资源每次只能被一个线程使用。

　　2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

　　3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。

　　4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

　　只