Java中如何避免死锁&线程通信&线程池的相关总结

已于 2023-06-05 19:56:11 修改
阅读量413 收藏 1
点赞数 1
文章标签： java jvm 开发语言
于 2023-06-05 19:55:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhl15736773842/article/details/131047134
版权

目录

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

2、线程通信

2.1 等待：

2.2 通知：

2.3 sleep和wait的区别

2.4 线程的状态

3、线程池

3.1 什么是线程池

3.2  问题

3.3 线程池的优点：

3.4 线程池的原理

3.5 创建线程池

3.6 实现Callable接口重写run方法

3.7 Lock锁

4、总结

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

        死锁：

  • 当第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁。
  • 一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，由此可能造成死锁。

案例：A和B同时使用画板和画笔这两把锁，如果使用锁嵌套就会造成死锁问题。

 如何避免：

1、尽量不要使用锁嵌套

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

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

2、线程通信

2.1 等待：

  • public final void wati()
  • public final void wati(long timeout)
  • 必须在对obj加锁的同步代码块中。在一个线程中，调用obj.wait()时，此线程会释放其拥有的所有标记。同时此线程阻塞在o的等待队列中。释放锁，进入等待队列。

2.2 通知：

  • public final void notify()    ---唤醒队列中的其中一个，随机的。
  • public final void notifyAll()   ----唤醒队列中的所有等待线程。

案例：银行卡一存一取的实现

public class BankCard {
    private double blance;
    private boolean flag;//true代表有钱，false代表没钱

    public synchronized void save(double money){
        if (flag){//有钱进入等待队列
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有钱就让余额加上存的钱
        blance=blance+money;
        System.out.println(Thread.currentThread().getName()+"存了"+money);
        flag=true;
        //唤醒等待队列中的线程
        notify();
    }

    public synchronized void take(double money){
        if (flag==false){//没钱进入等待队列
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有钱就让余额减去取出的钱
        blance=blance-money;
        System.out.println(Thread.currentThread().getName()+"取了"+money);
        flag=false;
        //唤醒等待队列中的线程
        notify();
    }

//线程一
public class SaveRunnable implements Runnable{
    private BankCard bankCard;
    public SaveRunnable(BankCard card){
        bankCard=card;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            bankCard.save(1000);
        }
    }
}

//线程二
public class TakeRunnable implements Runnable{
    private BankCard bankCard;
    public TakeRunnable(BankCard card){
        bankCard=card;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            bankCard.take(1000);
        }
    }
}

//测试
public class Test {
    public static void main(String[] args) {
        BankCard bankCard = new BankCard();
        SaveRunnable save = new SaveRunnable(bankCard);
        TakeRunnable take = new TakeRunnable(bankCard);

        //创建线程
        Thread thread1 = new Thread(save,"A");
        Thread thread2 = new Thread(take,"B");

        //开启线程
        thread1.start();
        thread2.start();

    }
}

2.3 sleep和wait的区别

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

2、wait来自于Object类中，sleep来自Thread类中。

3、wait会释放锁资源，sleep不会释放锁资源

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

2.4 线程的状态

  • NEW：新建状态。当new一个线程对象进入该状态。
  • RUNNABLE：运行状态。调用完start并获取cpu时间片进入运行状态。
  • BLOCKED：堵塞状态。当没有获取锁资源时。
  • WAITING：当执行了wait方法时，该线程进入等待状态。
  • TIMED_WAITING：当执行sleep方法时，进入该状态。
  • TERMINATED：终止状态。当线程执行完毕或出现异常中断。

3、线程池

3.1 什么是线程池

线程池是一种利用池化技术思想来实现的线程管理技术，主要是为了复用线程、便利地管理线程和任务、并将线程的创建和任务的执行解耦开来。我们可以创建线程池来复用已经创建的线程来降低频繁创建和销毁线程所带来的资源消耗。在JAVA中主要是使用ThreadPoolExecutor类来创建线程池，并且JDK中也提供了Executors工厂类来创建线程池（不推荐使用）。

3.2  问题

  • 线程是宝贵的内存资源，单个线程约占1MB空间，过多分配易造成内存溢出。
  • 频繁的创建及销毁线程会增加虚拟机回收频率、资源开销、造成性能下降。

3.3 线程池的优点：

  • 线程容器，可设定线程分配的数量上限。
  • 将预先创建的线程对象存入池中，并重用线程池中的线程对象。
  • 避免频繁的创建和销毁。

3.4 线程池的原理

 将任务提交给线程池，由线程池分配线程、运行任务，并在当前任务结束后复用线程。

3.5 创建线程池

常用的线程池接口和类（所在包java.util.concurrent）：

  • Executor：线程池的顶级接口。
  • ExecutorService：线程池接口，可通过submit（Runnable task）、 execute（Runnable command）提交任务代码。
  • Executors工厂类：通过此类可以获得一个线程池。
  • 通过newFixedThreadPool（int nThreads） 获取固定数量的线程池。参数：指定线程池中线程的数量。
  • 通过newSingleThreadExecutor();//创建单一线程池，池子中只有一个线程对象。---适合任务的有序执行。
  • 通过newCachedThreadPool（）获得动态数量的线程池，如不够则创建新的，没有上限。

———————————————————————————————————————————

Executor：它是线程池的顶级接口。该接口中就存在一个方法。void execute（Runnable command）；执行线程任务的方法。

  ExecutorService：它是Executor接口中的子接口。

  1. shutdown（）:关闭线程池---当前线程池要还有任务，需要等待任务完成后才会关闭。
  2. shutdownNow():立刻关闭线程池，不管是否还有任务未完成。
  3. isShutdown():是否属于关闭状态。
  4. isTerminated（）：判断是否线程池终止了。
  5. submit(Callable<T> task):执行线程任务。

        submit(Runnable task)

Executors：它是线程池的工厂类，该类可以获取线程池对象。

(1)通过newFixedThreadPool（int nThreads）获取固定数量的线程池。

public class Test {
    public static void main(String[] args) {
        //获取固定长度的线程池，----阿里巴巴不建议使用Executors创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);

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

(2)通过newSingleThreadExecutor() ------创建单一线程池，池子中只有一个线程对象。---适合任务的有序执行。

public class Test {
    public static void main(String[] args) {
        //创建单一线程池，池子中只有一个线程对象。---适合任务的有序执行。
        ExecutorService executorService = Executors.newSingleThreadExecutor();

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

(3)通过newCachedThreadPool()------可变线程池

public class Test {
    public static void main(String[] args) {
        //可变线程池
        ExecutorService executorService = Executors.newCachedThreadPool();

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

(4)通过newScheduledThreadPool()------延迟线程池

public class Test {
    public static void main(String[] args) {
        //延迟线程池
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);

        for (int i = 0; i < 2; i++) {
            executorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("定时执行任务");
                }
            },10, TimeUnit.SECONDS);
        }
/*        executorService.shutdownNow();*/
    }
}

(5)通过ExecutorService接口中的ThreadPoolExecutor实现类创建线程池------推荐使用

//建议使用自己new线程池 ----(1)没有无参构造函数  (2)构造函数私有化
//                              int corePoolSize, 核心线程数
//                              int maximumPoolSize,最大线程数
//                              long keepAliveTime,等待时间长
//                              TimeUnit unit,实践单位
//                              BlockingQueue<Runnable> workQueue 等待队列
public class Test2 {
    public static void main(String[] args) {
        BlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        //建议使用自己new线程池 ----(1)没有无参构造函数  (2)构造函数私有化
        //                              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 < 8; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~");
                }
            });
        }
    }
}

3.6 实现Callable接口重写run方法

线程池中submit（）和execute（）方法有什么区别

  • execute():只能执行Runnable类型的任务
  • submit():可以执行Runnable和Callable类型的任务
  • Callable类型的任务可以获取执行的返回值，而Runnable执行无返回值。
public class Test3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        My my = new My();
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<Double> submit = executorService.submit(my);
        System.out.println(submit.get());
    }
}
class  My implements Callable<Double>{

    @Override
    public Double call() throws Exception {
        double sum = 0;
        for (int i = 1; i <=100; i++) {
            sum+=i;
        }
        return sum;
    }
}

3.7 Lock锁

synchronized和Lock有什么区别：

  •  synchronized 可以给类、方法、代码块加锁；而 lock 只能给代码块加锁。
  •  synchronized 不需要手动获取锁和释放锁，使用简单，发生异常会自动释放锁，不会造成死锁；而 lock 需要自己加锁和释放锁，如果没有使用 unLock() 去释放锁就会造成死锁。
  •  通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。---tryLock（）
public class TickteTask implements Runnable{
    //定义100张票
    private Integer tickte=100;
    //定义lock锁
    private Lock l=new ReentrantLock();
    @Override
    public void run() {//使用lock、锁
        //需要用到死循环
        while (true){
                l.lock();//上锁
            try {
                if(tickte>0){
                    tickte--;
                    System.out.println(Thread.currentThread().getName()+"卖出去了一张票，还剩："+tickte+"张");
                }else {
                    break;
                }
            }finally {
                l.unlock();//解锁
            }
        }
    }


    /*@Override
    public void run() {
        //需要用到死循环
        while (true){
            synchronized (this){//锁对象就是this
                if(tickte>0){
                    tickte--;
                    System.out.println(Thread.currentThread().getName()+"卖出去了一张票，还剩："+tickte+"张");
                }else {
                    break;
                }
            }
        }
    }*/
}

4、总结

  1. 死锁--什么是死锁？----避免死锁？
  2. 线程通信---wait ---notify
  3. 线程状态----NEW RUNNABLE WAITING TIMED_WAITING TERMINATED
  4. 线程池：---有点。如何创建线程池
  5. 实现线程的第三种方式 ---Callable
  6. Lock 手动锁

 如有不足之处请指出, 转载请注明出处, 谢谢~!

Java于
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java开发之——线程面试篇：死锁和如何避免死锁？
成都汇智动力的博客
01-13 830
在面试的时候在问起线程锁的部分，经常被问到“什么是死锁”、“怎么避免死锁”之类的问题，甚至开发中在使用锁的时候因为逻辑不严谨导致出现程序无法正确终止或者执行的情况，这些都跟死锁有着不可分割的联系，这篇文章我们就来说说死锁的问题。 什么是死锁 死锁就是当两个或两个以上的线程因竞争相同资源而处于无限期的等待，这样就导致了多个线程的阻塞，出现程序无法正常运行和终止的情况。 举个例子说明下死锁的现象：小明和小张要玩一个玩具，这个玩具有两部分组成必须两部分组装起来才能玩，小明拿了第一部分，小张拿了第二部分；这时.
死锁解密：Java中避免致命纠缠的策略
最新发布
07-16
### 死锁解密：Java 中避免致命纠缠的策略 #### Java 语言概览与特点 Java 是一种广泛采用的编程语言，最初由 Sun Microsystems（现隶属于 Oracle 公司）于 1995 年发布。作为一种面向对象的语言，Java 将现实世界...
避免死锁
07-12 1043
原文链接        作者：Jakob Jenkov 译者：申章   校对：丁一 在有些情况下死锁是可以避免的。本文将展示三种用于避免死锁的技术： 加锁顺序加锁时限死锁检测 加锁顺序 当多个线程需要相同的一些锁，但是按照不同的顺序加锁，死锁就很容易发生。 如果能确保所有的线程都是按照相同的顺序获得锁，那么死锁就不会发生。看下面这个例子： Thread
Java中，如何避免死锁？
weixin_44099583的博客
01-04 1009
使用工具或JVM内置功能（如JConsole）来监控和检测系统中的死锁，然后进行相应的处理。将大的锁分割成几个小的锁，如果可能的话，使得不同的线程可以同时访问不同的资源。方法来请求锁，它允许线程等待锁一定的时间后放弃，从而避免死锁。尽量避免一个线程在持有一个锁的同时去请求另一个锁。确保所有线程以相同的顺序请求和释放锁。
java如何避免死锁_Java中产生死锁的原因及如何避免
weixin_42177768的博客
02-12 389
1. Java中导致死锁的原因Java中死锁最简单的情况是，一个线程T1持有锁L1并且申请获得锁L2，而另一个线程T2持有锁L2并且申请获得锁L1，因为默认的锁申请操作都是阻塞的，所以线程T1和T2永远被阻塞了。导致了死锁。这是最容易理解也是最简单的死锁的形式。但是实际环境中的死锁往往比这个复杂的多。可能会有多个线程形成了一个死锁的环路，比如：线程T1持有锁L1并且申请获得锁L2，而线程T2持有锁...
Java中如何避免死锁呢？
qq_25073223的博客
07-12 1842
java代码避免死锁的方法分享
JAVA多线程通信学习_服务器多线程通信_
10-03
在Java编程中，多线程通信是构建高效并发应用程序的关键技术。服务器多线程通信尤其重要，因为它允许服务器同时处理多个客户端请求，提高系统资源利用率并优化响应时间。本篇文章将深入探讨Java中的多线程通信，以及...
Java多线程-多线程知识点总结和企业真题
02-04
6. **线程通信** - **题1**：`wait()`和`notify()`方法的作用是什么？ - `wait()`使当前线程进入等待状态，`notify()`唤醒一个等待线程。 - **题2**：如何使用`wait()`和`notify()`方法实现生产者消费者模型？ -...
java基础知识多线程线程池讲解和练习
11-01
线程间的同步和通信是多线程编程的关键，Java提供了synchronized关键字、wait/notify机制以及Lock接口等工具来处理这些问题，防止数据不一致性和死锁的发生。 接着，我们来探讨线程池。线程池是管理线程的一种机制...
Java 并发常见知识点&面试题总结
08-19
5. **线程通信** - `wait()`、`notify()` 和 `notifyAll()` 方法用于线程间的通信，必须在同步块或同步方法中调用。 - **BlockingQueue** 接口及其实现如`ArrayBlockingQueue`，`LinkedBlockingQueue`，提供了线程...
详解java中产生死锁的原因及如何避免
08-26
主要介绍了java中产生死锁的原因及如何避免，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java并发编程如何防止死锁？
知识分享官
09-25 391
死锁可能是大家都不想遇到的问题，因为一旦程序出现死锁，如果没有外力的话，程序会因为资源竞争一直处于假死状态。死锁示例代码如下：publicclass}class}class}当一个线程获得了 OBJECT_1 锁时，它并没有释放锁，然后再申请 OBJECT_2 锁。这时，另一个线程获取了OBJECT_2锁，并没有释放锁去申请OBJECT_1锁。由于 OBJECT_1 和 OBJECT_2 锁都没有被释放，所以两个线程会一起请求，陷入死循环，即出现死锁情况。
Java死锁范例以及如何分析死锁
qi20088的专栏
04-08 603
http://www.importnew.com/9668.html
java 避免死锁_java避免死锁的方法
weixin_32006655的博客
02-20 106
public class DeadLockTest {public static final Lock lock1 = new ReentrantLock();public static final Lock lock2 = new ReentrantLock();public static void main(String[] args) {DeadLockTest test = new Dea...
java如何避免死锁_Java死锁与如何避免死锁
weixin_29477915的博客
02-16 149
所谓死锁就是进程循环等待它方占有的资源而无限制的僵持下去的局面。以一个简单的例子来解释：一个桥，最多可以通过一个车子，但是左右两边都来了车子，而且都上了桥，左边的车子，占用了左边的桥资源，二右边的车子，占用了右边的桥的资源。左边的车子等待右边的车子让出右边的资源，但是右边的车子却要左边的车子让出左边的资源。双方都不放弃自己所占有的资源，却都想着让对方让出自己的资源，这就会无限制的等待下去。上述的车...
java如何避免死锁_java并发编程如何预防死锁
weixin_29053695的博客
02-16 250
在java并发编程领域已经有技术大咖总结出了发生死锁的条件，只有四个条件都发生时才会出现死锁：1.互斥，共享资源X和Y只能被一个线程占用2.占有且等待，线程T1已经取得共享资源X，在等待共享资源Y的时候，不释放共享资源X3.不可抢占，其他线程不能强行抢占线程T1占有的资源4.循环等待，线程T1等待线程T2占有的资源，线程T2等待线程T1占有的资源，就是循环等待只要能破坏其中一个，就可以成功避免死锁...
Java死锁如何避免？
m0_70734549的博客
07-20 402
Java死锁如何避免？
Java如何避免死锁？
安静的傍晚
02-26 456
Java多线程中的死锁        死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。这是一个严重的问题，因为死锁会让你的程序挂起无法完成任务，死锁的发生必须满足以下四个条件：互斥条件：一个资源每次只能被一个进程使用。请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。不剥夺条件：进程已获得的资源，在末使用完之前，...
如何避免Java线程中的死锁
攻城狮不是猫
02-24 240
如何避免Java中的死锁？是多线程赛季味道的问题之一，在高级别上提出了更多问题并带有大量后续问题。尽管问题看起来非常基本，但大部分开发人员一旦开始深入研究就会陷入困境。面试问题从“ 什么是死锁？ ” 开始，答案很简单，当两个或更多线程正在等待对方释放锁定并在无限时间卡住时，情况就称为死锁。它只会发生在多任务的情况下。你如何检测Java中的死锁？虽然这可能有很多答案，但是我的版本首先会查看代码，如果...
Java实现多线程通信详解
在Java编程中，多线程通信是一项重要的技术，它允许不同线程之间共享数据、同步执行，从而实现高效的并发处理。以下是对标题和描述中所述知识点的详细说明： 1. **虚假的多线程示例** 在上述例子中，创建了两个`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值