本文共 25164 字，大约阅读时间需要 83 分钟。
一、进程与线程概念
1、并发和并行是即相似又有区别：
并发：指两个或多个事件在同一时间段内发生。
并行：指两个或多个事件在同一时刻点发生。
在操作系统中，在多道程序环境下，并发性是指在一段时间内宏观上有多个程序在同时运行，但在单CPU系统中，每一时刻却仅能有一道程序执行（时间片即CPU分配给各个程序的时间），故微观上这些程序只能是分时地交替执行。
若计算机系统中有多个CPU，则这些可以并发执行的程序便可被分配到多个处理器上，实现多任务并行执行，即利用每个处理器来处理一个可并发执行的程序，这样，多个程序便可以同时执行，因为是微观的，所以大家在使用电脑的时候感觉就是多个程序是同时执行的。
“多核处理器”电脑可以同时并行地处理多个程序，从而提高了电脑的运行效率。
单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。
同理，线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。
2、进程与线程
进程：是指一个内存中运行中的应用程序。每个进程都有自己独立的一块内存空间，一个应用程序可以同时启动多个进程。比如在Windows系统中，一个运行的xxx.exe就是一个进程。
线程：是指进程中的一个执行任务(控制单元)，一个进程可以同时并发运行多个线程；线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。
一个进程至少有一个线程，为了提高效率，可以在一个进程中开启多个执行任务,即多线程。如：多线程下载软件。
多进程：操作系统中同时运行的多个程序。
多线程：在同一个进程中同时运行的多个执行任务。
我们查看Windows环境下的任务管理器：
在操作系统中允许多个任务，每一个任务就是一个进程，每一个进程也可以同时执行多个任务，每一个任务就是线程。
3、进程与线程的区别：
线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。
进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
线程：堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间可以影响的，又称为轻型进程或进程元。
因为一个进程中的多个线程是并发运行的，那么从微观角度上考虑也是有先后顺序的，那么哪个线程执行完全取决于CPU调度器，程序员是控制不了的。
我们可以把多线程并发性看作是多个线程在瞬间抢CPU资源，谁抢到资源谁就运行，这也造就了多线程的随机性。
Java程序的进程里至少包含主线程和垃圾回收线程(后台线程)。
4、多线程并发
计算机通常只有一个CPU时，在任意时刻只能执行一条计算机指令，每一个线程只有获得CPU的使用权才能执行指令。
所谓多线程并发运行，从宏观上看，其实是各个线程轮流获得CPU的使用权，分别执行各自的任务。
那么在可运行池中，会有多个线程处于就绪状态等到CPU调度，JAVA中JVM就负责了线程的调度。
JVM采用的是抢占式调度，没有采用分时调度，因此可以能造成多线程执行结果的随机性。
多线程作为一种多任务、并发的工作方式，当然有其存在优势：
1）进程之前不能共享内存，而线程之间共享内存(堆内存)则很简单。
2）系统创建进程时需要为该进程重新分配系统资源，创建线程则代价小很多，因此实现多任务并发时，多线程效率更高.
3）Java语言本身内置多线程功能的支持，而不是单纯的作为底层系统的调度方式，从而简化了多线程编程.
比如：多线程下载：
可以理解为一个线程就是一个文件的下载通道，多线程也就是同时开起好几个下载通道。当服务器提供下载服务时，使用下载者是共享带宽的，在优先级相同的情况下，总服务器会对总下载线程进行平均分配。
不难理解，如果你线程多的话，那下载的越快。现流行的下载软件都支持多线程。
多线程是为了同步完成多项任务，不是为了提供程序运行效率，而是通过提高资源使用效率来提高系统的效率。
宽带带宽知识点:
宽带带宽是以位（bit）计算，而下载速度是以字节（Byte）计算，1字节（Byte）等于8位（bit），所以1024kb/s是代表上网带宽为1024千位（1M），而下载速度需要1024千位/秒（1024kb/s）带宽除以8，得出128千字节/秒（128KB/s）。
二、线程的创建与启动
1、继承 Thread 类：
1）自定义类继承于 Thread 类，那么该自定义类就是线程类；
2）其覆写 run 方法，将线程运行的代码存放在run中；
3）创建自定义类的对象，即线程对象；
4）调用线程对象的start方法，启动线程。
public class HelloWorld { public static void main(String[] args) { for (int i = 1; i <= 100; i++) { System.out.println("打游戏" + i); if(i == 10){ MusicDemo musicDemo = new MusicDemo(); musicDemo.start(); } } }}class MusicDemo extends Thread{ @Override public void run() { for (int i = 1; i <= 50; i++) { System.out.println("听音乐" + i); } }} 
2、实现 Runnable 接口：
1）自定义类实现 Runnable接口，那么该自定义类不是线程类；
2）其覆写run方法，线程运行的代码存放在run中；
3）通过 Thread类创建线程对象，并将实现了 Runnable接口的实现类对象作为参数传递给 Thread类的构造器。
4）Thread类对象调用start方法，启动线程。
public class HelloWorld { public static void main(String[] args) { for (int i = 1; i <= 100; i++) { System.out.println("打游戏" + i); if(i == 10){ Thread thread = new Thread(new MusicDemo()); thread.start(); } } }}class MusicDemo implements Runnable{ @Override public void run() { for (int i = 1; i <= 50; i++) { System.out.println("听音乐" + i); } }} 上面两种还可以使用匿名内部类的方式创建，本质都是一样的
1）使用接口形式的
public static void main(String[] args) { for (int i = 1; i <= 100; i++) { System.out.println("打游戏" + i); if(i == 10){ new Thread(new Runnable() { @Override public void run() { for (int i = 1; i <= 50; i++) { System.out.println("听音乐" + i); } } }).start(); } } } 2）使用类形式的 使用不多
public static void main(String[] args) { for (int i = 1; i <= 100; i++) { System.out.println("打游戏" + i); if(i == 10){ new Thread(){ @Override public void run() { for (int i = 1; i <= 50; i++) { System.out.println("听音乐" + i); } } }.start(); } } } 3、 使用Callable和Future创建线程
1），自定义类实现 Callable接口，重写call()方法，该方法就是线程方法执行体，call()方法有返回值。
2）使用FutureTask类的实例，来包装Callable对象，即将FCallable实现类作为参数传递给 FutureTask类的构造器中。
3）通过 Thread类创建线程对象，并将FutureTask对象作为参数传递给 Thread类的构造器。
4）Thread类对象调用start方法，启动线程。
5）通过FutureTask实例对象调用get()方法得到子线程的返回值。
public class HelloWorld { public static void main(String[] args) { MusicDemo musicDemo = new MusicDemo(); // //创建FutureTask对象 FutureTask futureTask = new FutureTask<>(musicDemo); for (int i = 1; i <= 100; i++) { System.out.println("打游戏" + i); if(i == 10){ new Thread(futureTask, "有返回值的线程").start(); } } //获取子线程的返回值 try { System.out.println("子线程的返回值： "+futureTask.get()); } catch (Exception e) { e.printStackTrace(); } }}class MusicDemo implements Callable { int i ; //call（）方法称之为线程方法执行体，且该方法有返回值，可通过FutureTask实例对象调用get（）方法得到子线程的返回值 @Override public Integer call() throws Exception { for (; i <30; i++) { System.out.println("听音乐" + i); System.out.println(Thread.currentThread().getName()+" "+i); } return i; }} 
三、线程同步
吃苹果比赛：分析继承方法与实现方式的区别
继承方式：
public class ThreadDemo { public static void main(String[] args) { Apple apple1 = new Apple(); Apple apple2 = new Apple(); Apple apple3 = new Apple(); apple3.setName("小明"); apple1.start(); apple2.start(); apple3.start(); }}class Apple extends Thread{ private int num = 50; @Override public void run() { for (int i = 0; i <50; i++) { if(num > 0){ // getName(),获取线程名称，名称默认的是“Thread-n”的形式 System.out.println(super.getName() + "吃苹果" + num); num--; } } }} 
实现方式：
public class ThreadDemo { public static void main(String[] args) { Apple apple = new Apple(); Thread thread1 = new Thread(apple); Thread thread2 = new Thread(apple); Thread thread3 = new Thread(apple,"小明"); thread1.start(); thread2.start(); thread3.start(); }}class Apple implements Runnable{ private int num = 50; @Override public void run() { for (int i = 0; i < 50; i++) { if(num > 0){ System.out.println(Thread.currentThread().getName() + "吃苹果" + num); num--; } } }}
public class ThreadDemo { public static void main(String[] args) { Apple apple = new Apple(); // //创建FutureTask对象 FutureTask futureTask1 = new FutureTask<>(apple); FutureTask futureTask2 = new FutureTask<>(apple); FutureTask futureTask3 = new FutureTask<>(apple); new Thread(futureTask1).start(); new Thread(futureTask2).start(); new Thread(futureTask3).start(); //获取子线程的返回值 try { System.out.println("futureTask1子线程的返回值： "+futureTask1.get()); System.out.println("futureTask2子线程的返回值： "+futureTask2.get()); System.out.println("futureTask3子线程的返回值： "+futureTask3.get()); } catch (Exception e) { e.printStackTrace(); } }}class Apple implements Callable { private int num = 50; @Override public Integer call() throws Exception { for (int i = 0; i < 50; i++) { if(num > 0){ Thread.sleep(10); System.out.println(Thread.currentThread().getName() + "吃苹果" + num); num--; } } return num; }} 
1、继承方法与实现方式的区别：
继承方式：
1）Java 中类是单继承的，如果继承了 Thread 类，则该类就不能再继承其他直接父类。
2）从操作上分析，继承方式简单，获取线程名称也简单（操作上更简单）。
3）从多线程共享同一个资源上分析，继承方式不推荐使用。
实现方式：
1）Java 中类可以多实现接口，此时，该类可以继承其他类，并还可以实现其他接口（设计上更优雅）。
2）从操作上分析，实现方式稍微复杂点，获取线程名称也比较复杂点，得使用 Thread.currentThread() 来获取当前线程的引用。
3）从多线程共享同一个资源上分析，实现方式可以做到（是否共享同一资源）。
2、多线程安全问题
当多线程并发访问同一个资源对象的时候，可能就会出现线程不安全的问题。
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。
在线程的 run方法中不能使用 throws来声明抛出异常，只能在方法中使用 try-catch来处理异常。
3、什么是线程同步
同步这里指，协同步调，互相配合，并按预定的先后次序进行运行。
线程同步是指多线程通过特定的设置来控制线程之间的执行顺序（即所谓的同步）。也可以说是在线程之间通过同步建立起执行顺序的关系，如果没有同步，那线程之间是各自运行各自的！
多线程安全问题的解决方案（方案有很多）：这里采用上面实现方式创建线程的demo做线程同步，类main不变，给 Apple 类加锁
1）synchronized 同步代码块
// 语法synchronized(同步锁){ 需要同步操作的代码} 同步锁：
为了保证每个线程都能正常的执行原子操作，Java引入了线程同步机制。同步监听对象/同步锁/同步监听器/互斥锁。
对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。
Java 程序运行使用任何对象都可以作为同步监听对象，但是一般我们把当前并发访问的共同资源作为同步监听对象。
注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁谁就进入代码块，其他线程只能在外等待。
class Apple implements Runnable{ private int num = 50; @Override public void run() { for (int i = 0; i < 50; i++) { synchronized (this){ // this 表示 apple 对象，多线程共享的资源 if(num > 0){ try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "吃苹果" + num); num--; } } } }} 2）synchronized 同步方法
使用 synchronized 修饰的方法就叫同步方法。
同步锁： 对于非 static方法，同步锁就是 this。 对于 static方法，我们使用当前方法所在类的字节码对象（Apple.class）比如：单例懒加载设计模式（推荐使用饿汉模式）class Apple implements Runnable{ private int num = 50; @Override public void run() { for (int i = 0; i < 50; i++) { eat(); } } synchronized private void eat(){ if(num > 0){ try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "吃苹果" + num); num--; } }} class Apple implements Callable{ private int num = 50; @Override public Integer call() { eat(); return num; } synchronized private void eat() { for (int i = 0; i < 50; i++) { if (num > 0) { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "吃苹果" + num); num--; } } }}
3）Lock机制（使用 Lock 接口的 ReentrantLock 类对象）
在JDK1.5中新增了一个java.util.concurrent包来支持同步。
关键字synchronized实现的同步锁，是隐藏的，所以我们并不明确是在哪里加上了锁，在哪里释放了锁。为了更明确的控制从哪里开始锁，在哪里释放锁，JDK1.5提供了Lock。
Lock机制与使用synchronized方法和块具有相同的基本行为和语义，并且扩展了其能力，更能体现面向对象。
Lock是一个接口，我们真正用的是它的实现类ReentrantLock。
ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁 unlock() : 释放锁
class Apple implements Runnable{ private int num = 50; private final Lock lock = new ReentrantLock(); @Override public void run() { for (int i = 0; i < 50; i++) { eat(); } } private void eat(){ lock.lock(); // 获取锁，进入方法立马加锁 try { if(num > 0){ System.out.println(Thread.currentThread().getName() + "吃苹果" + num); Thread.sleep(10); num--; } } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); // 结束方法时，释放锁 } }} 
4）使用局部变量实现线程同步
如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。
ThreadLocal 类的常用方法：
ThreadLocal() : 创建一个线程本地变量
get() : 返回此线程局部变量的当前线程副本中的值 initialValue() : 返回此线程局部变量的当前线程的"初始值" set(T value) : 将此线程局部变量的当前线程副本中的值设置为value这里和上面是多个线程并发访问同一个资源，这里ThreadLocal处理每个线程都访问50
class Apple implements Callable{ //定义在这里的属性是所有线程共享的变量数据 private static ThreadLocal num = new ThreadLocal (){ @Override protected Integer initialValue() { return 50; } }; @Override public Integer call() { for (int i = 0; i < 50; i++) { if (num.get() > 0) { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "吃苹果" + num.get()); num.set(num.get()-1); } } return num.get(); }}
注意：ThreadLocal与其他同步机制
1）ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。
2）ThreadLocal并不能代替同步机制，两者面向的问题领域不同。
同步机制是为了同步多个线程对相同资源的并发访问，是多个线程之间进行通信，并且协同的有效方式；
ThreadLocal是为了隔离多个线程的数据共享，从而避免多个线程之间对共享资源的竞争，也就不需要对多个线程进行同步了。ThreadLocal采用以"空间换时间"的方法，其他同步机制采用以"时间换空间"的方式。
3）ThreadLocal适用的场景是，多个线程都需要使用一个变量，但这个变量的值不需要在各个线程间共享，各个线程都只使用自己的这个变量的值。这样的场景下，可以使用ThreadLocal。
3、synchronized 的好与坏
好处：保证了多线程并发访问时的同步操作，避免了线程的安全性问题。
坏处：使用 synchronized 的方法/代码块的性能比不使用要低一些。
建议：尽量减小 synchronized 的作用域。
线程执行同步代码块或者同步方法时，程序调用了Thread.sleep()、Thread.yield()方法来暂停当前线程执行，当前线程不会释放对同步监测器的锁定。
四、死锁产生
多线程通信的时候很容易造成死锁，死锁无法解决，只能避免，
1、造成死锁的原因一句话：
多线程之间交错执行，当当前线程拥有其他线程需要的资源（锁），当前线程等待其他线程已拥有的资源，两者都不放弃自己拥有的资源时，就会造成死锁。比如：当A线程等待由B线程持有的锁，而B线程正在等待A线程持有的锁时，此时发生死锁现象，JVM不检测也不试图避免这种情况，所以程序员必须保证不导致死锁。
注意：Thread类中过时的方法很容易导致死锁，所以已经被废弃了(因为存在线程安全问题)。
suspend()：使正在运行的线程放弃CPU,暂停运行.
resume()：是暂停的线程恢复运行.
void stop() ：结束当前线程
过时方法出现死锁情况：A线程获得对象锁，正在执行一个同步方法，如果B线程调用A线程的suspend方法，此时A线程暂停运行，此时A线程放弃CPU，但是不会放弃占用的锁。
2、避免死锁法则：
当多个线程都要访问共享的资源A，B，C时，保证每一个线程都按照相同的顺序去访问他们，比如都先访问A，接着B，最后C。
实例1、锁顺序死锁demo
public class DeakLockTest1 { public static void main(String[] args) { // 两个资源/锁 Object resourceA = new Object(); Object resourceB = new Object(); // 线程1 Thread threadA = new Thread("线程A") { @Override public void run() { synchronized (resourceA){ System.out.println(Thread.currentThread().getName() + "locked resourceA, 需要resourceB"); synchronized (resourceB){ System.out.println(Thread.currentThread().getName() + "locked resourceB， 结束"); } } } }; // 线程2 Thread threadB = new Thread("线程B") { @Override public void run() { synchronized (resourceB){ System.out.println(Thread.currentThread().getName() + "locked resourceB，需要resourceA"); synchronized (resourceA){ System.out.println(Thread.currentThread().getName() + "locked resourceA， 结束"); } } } }; // 启动线程 threadA.start(); threadB.start(); }} 
出现死锁分析：
线程A率先占有了resource1，继续运行时需要resource2，但此时resource2却被线程ThreadB占有了，
线程B率先占有了resource2，继续运行时需要resource1，但此时resource1却被线程ThreadA占有了，
线程A与线程B都不放弃自己拥有的资源时，都处于等待状态，谁也无法继续运行，即产生了死锁。
实例2、动态锁顺序死锁demo
public class DeakLockTest2 { public static void main(String[] args) { // 两个资源 Account a = new Account("A",1000); Account b = new Account("B",1000); // a 向 b 转账 TransferMoneyDemo abtransferMoneyDemo = new TransferMoneyDemo(a, b, 100); // b 向 a 转账 TransferMoneyDemo batransferMoneyDemo = new TransferMoneyDemo(b, a, 100); new Thread(abtransferMoneyDemo,"线程1ab").start(); new Thread(abtransferMoneyDemo,"线程2ab").start(); new Thread(batransferMoneyDemo,"线程3ba").start(); }}class TransferMoneyDemo implements Runnable{ private Account fromAccount; private Account toAccount; private double money; public TransferMoneyDemo(Account fromAccount, Account toAccount, double money){ this.fromAccount =fromAccount; this.toAccount = toAccount; this.money = money; } @Override public void run() { transferMoney(fromAccount,toAccount,money); } private void transferMoney(Account fromAccount, Account toAccount, double money) { synchronized (fromAccount) { System.out.println(Thread.currentThread().getName() + "得到锁" + fromAccount.getName()); synchronized (toAccount) { System.out.println(Thread.currentThread().getName() + "得到锁" + toAccount.getName()); if(fromAccount.getMoney() < money) { System.out.println("余额不足"); } else { // 进行转账 fromAccount.setMoney(fromAccount.getMoney()-money); toAccount.setMoney(toAccount.getMoney() + money); System.out.println("转账后：" + fromAccount.getName() + "有：" + fromAccount.getMoney()); System.out.println("转账后：" + toAccount.getName() + "有：" + toAccount.getMoney()); } } } }}class Account{ private String name; private double money; public Account(String name, double money) { this.name = name; this.money = money; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getMoney() { return money; } public void setMoney(double money) { this.money = money; }} 
出现死锁分析：
线程3从b向a账户转账，线程1从a向b账户转账，调用transferMoney()，都不放弃自己拥有的资源，即产生了死锁。
五、避免死锁的解决方法
1、固定加锁的顺序（针对锁顺序死锁）
线程之间交错执行发生死锁的原因是因为加锁顺序不一致而出现的，如果所有线程以固定的顺序来获得锁，那么程序中就不会出现锁顺序死锁问题。这里使用资源的 hashcode 来自定定义锁顺序。
实例1的避免方法：
public class DeakLockTest1 { public static void main(String[] args) { // 两个资源/锁 Object resourceA = new Object(); Object resourceB = new Object(); // 定义加锁顺序规则：如果hashCode值或者其他就先加resourceA int hashCodeA = System.identityHashCode(resourceA); int hashCodeB = System.identityHashCode(resourceB); Object otherLock = new Object(); // 线程1，先占有resourceA,再尝试着占有resourceB Thread threadA = new Thread("线程A") { @Override public void run() { if(hashCodeA > hashCodeB){ synchronized (resourceA){ System.out.println(Thread.currentThread().getName() + "locked resourceA, 需要resourceB"); synchronized (resourceB){ System.out.println(Thread.currentThread().getName() + "locked resourceB， 结束"); } } }else if(hashCodeA < hashCodeB){ synchronized (resourceB){ System.out.println(Thread.currentThread().getName() + "locked resourceB，需要resourceA"); synchronized (resourceA){ System.out.println(Thread.currentThread().getName() + "locked resourceA， 结束"); } } }else { synchronized (otherLock){ synchronized (resourceA){ System.out.println(Thread.currentThread().getName() + "locked resourceA, 需要resourceB"); synchronized (resourceB){ System.out.println(Thread.currentThread().getName() + "locked resourceB， 结束"); } } } } } }; // 线程2，先占有resourceB,再尝试着占有resourceA Thread threadB = new Thread("线程B") { @Override public void run() { if(hashCodeA > hashCodeB){ synchronized (resourceA){ System.out.println(Thread.currentThread().getName() + "locked resourceA, 需要resourceB"); synchronized (resourceB){ System.out.println(Thread.currentThread().getName() + "locked resourceB， 结束"); } } }else if(hashCodeA < hashCodeB){ synchronized (resourceB){ System.out.println(Thread.currentThread().getName() + "locked resourceB，需要resourceA"); synchronized (resourceA){ System.out.println(Thread.currentThread().getName() + "locked resourceA， 结束"); } } }else { synchronized (otherLock){ synchronized (resourceA){ System.out.println(Thread.currentThread().getName() + "locked resourceA, 需要resourceB"); synchronized (resourceB){ System.out.println(Thread.currentThread().getName() + "locked resourceB， 结束"); } } } } } }; // 启动线程 threadA.start(); threadB.start(); }} 实例2的避免方法：
public class DeakLockTest2 { public static void main(String[] args) { // 两个资源 Account a = new Account("A",1000); Account b = new Account("B",1000); // a 向 b 转账 TransferMoneyDemo abtransferMoneyDemo = new TransferMoneyDemo(a, b, 500); // b 向 a 转账 TransferMoneyDemo batransferMoneyDemo = new TransferMoneyDemo(b, a, 100); new Thread(abtransferMoneyDemo,"线程1ab").start(); new Thread(abtransferMoneyDemo,"线程2ab").start(); new Thread(batransferMoneyDemo,"线程3ba").start(); }}class TransferMoneyDemo implements Runnable{ private Account fromAccount; private Account toAccount; // 定义加锁顺序规则：如果hashCode值或者其他就先加fromAccount private double money; Object otherLock = new Object(); public TransferMoneyDemo(Account fromAccount, Account toAccount, double money){ this.fromAccount =fromAccount; this.toAccount = toAccount; this.money = money; } @Override public void run() { transferMoney(fromAccount,toAccount,money); } private void transferMoney(Account fromAccount, Account toAccount, double money) { int hashCodeA = System.identityHashCode(fromAccount); int hashCodeB = System.identityHashCode(toAccount); if(hashCodeA > hashCodeB){ synchronized (fromAccount) { System.out.println(Thread.currentThread().getName() + "得到锁" + fromAccount.getName()); synchronized (toAccount) { transferMoneyHandle(fromAccount, toAccount, money); } } }else if(hashCodeA < hashCodeB){ synchronized (toAccount) { System.out.println(Thread.currentThread().getName() + "得到锁" + fromAccount.getName()); synchronized (fromAccount) { transferMoneyHandle(fromAccount, toAccount, money); } } }else { synchronized (otherLock){ synchronized (fromAccount) { System.out.println(Thread.currentThread().getName() + "得到锁" + fromAccount.getName()); synchronized (toAccount) { transferMoneyHandle(fromAccount, toAccount, money); } } } } } private void transferMoneyHandle(Account fromAccount, Account toAccount, double money){ System.out.println(Thread.currentThread().getName() + "得到锁" + toAccount.getName()); if(fromAccount.getMoney() < money) { System.out.println("余额不足"); } else { // 进行转账 fromAccount.setMoney(fromAccount.getMoney()-money); toAccount.setMoney(toAccount.getMoney() + money); System.out.println("转账后：" + fromAccount.getName() + "有：" + fromAccount.getMoney()); System.out.println("转账后：" + toAccount.getName() + "有：" + toAccount.getMoney()); } }}class Account{ private String name; private double money; public Account(String name, double money) { this.name = name; this.money = money; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getMoney() { return money; } public void setMoney(double money) { this.money = money; }} 
2、开放调用（针对对象之间协作造成的死锁）
对象之间协作造成的死锁：主要是在调用某个方法时就需要持有锁（即同步方法的使用），并在其方法内部也调用了其他对象带锁的方法，这样就隐式有两个锁，这种方式也很容易就造成死锁。
避免死锁的方法：尽量减小 synchronized 的作用域。使用同步代码块最好仅被用于保护那些涉及共享资源的操作。
3、使用定时锁 - tryLock()（针对永久等待）
ReentrantLock尝试获取锁有返回值tryLock()
tryLock() 方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
tryLock(long time, TimeUnit unit)方法，在时间期限之内如果还拿不到锁，则返回false。否则返回true。
public class DeakLockTest3 { public static void main(String[] args) { final Lock lock = new ReentrantLock(); tryLockDemo tryLockDemo = new tryLockDemo(lock); new Thread(tryLockDemo,"线程1").start(); new Thread(tryLockDemo,"线程2").start(); new Thread(tryLockDemo,"线程3").start(); }}class tryLockDemo implements Runnable{ Lock lock; public tryLockDemo(Lock lock){ this.lock = lock; } @Override public void run() { if(lock.tryLock()){//尝试获取锁 try { System.out.println(Thread.currentThread().getName() + "获取到锁，处理业务！"); } catch (Exception e) { System.out.println(Thread.currentThread().getName() + "出错了！"); } finally { // 释放锁 lock.unlock(); } }else{ //获取不到锁 System.out.println(Thread.currentThread().getName() + "获取不到锁！"); } }} 
ends ~
转载地址：http://dncgn.baihongyu.com/