Java 进程/线程与线程同步/死锁

左手的ㄟ右手 2021-11-27 05:12 480阅读 0赞

## 一、进程与线程概念 ##

**1、并发和并行是即相似又有区别：**

**并发：指两个或多个事件在同一时间段内发生。**

**  并行：指两个或多个事件在同一时刻点发生。**

在操作系统中，在多道程序环境下，**并发性**是指在一段时间内宏观上有多个程序在同时运行，但在单CPU系统中，每一时刻却仅能有一道程序执行（时间片即CPU分配给各个程序的时间），故微观上这些程序只能是分时地交替执行。

若计算机系统中有多个CPU，则这些可以并发执行的程序便可被分配到多个处理器上，实现多任务并行执行，即利用每个处理器来处理一个可并发执行的程序，这样，多个程序便可以同时执行，因为是微观的，所以大家在使用电脑的时候感觉就是多个程序是同时执行的。

“多核处理器”电脑可以同时并行地处理多个程序，从而提高了电脑的运行效率。

单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。

同理，线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，**即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程**，我们把这种情况称之为**线程调度**。

**2、进程与线程**

进程：是指一个内存中运行中的应用程序。每个进程都有自己独立的一块内存空间，一个应用程序可以同时启动多个进程。比如在Windows系统中，一个运行的xxx.exe就是一个进程。

线程：是指进程中的一个执行任务(控制单元)，一个进程可以同时并发运行多个线程；**线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。**

一个进程至少有一个线程，为了提高效率，可以在一个进程中开启多个执行任务,即多线程。如：多线程下载软件。

多进程：操作系统中同时运行的多个程序。

多线程：在同一个进程中同时运行的多个执行任务。

我们查看Windows环境下的任务管理器：

在操作系统中允许多个任务，每一个任务就是一个进程，每一个进程也可以同时执行多个任务，每一个任务就是线程。

![20190724111432715.png][]

**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);
            }
        }
    }

![20190724113726969.png][]

**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<Integer> 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<Integer> {
        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;
        }
    }

![20200601202806135.png][]

## 三、线程同步 ##

吃苹果比赛：分析继承方法与实现方式的区别

**继承方式：**

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--;
                }
            }
        }
    }

![20190725211011858.png][]        ![20190725212915932.png][]

**实现方式：**

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<Integer> futureTask1 = new FutureTask<>(apple);
            FutureTask<Integer> futureTask2 = new FutureTask<>(apple);
            FutureTask<Integer> 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<Integer> {
        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;
        }
    }

![20200601204148804.png][]

**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<Integer> {
        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--;
                }
            }
        }
    }

![2020060121091984.png][]

### **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(); // 结束方法时，释放锁
            }
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70][]

### 4）使用局部变量实现线程同步  ###

如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

**ThreadLocal 类的常用方法：**

ThreadLocal() : 创建一个线程本地变量   
    get() : 返回此线程局部变量的当前线程副本中的值   
    initialValue() : 返回此线程局部变量的当前线程的"初始值"   
    set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

这里和上面是多个线程并发访问同一个资源，这里ThreadLocal处理每个线程都访问50

class Apple implements Callable<Integer> {
    
        //定义在这里的属性是所有线程共享的变量数据
        private static ThreadLocal<Integer>  num = new ThreadLocal<Integer>(){
            @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();
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1][]

**注意：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();
        }
    }

![20200613125333975.png][]

出现死锁分析：

线程A率先占有了resource1，继续运行时需要resource2，但此时resource2却被线程ThreadB占有了，

线程B率先占有了resource2，继续运行时需要resource1，但此时resource1却被线程ThreadA占有了，

线程A与线程B都不放弃自己拥有的资源时，都处于等待状态，谁也无法继续运行，即产生了死锁。

**实例2、动态锁顺序死锁demo**

![20200613125920537.png][]

出现死锁分析：

线程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;
        }
    
    }

![20200613130925663.png][]

**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() + "获取不到锁！");
            }
        }
    }

![20200613133401563.png][]

ends ~

[20190724111432715.png]: /images/20211126/0d08213056dd405491cca2d568e2b96a.png
[20190724113726969.png]: /images/20211126/e8fadd6d1013432a8ea1868c51a47351.png
[20200601202806135.png]: /images/20211126/8cce871971674d4aa466ef9456eb9eb8.png
[20190725211011858.png]: https://img-blog.csdnimg.cn/20190725211011858.png
[20190725212915932.png]: /images/20211126/443527eff9cf4ad6aa506c04f1a2f55f.png
[20200601204148804.png]: /images/20211126/ba941d19fced44ba9ab92373018fc29d.png
[2020060121091984.png]: /images/20211126/578a4b623671474883f028b3c1db73c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70]: /images/20211126/6a9b67e7ff704874bc4caea2659a939c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1]: /images/20211126/bc44567687fd436ca9b77fa6b6b44cf0.png
[20200613125333975.png]: /images/20211126/c26c27e5b0c84a828303391a3cb6e269.png
[20200613125920537.png]: /images/20211126/58dd6bff72504124af7d9671cc732014.png
[20200613130925663.png]: /images/20211126/71197cc104784e618661fbc3a29e3f44.png
[20200613133401563.png]: /images/20211126/0a6359b7aa804f8a8dacc87d2c125662.png