线程死锁状态

已于 2023-06-15 20:36:17 修改
阅读量63 收藏 1
点赞数
文章标签： java 开发语言 后端
于 2023-06-07 14:44:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77664771/article/details/131087024
版权

1.死锁以及如何避免死锁

如何避免：

1.进来不要使用锁的嵌套

2.不要使用锁，而使用安全类。java.util.concurrent下的类

3.设置锁的超时时间。Lock锁。到达指定时间没有获取锁，则不会等待该锁=

举例：冰冰和晨晨去吃饭，饭店规定只能一人一根筷子吃饭，为了完成吃饭，必须拥有一双筷子（例子随便举的，请勿较真）

 2.线程通信

 2.1案例：银行存钱和取钱，不能边取边存，要不只能存，要不只能取。

1.创建取钱的角色

package demo06;

public class TakeRunnable implements Runnable{
    //取钱的任务
    private BankCard bankCard;
    public TakeRunnable(BankCard card){bankCard=card;}
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            bankCard.take(1000);
        }
    }
}

 2.创建存钱的角色

package demo06;

public class SaveRunnable implements Runnable{
    //存钱的任务
    private BankCard bankCard;
    public SaveRunnable(BankCard card){bankCard=card;}
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            bankCard.save(1000);
        }
    }
}

3.创建银行卡

package demo06;


public class BankCard extends Object{ //objece类型
    private double balance;
    private boolean flag;//true表示有钱  false表示没钱


    public synchronized void save(double money) {
        if (flag) { //有钱，进入等待队列
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        balance = balance + money; //存的钱
        System.out.println(Thread.currentThread().getName()+"在卡中存了1000,卡中余额:"+balance+"元");
        flag = true;//标记有钱
        //唤醒等待队列的线程
        notify();
    }
    public synchronized void take(double money){
        if (flag==false){
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        balance = balance - money;//取钱
        System.out.println(Thread.currentThread().getName()+"从卡中取出1000,卡中余额:"+balance+"元");
        flag = false;
        //唤醒等待队列线程
        notify();
    }
}

4.创建测试类

package demo06;


public class Test06 {
    public static void main(String[] args) {
        BankCard bankCard = new BankCard();


        SaveRunnable save = new SaveRunnable(bankCard);
        TakeRunnable take = new TakeRunnable(bankCard);


        Thread t1 = new Thread(save, "我能挣钱");
        Thread t2 = new Thread(take, "最爱花钱");
        t1.start();
        t2.start();
    }
}

 2.2sleep和wait的区别

1.wait需要使用notify或notifyAll唤醒，而sleep到时间自动唤醒

2.wait来自于Object类中，sleep来自Thread类中

3.wait会是否锁资源，sleep不会释放锁资源

4.wait必须放在同步代码中，而sleep可以放在任意位置

 3.线程的状态

1.NEW : 新建状态 当new一个线程对象时进入入该状态

2.RUNNABLE ： 运行状态 调用完start并获取cpu时间片进入运行状态

3.BLOCKED ： 堵塞状态 当没有获取锁资源时

4.WAITING ： 当执行了wait方法时，该线程进入等待状态

5.TIMED_WAITING ： 当执行sleep方法时，进入该状态

6.TERMINATED ： 终止 当线程执行完毕或出现异常中断时

 

 4.线程池

 4.1线程池的原理：

 4.2创建线程池

 4.2.1固定长度的线程池

package demo07;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


/**
 * Executor:它是线程池的顶级接口。该接口中就存在一个方法。void execute(Runnable command);执行线程任务的方法
 * 1.shutdown():关闭线程池 ---当前线程池有还要任务，需要等任务完成后才会关闭
 * 2.shutdownNow():立刻关闭线程池
 * 3.isShutdown():是否属于关闭状态
 * 4.isTerminated():判断是否线程池终止
 * 5.submit(Callable<T> task):执行线程任务
 *   submit(Runnable task);
 * Executors:线程池的工厂类，该类可以获取线程池对象*/
public class Text07 {
    public static void main(String[] args) {
        //获取固定长度的线程池 -----阿里巴巴不建议使用Executors创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i=0;i<5;i++){
            executorService.execute(new Runnable(){
                @Override
                public void run(){
                    System.out.println(Thread.currentThread().getName()+"-----------");
                }
            });
        }
        executorService.shutdownNow();
    }
}

 4.2.2单一长度的线程池

package demo07;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


/**
 * Executor:它是线程池的顶级接口。该接口中就存在一个方法。void execute(Runnable command);执行线程任务的方法
 * 1.shutdown():关闭线程池 ---当前线程池有还要任务，需要等任务完成后才会关闭
 * 2.shutdownNow():立刻关闭线程池
 * 3.isShutdown():是否属于关闭状态
 * 4.isTerminated():判断是否线程池终止
 * 5.submit(Callable<T> task):执行线程任务
 *   submit(Runnable task);
 * Executors:线程池的工厂类，该类可以获取线程池对象*/
public class Text07 {
    public static void main(String[] args) {
        //创建单一线程池----池子中只有一个线程的对象  ---适合任务的有序执行
        //ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i=0;i<6;i++){
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"-----------");
                }
            });
        }
    }
}

 4.2.3可变线程池

package demo07;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Executor:它是线程池的顶级接口。该接口中就存在一个方法。void execute(Runnable command);执行线程任务的方法
 * 1.shutdown():关闭线程池 ---当前线程池有还要任务，需要等任务完成后才会关闭
 * 2.shutdownNow():立刻关闭线程池
 * 3.isShutdown():是否属于关闭状态
 * 4.isTerminated():判断是否线程池终止
 * 5.submit(Callable<T> task):执行线程任务
 *   submit(Runnable task);
 * Executors:线程池的工厂类，该类可以获取线程池对象*/
public class Text07 {
    public static void main(String[] args) {
        //可变线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i=0;i<6;i++){
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"-----------");
                }
            });
        }
    }
}

4.2.4延迟线程池

package demo07;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * Executor:它是线程池的顶级接口。该接口中就存在一个方法。void execute(Runnable command);执行线程任务的方法
 * 1.shutdown():关闭线程池 ---当前线程池有还要任务，需要等任务完成后才会关闭
 * 2.shutdownNow():立刻关闭线程池
 * 3.isShutdown():是否属于关闭状态
 * 4.isTerminated():判断是否线程池终止
 * 5.submit(Callable<T> task):执行线程任务
 *   submit(Runnable task);
 * Executors:线程池的工厂类，该类可以获取线程池对象*/
public class Text07 {
    public static void main(String[] args) {
        //延迟线程池
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        for (int i=0;i<6;i++){
            executorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("定时执行任务");
                }
            },10, TimeUnit.SECONDS);//定时时间10秒
        }
    }
}

4.2.5自定义线程池

package demo07;

import java.util.concurrent.*;

/**
 * Executor:它是线程池的顶级接口。该接口中就存在一个方法。void execute(Runnable command);执行线程任务的方法
 * 1.shutdown():关闭线程池 ---当前线程池有还要任务，需要等任务完成后才会关闭
 * 2.shutdownNow():立刻关闭线程池
 * 3.isShutdown():是否属于关闭状态
 * 4.isTerminated():判断是否线程池终止
 * 5.submit(Callable<T> task):执行线程任务
 *   submit(Runnable task);
 * Executors:线程池的工厂类，该类可以获取线程池对象*/
public class Text07 {
    public static void main(String[] args) {
        //建议使用自己的new线程池 ---1.没有无参构造函数 2.构造函数私有化
        BlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        /**线程池的参数
         * int corePoolSize,核心线程数
         * int maximumPoolSize,最大的个数
         * long keepAliveTime,等待时间长
         * TimeUnit unit,时间单位
         * BlockingQueue<Runnable> workQueue:等待队列
         * */
        ExecutorService executorService = new ThreadPoolExecutor(2,5,10,TimeUnit.SECONDS,blockingQueue);

        for (int i=0;i<5;i++){
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"---------------");
                }
            });
        }
    }
}

4.3callable线程任务

package demo08;

import java.util.concurrent.*;

public class test01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        My m = new My();
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<Double> submit = executorService.submit(m);
        System.out.println(submit.get());//抛出异常
    }
}
class My implements Callable<Double>{
    //求和
    @Override
    public Double call() throws Exception {
        double sum=0; //这里不能使用 int类型，因为是double类型的
        for (int i=1;i<=100;i++){
            sum+=i;
        }
        return sum;
    }
}
class My02 implements Runnable{
    @Override
    public void run() {

    }
}
//1.callable任务提有返回值，callable任务体抛出异常 callable是runnable补充

5.自动锁和手动锁的区别

1.synchronized自动上锁和解锁，而lock需要手动上锁和解锁

2.synchronized可以给代码块和方法上锁，而lock只能给代码块加锁

3.lock可以知道是否获取锁资源

 6.线程安全的集合

 7.总结：

这玩意真费脑子
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java线程同步-闭锁（CountDownLatch）
weixin_51389615的博客
07-05 216
Java线程同步-闭锁（CountDownLatch）
线程的状态，多线程带来的风险，synchronized关键字及死锁问题
申俏雅的博客
05-25 1214
去破坏死锁中的必要条件中的任意一个（除了互斥条件），给锁编号，然后制定一个固定的顺序（从小到大）来加锁，任意线程加多把锁的时候，都让线程遵循上述循序，此时循环等待自然破除
线程的死锁
雅俗共赏的博客
02-18 475
文章目录前言一、什么是死锁？二、死锁是怎样产生的？三、怎样实现一个死锁？四、死锁的排查和预防？总结 前言 什么是死锁？死锁是怎样产生的？怎么实现一个死锁？如何解决死锁？可能我们日常工作中很少用到这些相关内容，但是随着要求越来越高，这些东西不了解是不行的，下面对死锁做一个简单的记录。 一、什么是死锁？ 先看一下百度百科对死锁的定义： 死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这.
【＜线程锁死＞】
徐明晓的博客
08-05 232
【<线程锁死>】[1] 什么是线程锁死[2] 线程锁死分为哪两种[3] 活锁[3] 线程饥饿[5] 线程活性故障总结 [1] 什么是线程锁死 线程锁死是另一种常见的线程活性故障，与线程死锁不可以混为一谈。线程锁死的定义如下： 线程锁死是指等待线程由于唤醒其所需的条件永远无法成立，或者其他线程无法唤醒这个线程而一直处于非运行状态（线程并未终止）导致其任务 一直无法进展。 线程死锁和线程锁死的外部表现是一致的，即故障线程一直处于非运行状态使得其所执行的任务没有进展。但是锁死的产生条件和线程死锁不一样
多线程之死锁
weixin_40480299的博客
10-17 321
多线程之死锁 一、什么是死锁 当两个或两个以上正在执行的线程在同时抢夺资源，并且处于一种互相等待的状态，由于存在一种环路的锁依赖关系而永远等待下去，没有外界原因终止程序或者重启程序 它们将永远执行等待下去，称之为死锁。 经典的“哲学家进餐”的问题，很好的阐述了死锁的概念 5个哲学家坐在一起进餐，但是只有5支筷子（不是5双），并且每两个人中间都放有一支筷子，哲学家处于两种状态，要么思考，要么进餐，...
一分钟用睡前小故事图解Java线程之死锁
12-22
线程执行的六大状态一、故事引入二、死锁死锁的产生三、线程通信等待通知四、代码案例线程释放锁标记主线程通知MyThread线程主线程通知哪个线程？ 为了更好的理解死锁，读者可能需要了解线程安全相关的知识，主要是...
循环等待 死锁状态.rar_循环列表死锁
09-24
通过各线程的等待模拟死锁，使初学者对死锁有一定的了解
查找原始MySQL死锁ID
12-14
找到原始的锁ID，然后KILL掉一直持有的那个线程可以了， 但是众多线程，可怎么找到引起死锁的线程ID呢？ MySQL 发展到现在，已经非常强大了，这个问题很好解决。 直接从数据字典连查找。 　我们来演示下。 　...
Python多线程编程（五）：死锁的形成
12-25
前一篇文章Python：使用...此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。 由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源
查找MySQL线程中死锁的ID的方法
01-19
找到原始的锁ID，然后KILL掉一直持有的那个线程就可以了， 但是众多线程，可怎么找到引起死锁的线程ID呢？ MySQL 发展到现在，已经非常强大了，这个问题很好解决。 直接从数据字典连查找。 我们来演示下。 线程A，...
阻塞的三种状态以及死锁
Alex十年的博客
08-21 5405
1、一个线程占有了一个对象锁之后，CPU资源仍然能够被抢走。 2、当其他线程抢到了CPU资源之后，发现获取不到对象锁，就会进入阻塞状态，此时进入的是由于获取不到对象锁而阻塞的阻塞队列中。 3、当占有锁的线程释放锁的时候，就会立即唤醒等待锁的其他线程（在因获取不到对象锁而阻塞的阻塞队列中的线程）。 上面所说的释放锁的时候，包括了所有释放锁的情形： a、线程退出同步块 synchronized（obj...
Java中线程的状态、同步锁以及死锁详解
Invincible_Y的博客
02-06 858
线程的状态线程的六种状态 1.新建状态(new 线程对象) 2.运行状态(调用start方法) 3.受阻塞状态(等待CPU的执行资源) 4.休眠状态(调用了sleep(时间)方法) 5.等待状态(调用了wait方法) 6.死亡状态(run执行完毕)匿名内部类线程的第三种创建方式: 匿名内部类方式:相当于创建了一个该类的子类对象 new
java线程状态——死锁
裴珏的专栏
02-14 1853
参考： java 线程状态 java 线程状态——情况续说 java线程状态——java线程状态图 死锁，概念有很多，可以google 现在列出死锁的模拟代码和jstack的输出 一方面是理解死锁，一方面是学习jstack找出死锁，进行代码调优 import java.util.concurrent.TimeUnit; public class e {
day18【死锁、线程状态、等待与唤醒、Lambda】
weixin_43525993的博客
06-27 291
今日内容 死锁 线程状态 等待与唤醒 教学目标 能够描述死锁产生的原因 能够说出线程6个状态的名称 能够理解等待唤醒案例 第一章 死锁 1. 什么是死锁 死锁：是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待的现象。 死锁在开发中，也会遇到，当线程进入到死锁状态时，程序中线程就会一直处于等待状态。 死锁的发生： 举例1： 我请柳岩吃饭（麻辣烫） 我点了一份。上了一双筷子 我：一支 柳岩：一支 我和柳岩就相当于两个线程，而麻辣烫相当于共享资源，两个人都没办法吃，都在等待看着
多线程(五)线程的5种状态以及死锁
Felix的小黑板
09-25 650
–阻塞 –I/O: 可能线程在进行一个大数据的I/O操作, 导致程序看上去假死,导致的阻塞 –sleep(): 线程处于休眠状态 –lock: 等待锁资源的时候 –yield: 主动将CPU时间片释放 –死锁案例 package com.ygq.thread; /** * @author ：GQ.Yin * @date ：Created in 2019/7/21 20:46 ...
JVM的线程状态及如何排查死锁原因
u014484649的专栏
05-28 8423
1、TIMED_WAITING 2、waiting 3、blocked 4、runnable
jar包增量更新分析
junlaiyan的专栏
05-16 285
借助jdeps分析出jar包的增量文件
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
最新发布
qq_29022265的博客
05-19 1053
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
jstack查看线程死锁
09-06
当使用jstack命令查看线程死锁时，可以根据输出结果来分析。通常，jstack会给出线程之间的相互依赖关系和等待情况。例如，根据输出结果，可以发现某个线程在等待另一个线程持有的锁，而同时另一个线程又在等待该线程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值