线程的活跃性分析

1、死锁

有这样的情况:一个线程需要同时获取多把锁,这是就容易发生死锁

t1线程获取了A对象锁,接下来想要获取B对象的锁

t2线程获取了B对象锁,接下来想要获取A对象的锁

package com.sharing_model.more_lock;

import javax.crypto.spec.IvParameterSpec;

/**
 * 死锁:
 * t1线程获取了A对象锁,接下来想要获取B对象的锁
 * t2线程获取了B对象锁,接下来想要获取A对象的锁
 */
public class DeadLock {
    public static void main(String[] args) {
        Object A = new Object();
        Object B = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (A) {
                System.out.println("lock A");
                try {
                    Thread.sleep(1000);
                    synchronized (B) {
                        System.out.println("lock B");
                        System.out.println("操作。。。");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });

        Thread t2 = new Thread(() -> {
            synchronized (B) {
                try {
                    System.out.println("lock B");
                    Thread.sleep(500);
                    synchronized (A) {
                        System.out.println("lock A");
                        System.out.println("操作");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });


        t1.start();
        t2.start();
    }
}

2、死锁检测

  • jps + jstack

  • jconsole
    在这里插入图片描述

3、哲学家就餐问题

在这里插入图片描述

package com.sharing_model.more_lock;

/**
 * 哲学家就餐问题
 */
public class PhilosopherEatFood {
    public static void main(String[] args) {
        Chopstick c1 = new Chopstick("1");
        Chopstick c2 = new Chopstick("2");
        Chopstick c3 = new Chopstick("3");
        Chopstick c4 = new Chopstick("4");
        Chopstick c5 = new Chopstick("5");

        new Philosopher("苏格拉底", c1, c2).start();
        new Philosopher("柏拉图", c2, c3).start();
        new Philosopher("亚里士多德", c3, c4).start();
        new Philosopher("赫拉克利特", c4, c5).start();
        new Philosopher("阿基米德", c5, c1).start();
    }

}

class Philosopher extends Thread {
    String name;
    Chopstick left;
    Chopstick right;

    public Philosopher(String name, Chopstick left, Chopstick right) {
        this.name = name;
        this.left = left;
        this.right = right;
    }

    @Override
    public void run() {
        while (true) {
            //尝试获得左手筷子
            synchronized (left) {
                //尝试获得右手筷子
                synchronized (right) {
                    eat();
                }
            }
        }
    }

    private void eat()  {
        System.out.println(name + "eating...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Chopstick {

    public Chopstick(String s) {

    }
}

执行不一会,就执行不下去了

通过jconsole可以发现

4、活锁

活锁出现在两个线程相互改变对方的结束条件,最后谁也无法结束,例如

/**
 * 活锁
 */
public class LiveLock {
    static volatile int count = 10;
    static final Object Lock = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            //期望减到0退出
            while (count > 0) {
                try {
                    Thread.sleep(200);
                    count--;
                    System.out.println("t1:" + count);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1").start();

        new Thread(() -> {
            //期望超过20退出循环
            while (count < 20) {
                try {
                    Thread.sleep(200);
                    count++;
                    System.out.println("t2:" + count);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

5、饥饿

很多教程把饥饿定义为,一个线程由于优先级太低,始终得不到CPU调度执行,也不进行结束

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值