java多线程基础（二）线程死锁及线程通讯！！面试必备

最新推荐文章于 2024-07-31 18:35:11 发布
最新推荐文章于 2024-07-31 18:35:11 发布
阅读量620 收藏
点赞数
分类专栏： 多线程 文章标签： 多线程 面试 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/licmi/article/details/112161893
版权

学习多线程基础（二）线程死锁及线程通讯

1、线程死锁

1.1、什么是死锁

多线程以及多进程改善了系统资源的利用率并提高了系统的处理能力。然而，并发执行也带来了新的问题–死锁。
所谓死锁是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。
在这里插入图片描述

1.2、死锁产生的必要条件

以下这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

互斥条件

进程要求对所分配的资源（如打印机）进行排他性控制，即在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。

不可剥夺条件

进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放（只能是主动释放)。

请求与保持条件

进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。

循环等待条件

存在一种进程资源的循环等待链，链中每一个进程已获得的资源同时被 链中下一个进程所请求。即存在一个处于等待状态的进程集合{Pl, P2, …, pn}，其中Pi等 待的资源被P(i+1)占有（i=0, 1, …, n-1)，Pn等待的资源被P0占有，如图所示。

在这里插入图片描述在这里插入图片描述

1.3、死锁示例代码

DeadLock.java

package com.liuchunming.multithread;

public class DeadLock implements Runnable {
    private static Object obj1 = new Object();//定义成静态变量，使线程可以共享实例
    private static Object obj2 = new Object();//定义成静态变量，使线程可以共享实例
    public int flag;

    public DeadLock(int flag){
        this.flag=flag;
    }

    public void run() {
        if(flag == 1){
            //线程1执行代码
            synchronized (obj1){
                System.out.println(Thread.currentThread().getName()+"获取到obj1资源，请求obj2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj2){
                    System.out.println(Thread.currentThread().getName()+"已经获取到obj1后obj2");
                }
            }
        }
        else{
            //线程2执行代码
            synchronized (obj2){
                System.out.println(Thread.currentThread().getName()+"获取到obj2资源，请求obj1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj1){
                    System.out.println(Thread.currentThread().getName()+"已经获取到obj1后obj2");
                }
            }
        }
    }
}

DeadLockDemo.java

package com.liuchunming.multithread;


public class DeadLockDemo {
    public static void main(String[] args){
        //1、创建两个DeadLock实例，然flag一个等于1 一个等于2
        DeadLock deadLock1 = new DeadLock(1);
        DeadLock deadLock2 = new DeadLock(2);
        //2、再创建两个线程执行DeadLock实例
        Thread thread1 = new Thread(deadLock1,"runnable1");
        Thread thread2 = new Thread(deadLock2,"runnable2");
        //3、启动线程
        thread1.start();
        thread2.start();
    }
}

在这里插入图片描述
执行效果如下：
在这里插入图片描述

1.4、死锁处理

  • 预防死锁：通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或几个条件，来防止死锁的发生。
  • 避免死锁：在资源的动态分配过程中，用某种方法去防止系统进入不安全状态，从而避免死锁的发生。
  • 检测死锁：允许系统在运行过程中发生死锁，但可设置检测机构及时检测死锁的发生，并采取适当措施加以清除。
  • 解除死锁：当检测出死锁后，便采取适当措施将进程从死锁状态中解脱出来。

死锁预防

预防死锁是设法至少破坏产生死锁的四个必要条件之一,严格的防止死锁的出现。

破坏“互斥”条件
“互斥”条件是无法破坏的。因此，在死锁预防里主要是破坏其他几个必要条件，而不去涉及破坏“互斥”条件。

破坏“占有并等待”条件
破坏“占有并等待”条件，就是在系统中不允许进程在已获得某种资源的情况下，申请其他资源。即要想出一个办法，阻止进程在持有资源的同时申请其他资源。

  • 方法一：一次性分配资源，即创建进程时，要求它申请所需的全部资源，系统或满足其所有要求，或什么也不给它。
  • 方法二：要求每个进程提出新的资源申请前，释放它所占有的资源。这样，一个进程在需要资源S时，须先把它先前占有的资源R释放掉，然后才能提出对S的申请，即使它可能很快又要用到资源R。

破坏“不可抢占”条件
破坏“不可抢占”条件就是允许对资源实行抢夺。

  • 方法一：如果占有某些资源的一个进程进行进一步资源请求被拒绝，则该进程必须释放它最初占有的资源，如果有必要，可再次请求这些资源和另外的资源。
  • 方法二：如果一个进程请求当前被另一个进程占有的一个资源，则操作系统可以抢占另一个进程，要求它释放资源。只有在任意两个进程的优先级都不相同的条件下，方法二才能预防死锁。

破坏“循环等待”条件
破坏“循环等待”条件的一种方法，是将系统中的所有资源统一编号，进程可在任何时刻提出资源申请，但所有申请必须按照资源的编号顺序（升序）提出。这样做就能保证系统不出现死锁。

1.5、死锁避免

避免死锁不严格限制产生死锁的必要条件的存在,因为即使死锁的必要条件存在,也不一定发生死锁。

有序资源分配法

该算法实现步骤如下：

  • 必须为所有资源统一编号，例如打印机为1、传真机为2、磁盘为3等
  • 同类资源必须一次申请完，例如打印机和传真机一般为同一个机器，必须同时申请
  • 不同类资源必须按顺序申请
    例如：有两个进程P1和P2，有两个资源R1和R2
    P1请求资源：R1、R2
    P2请求资源：R1、R2
    让P2等待P1将资源释放、这样就破坏了环路条件，避免了死锁的发生。

银行家算法

银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。流程图如下：
在这里插入图片描述
银行家算法的基本思想是分配资源之前，判断系统是否是安全的；若是，才分配。它是最具有代表性的避免死锁的算法。
设进程i提出请求REQUEST [i]，则银行家算法按如下规则进行判断。

  1. 如果REQUEST [i]<= NEED[i，j]，则转（2)；否则，出错。
  2. 如果REQUEST [i]<= AVAILABLE[i]，则转（3)；否则，等待。
  3. 系统试探分配资源，修改相关数据：
    AVAILABLE[i]-=REQUEST[i];//可用资源数-请求资源数
    ALLOCATION[i]+=REQUEST[i];//已分配资源数+请求资源数
    NEED[i]-=REQUEST[i];//需要资源数-请求资源数
  4. 系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。

顺序加锁

当多个线程需要相同的一些锁，但是按照不同的顺序加锁，死锁就很容易发生。
例如以下两个线程就会死锁：
Thread 1:

lock A (when C locked) 
lock B (when C locked) 
wait for C

Thread 2:

wait for A 
wait for B
lock C (when A locked)

如果能确保所有的线程都是按照相同的顺序获得锁，那么死锁就不会发生。 例如以下两个线程就不会死锁
Thread 1:

lock A 
lock B
lock C

Thread 2:

wait for A 
wait for B
wait for C

按照顺序加锁是一种有效的死锁预防机制。但是，这种方式需要事先知道所有可能会用到的锁，但总有些时候是无法预知的，所以该种方式只适合特定场景。

限时加锁

限时加锁是线程在尝试获取锁的时候加一个超时时间，若超过这个时间则放弃对该锁请求，并回退并释放所有已经获得的锁，然后等待一段随机的时间再重试
以下是一个例子，展示了两个线程以不同的顺序尝试获取相同的两个锁，在发生超时后回退并重试的场景：

Thread 1 locks A    //线程1锁定a
Thread 2 locks B    //线程2锁定b
Thread 1 attempts to lock B but is blocked  //1尝试去锁定b 但是b被2锁定了
Thread 2 attempts to lock A but is blocked  //2尝试去锁定a a被1锁定了
Thread 1’s lock attempt on B times out  //1线程等待一段时间超时了
Thread 1 backs up and releases A as well //回退，释放掉a资源
Thread 1 waits randomly (e.g. 257 millis) before retrying.  //等待一段时间
Thread 2’s lock attempt on A times out  //线程2等待一段时间超时了
Thread 2 backs up and releases B as well //回退、释放掉b资源
Thread 2 waits randomly (e.g. 43 millis) before retrying. //等待一段时间

//如果他们等待的时间不一样，迟早有一次机会会获取到各种所需的资源

在上面的例子中，线程2比线程1早200毫秒进行重试加锁，因此它可以先成功地获取到两个锁。这时，线程1尝试获取锁A并且处于等待状态。当线程2结束时，线程1也可以顺利的获得这两个锁。
这种方式有两个缺点：

  1. 当线程数量少时，该种方式可避免死锁，但当线程数量过多，这些线程的加锁时限相同的概率就高很多，可能会导致超时后重试的死循环。
  2. Java中不能对synchronized同步块设置超时时间。你需要创建一个自定义锁，或使用Java5中java.util.concurrent包下的工具。

死锁检测

预防和避免死锁系统开销大且不能充分利用资源，更好的方法是不采取任何限制性措施，而是提供检测和解脱死锁的手段，这就是死锁检测和恢复。
死锁检测数据结构：

  • E是现有资源向量（existing resource vector），代码每种已存在资源的总数
  • A是可用资源向量（available resource vector），那么Ai表示当前可供使用的资源数（即没有被分配的资源）
  • C是当前分配矩阵（current allocation matrix），C的第i行代表Pi当前所持有的每一种类型资源的资源数
  • R是请求矩阵（request matrix），R的每一行代表P所需要的资源的数量
    在这里插入图片描述
    死锁检测步骤：
  1. 寻找一个没有结束标记的进程Pi，对于它而言R矩阵的第i行向量小于或等于A。
  2. 如果找到了这样一个进程，执行该进程，然后将C矩阵的第i行向量加到A中，标记该进程，并转到第1步
  3. 如果没有这样的进程，那么算法终止
  4. 算法结束时，所有没有标记过的进程都是死锁进程。

死锁恢复

利用抢占恢复
临时将某个资源从它的当前所属进程转移到另一个进程。
这种做法很可能需要人工干预，主要做法是否可行需取决于资源本身的特性

利用回滚恢复
周期性的将进程的状态进行备份，当发现进程死锁后，根据备份将该进程复位到一个更早的，还没有取得所需的资源的状态，接着就把这些资源分配给其他死锁进程。

通过杀死进程恢复
最直接简单的方式就是杀死一个或若干个进程。
尽可能保证杀死的进程可以从头再来而不带来副作用。

2、线程通讯

2.1、为什么要线程通信

多个线程并发执行时，在默认情况下CPU是随机切换线程的，有时我们希望CPU按我们的规律执行线程，此时就需要线程之间协调通信。
CPU执行规律图
在这里插入图片描述

2.2、线程通讯方式

线程间通信常用方式如下：

  • 休眠唤醒方式：
    Object的wait、notify、notifyAll
    Condition的await、signal、signalAll
  • CountDownLatch：用于某个线程A等待若干个其他线程执行完之后，它才执行
  • CyclicBarrier：一组线程等待至某个状态之后再全部同时执行
  • Semaphore：用于控制对某组资源的访问权限

休眠唤醒方式

Object的wait、notify、notifyAll

package com.multithread.thread;

public class WaitNotifyRunnable{
    private Object obj = new Object();
    private Integer i=0; //要打印的数
/**
*
* 奇数方法打印，由奇数线程调用
*
**/
    public void odd() {
        while(i<10){
            synchronized (obj){ // notify，wait方法是依赖synchronized 关键字的
		//<10打印奇数
                if(i%2 == 1){
                    System.out.println("奇数："+i);
                    i++;
                    obj.notify();//唤醒偶数线程打印
                } else {
                    try {
                        obj.wait();//等待偶数线程打印完成
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
/**
*
*  偶数打印方法，由偶数线程调用
*
**/
    public void even(){
        while(i<10){
            synchronized (obj){
                if(i%2 == 0){
                    System.out.println("偶数："+i);
                    i++;
                    obj.notify();
                } else {
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public static void main(String[] args){
        final WaitNotifyRunnable runnable = new WaitNotifyRunnable();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                runnable.odd();
            }
        }, "偶数线程");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                runnable.even();
            }
        }, "奇数线程");

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

在这里插入图片描述

Condition的await、signal、signalAll

package com.multithread.thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class WaitNotifyRunnable{
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private Integer i=0;
    public void odd() {
        while(i<10){
            lock.lock();
            try{
                if(i%2 == 1){
                    System.out.println("奇数："+i);
                    i++;
                    condition.signal();
                } else {
                    condition.await();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }
    }

    public void even(){
        while(i<10){
            lock.lock();
            try{
                if(i%2 == 0){
                    System.out.println("偶数："+i);
                    i++;
                    condition.signal();
                } else {
                    condition.await();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }
    }
    public static void main(String[] args){
        final WaitNotifyRunnable runnable = new WaitNotifyRunnable();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                runnable.odd();
            }
        }, "偶数线程");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                runnable.even();
            }
        }, "奇数线程");

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

在这里插入图片描述

Object和Condition休眠唤醒区别

  • object wait()必须在synchronized（同步锁）下使用，
  • object wait()必须要通过Nodify()方法进行唤醒
  • condition await() 必须和Lock（互斥锁/共享锁）配合使用
  • condition await() 必须通过 signal() 方法进行唤醒

2.3、CountDownLatch方式

CountDownLatch是在java1.5被引入的，存在于java.util.concurrent包下。
CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。
CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。

在这里插入图片描述
每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。
需求：教练训练运动员，教练需要等待运动员到齐且准备好之后才能开始训练
示例代码：

package com.liuchunming.ThreadCountDownLatch;

import java.util.concurrent.CountDownLatch;

public class CountDown {
    private CountDownLatch countDownLatch = new CountDownLatch(3);  // 设置等待的运动员是3个

    /**
     * 运动员方法，由运动员线程调用
     */
    public void racer(){
        // 1、获取运动员线程名称
        String name= Thread.currentThread().getName();
        // 2、运动员开始准备，打印准备信息
        System.out.println(name+"正在准备。。。");
        // 3、线程睡眠1000毫秒，表示在准备
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 4 、准备完毕，打印准备完毕信息 同时计数减1
        System.out.println(name+"准备完毕！");
        countDownLatch.countDown();
    }

    /**
     * 教练方法，由教练线程调用
     */
    public void coach(){
        //1、获取教练线程名称
        String name=Thread.currentThread().getName();
        // 2、教练等待所有运动员准备完毕、打印等待信息
        System.out.println(name+"等待运动员准备。。。");
        // 3、调用countDownLatch的await方法等待其他线程执行完毕
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //4 、所有运动员已就绪，教练开始训练，打印训练信息
        System.out.println("所有运动员已就绪，"+name+"开始训练！");
    }
    public static void main(String[] args) {
        //1、CountDown实例
        final CountDown countDown = new CountDown();
        //2、创建三个线程对象，调用CountDown的racer方法
           Thread thread1 = new Thread(new Runnable() {
            public void run() {
                countDown.racer();
            }
        }, "运动员1");
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                countDown.racer();
            }
        }, "运动员2");
        Thread thread3 = new Thread(new Runnable() {
            public void run() {
                countDown.racer();
            }
        }, "运动员3");
        //3、创建一个线程对象，调用countDownLatch的ceach方法
        Thread thread4 = new Thread(new Runnable() {
            public void run() {
                countDown.coach();
            }
        }, "教练员");
        thread4.start();
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

在这里插入图片描述

2.4、CyclicBarrier方式

CyclicBarrier是在java1.5被引入的，存在于java.util.concurrent包下。
CyclicBarrier实现让一组线程等待至某个状态之后再全部同时执行。
CyclicBarrier底层是
三个线程同时启动，示例代码如下：

package com.liuchunming.ThreadCyclicBarrier;

import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    final CyclicBarrier cyclicBarrier = new CyclicBarrier(3);// 参数是参与CyclicBarrier的线程数

    public  void  startThread(){
        //1、打印程序启动
        System.out.println(Thread.currentThread().getName()+"：准备...");
        //2、调用CyclicBarrier的await方法让线程全部准备
        try {
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        //3、打印完毕信息
        System.out.println(Thread.currentThread().getName()+"启动完毕："+new Date().getTime());
    }

    public static void main(String[] args){
      final CyclicBarrierDemo cyclicBarrierDemo =new CyclicBarrierDemo();
        Thread thread1 =new Thread(new Runnable() {
            public void run() {
                cyclicBarrierDemo.startThread();
            }
        },"线程1");
        Thread thread2 =new Thread(new Runnable() {
            public void run() {
                cyclicBarrierDemo.startThread();
            }
        },"线程2");
        Thread thread3 =new Thread(new Runnable() {
            public void run() {
                cyclicBarrierDemo.startThread();
            }
        },"线程3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

执行效果如下：三个线程同时启动
在这里插入图片描述

2.5、Semaphore方式

Semaphore是在java1.5被引入的，存在于java.util.concurrent包下。
Semaphore用于控制对某组资源的访问权限。
工人使用机器工作，示例代码如下：

package com.liuchunming.Semaphore;

import java.util.concurrent.Semaphore;

public class SemaphoreDemo {

    static class Machine implements Runnable{
        private int num; //工人编号
        private Semaphore semaphore;  //机器数

        public Machine(int num, Semaphore semaphore) {
            this.num = num;
            this.semaphore = semaphore;
        }

        public void run() {
            try {
                // 1、工人获取到机器
                semaphore.acquire();//请求机器
                System.out.println("工人"+this.num+"请求机器，正在使用机器");
                // 线程休眠、模拟工作过程
                Thread.sleep(1000);
                System.out.println("工人"+this.num+"使用完毕，已经释放机器");
                semaphore.release();//释放机器
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        int worker = 8;//工人数
        Semaphore semaphore = new Semaphore(3);//机器数
        for (int i=0; i< worker; i++){
            new Thread(new Machine(i, semaphore)).start();
        }
    }
}

执行效果如下：
在这里插入图片描述

小结

sleep和wait区别

在这里插入图片描述

wait和notify区别

wait和notify都是Object中的方法
wait和notify执行前线程都必须获得对象锁
wait的作用是使当前线程进行等待
notify的作用是通知其他等待当前线程的对象锁的线程

JAVA多线程之 经典“死锁”问题
weixin_43740680的博客
10-14 420
原创 多线程之死锁详解 ...
Java多线程面试题
tq02的博客
07-10 2641
线程的面试点问题
线程的状态（全面）、常见的方法（sleep、yield、join）
awodwde的博客
11-06 147
线程对象被创建，即为初始状态，只在堆中开辟内存，和常规对象一样。线程new出来之后是一个初始状态 调用start（）进入就绪状态 ready（） OS选中，获得时间片就进入运行状态，时间片到期，则回到就绪状态 常见的静态方法（使用类名来调用） public static void sleep（long millis）:当前线程主动休眠xx毫秒 注意这个异常是抛不出去的，只能使用try catch public static void yield（） 主动放弃CPU的使用权 ..
java多线程与死锁_java多线程系列5-死锁与线程间通信
weixin_34382844的博客
02-16 113
这篇文章介绍java死锁机制和线程间通信死锁死锁：两个或两个以上的线程在争夺资源的过程中，发生的一种相互等待的现象。同步代码块的嵌套案例public classMyLock {//创建两把锁对象public static final Object objA = newObject();public static final Object objB = newObject();}public cla...
java基础之线程通信和死锁
weixin_50691399的博客
11-07 220
本文主要是线程通信和死锁相关问题
Java多线程 死锁的检测与恢复策略
Java持续实践
09-12 438
文章目录检测与恢复策略死锁的修复策略总结 检测与恢复策略 检测与恢复策略: 一段时间检测是否有死锁, 如果有剥夺某一个资源 ,打开死锁. 死锁的检测算法 : 允许发生死锁. 每次调用锁的时候 , 都做记录,用图的数据结构来记录. 根据有向图的方向, 定期检查 "锁的调用链路"中是否存在环路. 一旦发生死锁, 用死锁恢复机制进行恢复. 恢复方法1 : 进程终止 逐个的终止线程, 直到死锁消除为止. 终止的顺序 根据优先级终止, 看是前台的交互更加的重要, 还是后台的处理更重要 根据已经占用的资源和 还
Java程序员面试中的多线程问题总结
09-01
实现Java多线程有两种主要方式：一是继承`Thread`类，二是实现`Runnable`接口。通常推荐实现`Runnable`接口，因为它允许多重继承，更符合面向接口编程的原则。 3. **`Thread.start()`与`Thread.run()`的区别？** ...
【BAT必备】多线程面试题
09-25
### 【BAT必备】多线程面试题解析 #### 一、多线程基本概念 **1.1 什么是多线程？** 多线程是指在同一个应用或进程中同时执行多个线程来完成任务的一种机制。它能充分利用多核处理器的能力，提高程序运行效率。 ...
Java面试题（多线程）
最新发布
Hanshy123的博客
07-31 819
java中多线程方面的面试题
讲解Java在面试中的高频考点，分别包含Java基础、Java集合、Java多线程与并发编程、Java虚拟机、数据库、
06-02
Java多线程与并发编程是高级Java开发者的关键技能。面试时，你需要理解线程的生命周期，如何创建和管理线程，以及同步机制（如synchronized关键字、volatile、Lock接口等）的使用。并发模型中的线程池、Future、...
Java多线程：（三）一些方法：start()，sleep()，yield()，join()
ppp21spider的专栏
04-10 1416
 1.start()和run() 执行的线程,一定要调用它的start()方法。不能调用run()方法。 如果直接调用线程对象的run()方法,程序也会执行,但那样是在当前线程中执行,不会启动新的线程。 start()方法的本质是从CPU中申请一个新的线程空间来执行 run()方法中的代码。 run()方法的本质是只是线程的接口回调方法。 一个线程对象只能运行成功一次start()方法...
线程的几种状态以及线程状态切换
L13763338360的博客
03-21 784
讲java线程的状态切换前先复习下线程创建的几种方法 继承thread类 实现runnable接口 使用Callable和Future创建线程 使用线程池例如用Executor框架 java线程有五个状态：初始、就绪、运行、阻塞、死亡。 状态之间的切换用文字描述比较繁琐，千言不如一图，参考网友整理的图：https://www.iteye.com/blog/zy19982004-16269...
python 主线程_阻止主线程直到python后台线程完成side-task
weixin_39843078的博客
11-26 131
我有一个线程python应用程序,后台线程中有一个长时间运行的mainloop.这个后台主循环实际上是对pyglet.app.run()的调用,它驱动一个GUI窗口,也可以配置为定期调用其他代码.我需要从主线程中随意调用do_stuff(duration)函数来触发GUI中的动画,等待动画停止,然后返回.实际动画必须在后台线程中完成,因为GUI库无法处理由单独的线程驱动.我相信我需要做这样的事情：...
java sleep 就绪运行_2020全新Java面试题——多线程（二）
weixin_35125159的博客
02-16 208
一、线程有哪些状态？线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。1、创建状态在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。2、就绪状态当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。3、运行状态线程调度程序将处于就绪状态的线...
java 检测到死锁_java 性能检测工具 检测死锁等
weixin_35455994的博客
02-16 188
死锁检测方法1 JConsole 找到需要查看的进程，打开线程选项卡，点击检测死锁2 jps查看java进程ID，使用jstack 7412输出信息3 使用jvisualvm连接java虚拟机，查看线程检测死锁解决方法：四个条件打破一个即可，但是代价不同，最简单的编码就是顺序加锁和解锁现在我们介绍下如何避免死锁的几个常见方法。《java变发编程的艺术》避免一个线程同时获取多个锁。避免一个线程在锁...
Java 线程 wait ，sleep区别以及notify和notifyAll区别
weixin_30321709的博客
01-16 304
了解线程的状态， 1.新建状态(New) : 线程对象被创建后，就进入了新建状态。2.就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。3.运行状态(Running): 线程获取CPU权限进行执行。需要注...
java 死锁检测工具_Java精通并发-死锁检测与相关工具详解
weixin_42706667的博客
02-17 201
关于死锁其实在之前https://www.cnblogs.com/webor2006/p/10659938.html的jvm学习中已经详细举过例子了，不过这里再来复习一下，另外是从并发这个专题领域的角度再来看下它，这里先来阐述一下相关的概念：死锁：线程1等待线程2互斥持有的资源，而线程2也在等待线程1互斥持有的资源，两个线程都无法继续执行。活锁：线程持续重试一个总是失败的操作，导致无法继续执行。饿...
java死锁检测
pan_xi_yi的博客
09-03 511
导致死锁的程序 package com.study.train; import java.io.IOException; import java.lang.management.ManagementFactory; import java.lang.management.ThreadInfo; import java.lang.management.ThreadMXBean; import java.lang.reflect.Field; import java.util.*; import java.u
面试突击：死锁的排查工具有哪些？
m0_69860228的博客
05-16 243
死锁(Dead Lock)指的是两个或两个以上的运算单元(进程、线程或协程)，都在等待对方释放资源，但没有一方提起释放资源，从而造成了一种阻塞的现象就称为死锁。 比如线程 1 拥有了锁 A 的情况下试图获取锁 B，而线程 2 又在拥有了锁 B 的情况下试图获取锁 A，这样双方就进入相互阻塞等待的情况，如下图所示： 死锁的代码实现如下： import java.util.concurrent.TimeUnit; public class DeadLockTest { public sta
JAVA多线程面试必备知识点总结
"JAVA多线程(精典总结)，涵盖了面试常见问题，包括线程的基本概念、线程与进程的区别、线程的创建方式以及线程的状态转换等核心知识点。" 在Java编程中，多线程是提升程序性能和响应速度的重要手段。线程是进程中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值