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

最新推荐文章于 2021-02-21 07:42:54 发布

Charge8

最新推荐文章于 2021-02-21 07:42:54 发布

阅读量359

点赞数

分类专栏： # 并发编程文章标签：进程/线程与线程同步/死锁

本文链接：https://blog.csdn.net/qq_42402854/article/details/97112872

版权

并发编程专栏收录该内容

9 篇文章 3 订阅

订阅专栏

一、进程与线程概念

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对象，即将 Callable实现类作为参数传递给 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;
    }
}

本质上 Java中实现线程可以理解只有一种方式，都是通过 new Thread()创建线程，调用Thread#start启动线程，最终都会调用 Thread#run方法。

三、线程同步

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

继承方式：

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

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

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

注意：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 ~

Charge8

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 进程/线程与线程同步/死锁

一、进程与线程概念1、并发和并行是即相似又有区别：并发：指两个或多个事件在同一时间段内发生。并行：指两个或多个事件在同一时刻点发生。在操作系统中，在多道程序环境下，并发性是指在一段时间内宏观上有多个程序在同时运行，但在单CPU系统中，每一时刻却仅能有一道程序执行（时间片即CPU分配给各个程序的时间），故微观上这些程序只能是分时地交替执...
复制链接

扫一扫

专栏目录