多线程与死锁

多线程 专栏收录该内容
2 篇文章 0 订阅

Java多线程开发中,为了避免多个线程对同一份数据的操作,我们需要对我们的线程做加锁的操作,只要加锁,就必然存在锁竞争的问题,如果锁竞争的问题处理不当就会出现死锁问题。死锁会让程序一直卡住,程序不再往下执行。我们只能通过中止并重启的方式来让程序重新执行。

这是我们非常不愿意看到的一种现象,我们要尽可能避免死锁的情况发生!

造成死锁的原因可以概括成三句话:

  • 当前线程拥有其他线程需要的资源
  • 当前线程等待其他线程已拥有的资源
  • 都不放弃自己拥有的资源

动态顺序锁死锁

动态顺序锁导致死锁是最常见的死锁,例如我们在2个线程对2个账户进行转账操作,我们需要先锁定汇账账户减钱,然后再锁定入款账户加钱,一般来讲这个逻辑顺序是没有问题的,但是如果这2个线程并发同时处理,就会产生死锁。

public class DeadLock {


    public static void main(String[] args) {
        Account accountA = new Account(1L,"A",10000L);
        Account accountB = new Account(1L,"B",10000L);

        Thread a = new Thread(()->{
            try {
                transferMoney(accountA,accountB,100L);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread b = new Thread(()->{
            try {
                transferMoney(accountB,accountA,100L);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        a.start();
        b.start();

        while (true){
            try {
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }

    // 转账
    public static void transferMoney(Account fromAccount,
                                     Account toAccount,
                                     Long amount) throws Exception {
        // 锁定汇账账户
        synchronized (fromAccount) {
            System.out.println(Thread.currentThread().getName()+"获取账户"+fromAccount.getName()+"锁");
            // 锁定来账账户
            synchronized (toAccount) {
                System.out.println(Thread.currentThread().getName()+"获取账户"+toAccount.getName()+"锁");
                // 判余额是否大于0
                if (fromAccount.getAmount().compareTo(amount) < 0) {
                    throw new Exception("No enough money");
                } else {
                    // 汇账账户减钱
                    fromAccount.debit(amount);
                    // 来账账户增钱
                    toAccount.credit(amount);

                    System.out.println(Thread.currentThread().getName()+"完成转账");

                }
            }
        }
    }
}

@Data
class Account{

    private Long id;

    private String name;

    private Long amount;

    public Account(){}

    public Account(long id,String name, long amount){
        this.id = id;
        this.name = name;
        this.amount = amount;
    }


    public void debit(Long amount) {
        this.amount -= amount;
    }

    public void credit(Long amount) {
        this.amount += amount;
    }

}

程序执行结果如下:

Thread-1获取账户B锁
Thread-0获取账户A锁

我们会发现我们的转账一直无法完成交易,程序一直卡住,程序不再往下执行。即发生了死锁。

Jconsole 查看死锁

Jconsole是JDK自带的图形化界面工具,使用JDK给我们的的工具JConsole,我们可以直接查看Java进程中出现的死锁。
控制台输入jconsole启动图形化界面工具

jconsole

在这里插入图片描述
选择连接我们的本地调试进程
在这里插入图片描述
选择线程栏,我们会看到我们的正在运存的测试代码的3个线程
在这里插入图片描述
选择我们的线程,检测死锁
在这里插入图片描述
在这里插入图片描述
很明显看出,Thread-0需要的资源被Thread-1占用,Thread-0被阻塞。

固定锁顺序避免死锁

针对动态锁顺序导致的死锁,我们可以通过固定加锁的顺序来解决

public class FixedOrderDeadLock {

    public static void main(String[] args) {
        Account accountA = new Account(1L,"A",10000L);
        Account accountB = new Account(1L,"B",10000L);

        Thread a = new Thread(()->{
            try {
                transferMoney(accountA,accountB,100L);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread b = new Thread(()->{
            try {
                transferMoney(accountB,accountA,100L);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        a.start();
        b.start();

        while (true){
            try {
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    public static void transferMoney(final Account fromAcct,
                              final Account toAcct,
                              final Long amount)
            throws Exception {
        class Helper {
            public void transfer() throws Exception {
                if (fromAcct.getAmount().compareTo(amount) < 0)
                    throw new Exception("No enough money");
                else {
                    fromAcct.debit(amount);
                    toAcct.credit(amount);

                    System.out.println(Thread.currentThread().getName()+"完成转账");
                }
            }
        }
        // 得到锁的hash值
        int fromHash = System.identityHashCode(fromAcct);
        int toHash = System.identityHashCode(toAcct);

        // 根据hash值来上锁  不管是汇款账户还是入款账户,总是Hash值小的先锁,则对象锁的顺序是固定的
        if (fromHash < toHash) {
            synchronized (fromAcct) {
                System.out.println(Thread.currentThread().getName()+"获取账户"+fromAcct.getName()+"锁");
                synchronized (toAcct) {
                    System.out.println(Thread.currentThread().getName()+"获取账户"+toAcct.getName()+"锁");
                    new Helper().transfer();
                }
            }

        } else if (fromHash > toHash) {// 根据hash值来上锁
            synchronized (toAcct) {
                System.out.println(Thread.currentThread().getName()+"获取账户"+toAcct.getName()+"锁");
                synchronized (fromAcct) {
                    System.out.println(Thread.currentThread().getName()+"获取账户"+fromAcct.getName()+"锁");
                    new Helper().transfer();
                }
            }
        } else {//如果是同对象,由于 synchronized 已经支持可重入锁,所以并发的同账户互相转账不会产生死锁,锁顺序不产生影响
            synchronized (fromAcct) {
                synchronized (toAcct) {
                    new Helper().transfer();
                }
            }
        }
    }
}

程序执行结果

Thread-0获取账户A锁
Thread-0获取账户B锁
Thread-0完成转账
Thread-1获取账户A锁
Thread-1获取账户B锁
Thread-1完成转账

如结果所示,并不会产生死锁。

协作锁之间发生死锁

除了动态顺序锁发生死锁的情况,还存在一些死锁的情况,但是不是顺序锁那么简单可以被发现。因为有可能并不是在同一个方法中显示请求两个锁,而是嵌套另一个方法去获取第二个锁。这就是隐式获取两个锁(对象之间协作)。

例如,ProductProducer生产者会不断的生产商品并且向仓库注册商品,ProductDepository商品仓库会不断的处理注册到仓库的商品加工,生成编号。

public class CooperatingDeadlock {

    public static void main(String[] args) {
        ProductProducer productProducer = new ProductProducer();
        ProductDepository productDepository = new ProductDepository();
        productProducer.setProductDepository(productDepository);

        productProducer.start();
        productDepository.start();

        while (true){
            try {
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

}

class ProductProducer extends Thread{

    public void setProductDepository(ProductDepository productDepository) {
        this.productDepository = productDepository;
    }

    private ProductDepository productDepository;

    @Override
    public void run(){
        produce();
    }

    // produce()需要ProductProducer对象锁
    private synchronized void produce(){
        do {
            Product p = new Product(this);
            System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁,生产商品,并向仓库注册");
            this.productDepository.addAvailable(p);

            try{
                Thread.sleep(100);
            }catch (Exception e){
                e.printStackTrace();
            }
        }while (true);
    }

    public synchronized void handle(Product product) {
        System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁,加工商品,生成编号");
        product.setNo(System.currentTimeMillis());
    }
}

class ProductDepository extends Thread{

    public ProductDepository(){
        availableProductList = new ArrayList<>();
    }

    private ArrayList<Product> availableProductList;

    @Override
    public void run(){
        handleAvailable();
    }

    public synchronized void addAvailable(Product product) {
        System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁,注册到仓库");
        availableProductList.add(product);
    }

    // handleAvailable()需要ProductDepository对象锁
    public synchronized void handleAvailable() {
        System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁,将注册的商品进行加工");
        do{
            for (Product t : availableProductList)
                // 调用handle()需要ProductProducer对象锁
                t.handle();

            availableProductList.clear();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }while (true);
    }

}

class Product{
    private  ProductProducer productProducer;

    public Product(){}

    public void setNo(Long no) {
        this.no = no;
    }

    private Long no;

    public Product(ProductProducer productProducer){
        this.productProducer = productProducer;
    }

    public void handle(){
        this.productProducer.handle(this);
    }
}

此时我们执行程序:

Thread-0获取com.pubutech.multithread.example.deadlock.ProductProducer对象锁,生产商品,并向仓库注册
Thread-1获取com.pubutech.multithread.example.deadlock.ProductDepository对象锁,将注册的商品进行加工

很显然,我们的程序将陷入死锁无法继续执行下去。

开放调用避免死锁

在协作对象之间发生死锁的例子中,主要是因为在调用某个方法时就需要持有锁,并且在方法内部也调用了其他带锁的方法!

如果在调用某个方法时不再持有锁,而改为同步代码块仅用于保护那些涉及共享状态的操作!那么这种调用被称为开放调用!

我们可以这样来改造:

public class OpenMethodCooperationDeadLock {
    public static void main(String[] args) {
        OpenMethodProductProducer productProducer = new OpenMethodProductProducer();
        OpenMethodProductDepository productDepository = new OpenMethodProductDepository();
        productProducer.setProductDepository(productDepository);

        productProducer.start();
        productDepository.start();

        while (true){
            try {
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

}

class OpenMethodProductProducer extends Thread{

    public void setProductDepository(OpenMethodProductDepository productDepository) {
        this.productDepository = productDepository;
    }

    private OpenMethodProductDepository productDepository;

    @Override
    public void run(){
        produce();
    }

    private void produce(){
        do {
            OpenMethodProduct p = null;
            //需要ProductProducer对象锁,但是缩小锁的范围,不会同时去获取两个锁
            synchronized (this){
                System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁,生产商品,并向仓库注册");
                p = new OpenMethodProduct(this);
            }

            if (null != p){
                System.out.println(Thread.currentThread().getName()+"向仓库注册");
                this.productDepository.addAvailable(p);
            }

            try{
                Thread.sleep(100);
            }catch (Exception e){
                e.printStackTrace();
            }
        }while (true);
    }

    public synchronized void handle(OpenMethodProduct product) {
        System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁,加工商品,生成编号");
        product.setNo(System.currentTimeMillis());
    }
}

class OpenMethodProductDepository extends Thread{

    public OpenMethodProductDepository(){
        availableProductList = new ArrayList<>();
    }

    private ArrayList<OpenMethodProduct> availableProductList;

    @Override
    public void run(){
        handleAvailable();
    }

    public synchronized void addAvailable(OpenMethodProduct product) {
        System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁,注册到仓库");
        availableProductList.add(product);
    }

    public void handleAvailable() {
        do{
            ArrayList<OpenMethodProduct> availableProductListCopy;
            //需要ProductDepository对象锁,但是缩小锁的范围,不会同时去获取两个锁
            synchronized (this){
                System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁,准备将注册的商品进行加工");
                availableProductListCopy = new ArrayList<>(availableProductList);
                availableProductList.clear();
            }

            for (OpenMethodProduct t : availableProductListCopy)
                // 调用handle()需要ProductProducer对象锁
                t.handle();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }while (true);
    }

}

class OpenMethodProduct{
    private  OpenMethodProductProducer productProducer;

    public OpenMethodProduct(){}

    public void setNo(Long no) {
        this.no = no;
    }

    private Long no;

    public OpenMethodProduct(OpenMethodProductProducer productProducer){
        this.productProducer = productProducer;
    }

    public void handle(){
        this.productProducer.handle(this);
    }
}

程序执行结果如下,将会不断的协作下去直至我们终端程序而不会产生死锁

Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,生产商品,并向仓库注册
Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,准备将注册的商品进行加工
Thread-0向仓库注册
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,注册到仓库
Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,准备将注册的商品进行加工
Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,加工商品,生成编号
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,生产商品,并向仓库注册
Thread-0向仓库注册
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,注册到仓库
Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,准备将注册的商品进行加工
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,生产商品,并向仓库注册
Thread-0向仓库注册
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,注册到仓库
Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,加工商品,生成编号
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,生产商品,并向仓库注册
Thread-0向仓库注册
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,注册到仓库
Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,准备将注册的商品进行加工
Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,加工商品,生成编号
Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,加工商品,生成编号
Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,准备将注册的商品进行加工
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,生产商品,并向仓库注册
Thread-0向仓库注册
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,注册到仓库
Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,准备将注册的商品进行加工
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,生产商品,并向仓库注册
Thread-0向仓库注册
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,注册到仓库
Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,加工商品,生成编号
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁,生产商品,并向仓库注册
Thread-0向仓库注册
Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁,注册到仓库

RetreenLock锁超时解决死锁

synchronized 关键字的锁是由Java虚拟机实现的,它无法显示获取锁超时,但是Java5以后Java RetreenLock提供了tryLock()方法来实现获取锁超时,我们在获取锁时可以使用tryLock()方法。当等待超过时限的时候,tryLock()不会一直等待,而是返回错误信息。

  • 1
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

相关推荐
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值