精华内容
下载资源
问答
  • 线程——运行和阻塞状态详解
    千次阅读
    2019-06-28 16:14:54

    线程——运行和阻塞状态详解

    所有现代的桌面和服务器操作系统都采用抢占式调度策略,但一些小型设备如手机等可能采用协作式调度策略,在这样的系统中,只有当一个线程调用了它的sleep()或yield()方法后才会放弃其所占用的资源——也就是必须有线程主动放弃其所占用的资源。
    当发生如下情况时,线程将进入阻塞状态:
    1、线程调用了sleep()方法主动放弃其所占用的处理器资源;
    2、线程调用了一个阻塞式I/O方法,在该方法返回之前,该线程被阻塞;
    3、线程试图调用一个锁对象,但该锁对象整备其他线程所持有的;
    4、线程正在等待某个通知

    当前正在执行的线程被阻塞之后,其他线程就可以后的执行的机会。被阻塞的线程会在合适的时候重新进入就绪状态,注意是就绪状态,而不是运行状态。也就是说,被阻塞线程的阻塞解除之后,必须重新等待线程调度再次调度它。
    针对上面几种情况,当发生如下特定的情况时可以解除阻塞,让该线程重新进入就绪状态。
    1、调用sleep()方法的线程超过了指定的时间;
    2、线程调用的阻塞式I/O方法已经返回;
    3、线程成功的获得了试图获取的锁对象;
    4、线程正在等待某个通知时,其他线程发出了一个通知。

    更多相关内容
  • 1)新建:当线程被创建,它只会短暂地处于这种状态,在这段时间内,主要会执行一些初始化的的操作。 2)就绪:在这种状态下,只要调度器把时间片分配给线程,该线程就可以运行了。 3)阻塞线程能够运行,...

    系列:

    并发 · 一 —— 线程

    并发 · 二 —— 互斥锁(synchronized 和 Lock)

    并发 · 三 —— 原子性与易变性

     

    线程有四种状态:新建、就绪、阻塞和死亡。

    1)新建:当线程被创建时,它只会短暂地处于这种状态,在这段时间内,主要会执行一些初始化的的操作。

    2)就绪:在这种状态下,只要调度器把时间片分配给线程,该线程就可以运行了。

    3)阻塞:线程能够运行,但是有某个条件阻止它的运行。当线程处于阻塞状态时,调度器将忽略线程,不会分配给线程任何的CPU时间。直到线程重新进入了就绪的状态,调度器才会继续分配CPU时间给它。

    4)死亡:处于该状态的线程将不再是可调度的,并且再也不会得到CPU时间,它的任务已结束了。任务死亡的通常方式是从run()方法返回。

    注意:线程中的stop()方法已经被弃用了,主要是因为它不释放线程获取的锁,并且如果线程处于不一致的状态,其它任务可以在这种状态下浏览并修改它们,这样锁产生的问题就很难被发现了。

    进入阻塞状态几种方式:

    1)通过调用sleep(millisecond)使任务进入休眠状态,在这种情况下,任务在指定的时间内处于阻塞状态,不会获得CPU时间,并且不会释放线程自身所持有的锁(区别于调用wait()将线程挂起)。

    2)调用wait()使线程挂起,直到线程得到了notify()或notifyAll()消息,线程重新才会进入就绪状态。

    3)任务在等待某个输入/输出完成。

    4)任务试图在某个对象上调用其同步控制方法,但是对象锁不同,此时就会被阻塞了。

    **中断

    常规手动停止线程的方法就是通过设置标志位的方法或者到达预先埋好的返回代码的位置,切记,stop()方法已经弃用了,由于不稳定,无法正常释放锁

    public class text1 {
    	
    	volatile static boolean stop = false;
    	
    	public static void main(String[] args) {
    		new Thread(new Runnable() {
    			@Override
    			public void run() {
    				while (!stop) {
    					System.out.println("运行中。。");
    				}
    			}
    		}).start();
    		try {
    			Thread.sleep(1000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		stop = true;
    	}
    }

    1、interrupt()

    在Thread类提供interrupt()方法,用于中止正在被阻塞的任务。当打断一个正在被阻塞的任务时,通常还需要清理资源,这正如处理抛出异常,由于有这种需求存在,Java在设计阻塞时中断方法时,即在调用interrupt()设置线程为中断状态后,如果线程遇到阻塞就会抛出InterruptedException异常,并且将会重置线程的中断状态。例如

    public class text2 {
    	
    	public static void main(String[] args) {
    		new Thread(){
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				super.run();
    				interrupt();// 将线程设置为中断状态
    				
    				System.out.println("遇到阻塞");				
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					System.out.println("阻塞被打断");
    					// 在这里清理资源
    					e.printStackTrace();
    				}
    				
    				System.out.println("又遇到阻塞");				
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					System.out.println("阻塞被打断");
    					// 在这里清理资源
    					e.printStackTrace();
    				}
    				System.out.println("结束线程");
    			}
    		}.start();
    	}
    }

    >> 运行的结果

    遇到阻塞
    阻塞被打断
    java.lang.InterruptedException: sleep interrupted
        at java.lang.Thread.sleep(Native Method)
        at text$1.run(text.java:19)
    又遇到阻塞
    结束线程

    >>

    从运行结果,我们可以看出,在调用interrupt()方法线程就被设置为中断状态,一旦遇到阻塞,就会立马中断阻塞,并抛出异常,并且重置中断状态位,当下次遇到阻塞就不会被中断并抛出异常。可以这么理解,调用interrupt(),便将线程的中断标志位置为true,当遇到阻塞(或者在调用interrupt方法中,正处于阻塞),都会立马中断阻塞,将线程的中断标志位置为false,并抛出异常。

    public class text3 {
    	public static void main(String[] args) {
    		Thread t = new Thread(){
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				super.run();
    				System.out.println("遇到阻塞");				
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					System.out.println("阻塞被打断");
    					// 在这里清理资源
    					e.printStackTrace();
    				}
    				System.out.println("阻塞结束");
    				System.out.println("结束线程");
    			}
    		};
    		t.start();
    		try {
    			Thread.sleep(500); // 为了确保线程已经运行
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("调用interrupt()");
    		t.interrupt();
    	}
    }

    >> 运行结果

    遇到阻塞
    调用interrupt()
    阻塞被打断
    java.lang.InterruptedException: sleep interrupted
        at java.lang.Thread.sleep(Native Method)
        at text$1.run(text.java:17)
    阻塞结束
    结束线程

    >>

    正如上面的运行结果可以看出,如果线程正处于阻塞状态,调用interrupt()方法,会立马打断阻塞并抛出异常。

    2、Thread.interrupted();

     除了遇到阻塞会抛出异常,并重置线程中断状态,Thread还有提供了一个interrupted()的静态方法,可以将当前的线程的中断状态重置。将上面第一个例子text1改进一下,它将不会阻塞被中断

    public class text1_1 {
    	
    	public static void main(String[] args) {
    		new Thread(){
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				super.run();
    				interrupt(); // 将线程置为中断状态
    				Thread.interrupted(); // 重置线程中断状态
    				System.out.println("遇到阻塞");				
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					System.out.println("阻塞被打断");
    					// 在这里清理资源
    					e.printStackTrace();
    				}
    				System.out.println("阻塞结束");
    				System.out.println("结束线程");
    			}
    		}.start();
    		
    	}

    >> 运行结果

    遇到阻塞
    阻塞结束
    结束线程

    >>

    3、isInterrupted()

    可以通过调用这个方法打印当前线程的中断状态

    public class text4 {
    	public static void main(String[] args) {
    		new Thread(){
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				super.run();
    				interrupt(); // 设置中断状态
    				System.out.println(interrupted()); // 打印中断状态
    			}
    		}.start();
    		
    	}
    }

    >>运行结果

    true
    >>

    注意:当I/O和synchronized块上的等待是不可中断的的,也不需要InterruptException处理器。中断可以打断的有调用sleep()、调用wait()调起将线程挂起。

     

    正文到这就完了

    展开全文
  • java线程的五大状态,阻塞状态详解

    千次阅读 2020-08-17 09:45:54
    运行后可能遇到的阻塞状态 二、相关方法 2.1 新生状态 Thread t = new Thread(); 正如我们前面所说的,一个线程开始之后有自己的内存空间,这些工作空间和主内存进行交互,从主内存拷贝数据到工作空间。 这个...

    一、状态简介

    一个线程的生命周期里有五大状态,分别是:

    1. 新生
    2. 就绪
    3. 运行
    4. 死亡
    5. 运行后可能遇到的阻塞状态

    在这里插入图片描述

    二、相关方法

    2.1 新生状态

    Thread t = new Thread();
    

    正如我们前面所说的,一个线程开始之后有自己的内存空间,这些工作空间和主内存进行交互,从主内存拷贝数据到工作空间。

    当这个语句执行的时候,线程创建,开辟工作空间,也就是线程进入了新生状态。

    2.2 就绪状态

    普通情况,一旦调用了:

    t.start();
    

    start 方法被调用,线程立即进入了就绪状态,表示这个线程具有了运行的条件,但是还没有开始运行,这就是就绪状态。

    线程就绪,但不意味着立即调度执行,因为要等待CPU的调度,一般来说是进入了就绪队列

    但是还有另外三种情况,线程也会进入就绪状态,四种分别是:

    1. start()方法调用;
    2. 本来处于阻塞状态,后来阻塞解除;
    3. 如果运行的时候调用 yield() 方法,避免一个线程占用资源过多,中断一下,会让线程重新进入就绪状态。注意,如果调用 yield() 方法之后,没有其他等待执行的线程,此线程就会马上恢复执行;
    4. JVM 本身将本地线程切换到了其他线程,那么这个线程就进入就绪状态。

    2.3 运行状态

    当CPU选定了一个就绪状态的线程,进行执行,这时候线程就进入了运行状态,线程真正开始执行线程体的具体代码块,基本是 run() 方法。

    注意,一定是从 就绪状态 - > 运行状态,不会从阻塞到运行状态的。

    2.4 阻塞状态

    阻塞状态指的是代码不继续执行,而在等待,阻塞解除后,重新进入就绪状态。

    也就是说,阻塞状态发生肯能是运行状态转过去的, 运行状态 - > 阻塞状态,不会从就绪状态转过去。

    阻塞的方法有四种:

    1. sleep()方法,是占用资源在睡觉的,可以限制等待多久;
    2. wait() 方法,和 sleep() 的不同之处在于,是不占用资源的,限制等待多久;
    3. join() 方法,加入、合并或者是插队,这个方法阻塞线程到另一个线程完成以后再继续执行;
    4. 有些 IO 阻塞,比如 write() 或者 read() ,因为IO方法是通过操作系统调用的。

    上面的方法和start() 一样,不是说调用了就立即阻塞了,而是看CPU。

    2.5 死亡状态

    死亡状态指的是,线程体的代码执行完毕或者中断执行。一旦进入死亡状态,不能再调用 start() 。

    让线程进入死亡状态的方法是 stop() 和 destroy() 但是都不推荐使用,jdk里也写了已过时。

    一般的做法是,在线程内,让线程自身自然死亡,或者加一些代码,想办法让线程执行完毕。

    1. 自然死亡:这个线程体里就是多少次的循环,几次调用,执行完了就完了。
    2. 如果不能自然死亡:加一些终止变量,然后用它作为run的条件,这样,外部调用的时候根据时机,把变量设置为false。

    比如下面的写法,第一种就是我们的正常写法(虽然很简单但是没有用lambda表达式,主要为了和第二种对比)

    /*
        终止线程的方法1:自然死亡
    */
    public class Status implements Runnable{
        @Override
        public void run() {
            for (int i=0; i<20; i++){
                System.out.println("studying");
            }
        }
    
        public static void main(String[] args) {
            Status s = new Status();
            new Thread(s).start();
        }
    }
    
    /*
        终止线程的方法2:外部控制
    */
    public class Status implements Runnable{
        //1.加入状态变量
        private boolean flag = true;
        @Override
        //2.关联状态变量
        public void run() {
            while (flag){
                System.out.println("studying");
            }
        }
        //3.对外提供状态变量改变方法
        public void terminate() {
            this.flag = false;
        }
        public static void main(String[] args) {
            Status s = new Status();//1.新生
            new Thread(s).start();//2.就绪,随后进入运行
            //无人为阻塞
            for (int i=0; i<100000; i++){
                if (i==80000){
                    s.terminate();//3.终止
                    System.out.println("结束");
                }
            }
        }
    }
    

    三、阻塞状态详解

    上面的内容,线程的五大状态里,其他四种都比较简单,创建对象的新生态、start开始的就绪态、cpu调度之后进入的运行态,以及正常结束或者外加干预导致的死亡态。

    在这里插入图片描述

    3.1 sleep()

    • sleep(时间)指定当前线程阻塞的毫秒数:
    • sleep存在异常:InterruptException;
    • sleep时间到了之后线程进入就绪状态;
    • sleep可以模拟网络延时、倒计时等;
    • 每一个对象都有一个无形的锁,sleep不会释放锁。(也就是我们说过的,抱着资源睡觉,这个特点对比wait)

    前面用线程模拟抢票的网络延时,已经做过示例,就是用sleep设置线程阻塞的时间,达到网络延时的效果,让那个同步问题更容易显现出来。

    我们再用龟兔赛跑的例子修改一下,前面兔子和乌龟都是一样各自跑,这次让兔子骄傲的爱睡觉,每隔一段路就睡一段时间。

    public class Racer2 implements Runnable{
        private String winner;
        @Override
        public void run() {
            for (int dis=1; dis<=100; dis++){
                String role = Thread.currentThread().getName();
                //模拟兔子睡觉
                if (dis%10==0 && role.equals("兔子")){
                    try {
                        Thread.sleep(500);//睡
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(role + " 跑了 " + dis);
                //每走一步,判断是否比赛结束
                if (gameOver(dis))break;
            }
        }
    
        public boolean gameOver(int dis){
            if (winner != null){
                return true;
            } else if (dis == 100){
                winner = Thread.currentThread().getName();
                System.out.println("获胜者是 "+winner);
                return true;
            }
            return false;
        }
    
        public static void main(String[] args) {
            Racer2 racer = new Racer2();//1.创建实现类
            new Thread(racer,"兔子").start();//2.创建代理类并start
            new Thread(racer,"乌龟").start();
        }
    }
    

    这里面:

    Thread.sleep(500);//睡
    

    就是让线程进入阻塞状态,并且 500 ms 后,自动进入就绪状态,由 cpu 调度适时重新运行。

    也可以利用 sleep 模拟倒计时,不涉及多个线程,所以直接在主线程里面,主方法里写内容就可以,也不用run什么,直接调用sleep设置阻塞时间。

    public class SleepTime {
        public static void main(String[] args) throws InterruptedException {
            int num = 10;
            while (num>=0){
                Thread.sleep(1000);
                System.out.println(num--);
            }
        }
    }
    

    这就会完成10-0 的倒计时。

    更花哨一点,用 Dateformat 和 Date 实现时间的显示:

    public static void main(String[] args) throws InterruptedException {
        //获取十秒后的时间,然后倒计时
        Date endTime = new Date(System.currentTimeMillis()+1000*10);
        //干预线程的结束
        long end = endTime.getTime();
        DateFormat format = new SimpleDateFormat("mm:ss");
        while (true) {
            System.out.println(format.format(endTime));
            Thread.sleep(1000);
            endTime = new Date(endTime.getTime() - 1000);//-1s
            if (end-10000 > endTime.getTime()){
                break;
            }
        }
    }
    

    3.2 wait() && notify()

    和 sleep() 不同,wait() 方法和 notify() 搭配,可以互相搭配,一个经典的的使用场景以及介绍是在生产者-消费者模型中:

    生产者消费者模型详解

    3.3 yield()

    礼让线程,让当前正在执行的线程暂停,不阻塞线程,而是直接将线程从运行状态转入就绪状态,让cpu调度器重新调度。

    用法和 sleep 是一样的,也是一个静态方法,调用起来的效果比 sleep 弱。

    这是因为,礼让之余,还有 cpu 的调度在影响顺序,所以无法保证达到线程切换的效果, cpu 还是可能调用当前的线程。

    3.4 join()

    join 合并线程,待此线程执行完成后,再执行其他线程。也就是说,阻塞其他的所有线程,所以其实应该是插队线程,所以 join 应该翻译成加入,插入?。

    不同于 sleep 和 yield 方法,join 不是静态方法,是一个普通方法,要通过一个具体的 Thread 对象才能调用 join。

    public class JoinDemo {
        public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(() -> {
                for (int i=0; i<100; i++){
                    System.out.println("myThread is joining" + i);
                }
            });
    
            t.start();
    
            for (int i=0; i<100; i++){
                if (i == 50){
                    t.join();//插队,此时主线程不能执行,而要执行 t
                }
                System.out.println("main is running" + i);
            }
        }
    }
    

    执行结果可以看出来,等到主线程执行到 i = 50后,t 线程完全执行,直到结束,才继续执行 main 线程。

    (当然,在 i = 50 之前,是不确定的,cpu 给两个线程的安排)

    join 的最重要的部分,就是插队可以保证,这个线程自己一定会先执行完,这是在很多地方需要的逻辑。

    四、利用枚举变量监控线程状态

    回过头看线程的状态转换图:

    在这里插入图片描述
    新生态、死亡态、除了阻塞内部,其他都已经进行了练习,其中,就绪态到运行态之间是不由程序员控制的,所以 java 给这两个状态了一个统一的名称叫 Runnable(不要和Runnable接口搞混)。

    java jdk 里面对于线程状态的区分:

    在这里插入图片描述

    1. NEW 对应没有 Started 的线程,对应新生态;
    2. RUNNABLE,对于就绪态和运行态的合称;
    3. BLOCKED,WAITING,TIMED_WAITING三个都是阻塞态:
      • sleep 和 join 称为WAITING,TIMED_WAITING(设置了时间的话);
      • wait 和 IO 流阻塞称为BLOCKED。
    4. TERMINATED 死亡态。

    我们用一个 demo 观察一下状态的切换过程:

    public class AllState {
        public static void main(String[] args) throws InterruptedException {
            //一个拥有阻塞的线程
            Thread t = new Thread(()->{
                for (int i=0; i<10; i++){
                    try {
                        Thread.sleep(200);//阻塞
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("........I am running.........");
                }
            });
    
            System.out.println(t.getState());//获取状态,此时应该是new
    
            t.start();
            System.out.println(t.getState());//获取状态,此时已经start
    
            //监控阻塞,设置结束条件为监控到 t 线程已经变成 Terminated
            while (!t.getState().equals(Thread.State.TERMINATED)){
                Thread.sleep(200);//主线程每200ms监控一次线程 t
                System.out.println(t.getState());
            }
        }
    }
    

    在这里插入图片描述
    从输出结果可以看到,从 开始的 new 到 runnable(start后),到有线程执行了 running 的runnable,到阻塞的 timed_waiting ,到恢复 runnable,到最终的结束 terminated。

    Thread 还提供了线程数方法,可以计数,结束条件其实还可以改成对于线程数的判断,因为当 t 结束后,线程数就只剩下主线程了

    while (Thread.activeCount() != 1){
        System.out.println(Thread.activeCount());
        Thread.sleep(200);//主线程每200ms监控一次线程 t
        System.out.println(t.getState());
    }
    

    然而,运行起来的时候输出显示的是 3 个线程:

    在这里插入图片描述
    最后 terminated 之后陷入了线程数是 2 的死循环,和预想的不一样。。。

    引入了另一个问题,搜了一下,应该是控制台输出,也是一个线程被监控的。

    展开全文
  • 使线程进入阻塞状态的方法

    千次阅读 2019-10-21 22:58:15
    sleep( ) 使线程在一定的时间内进入阻塞状态,不能得到cpu时间,但不会释放锁资源。指定的时间一过,线程重新进入可执行状态 wait( )使线程进入阻塞状态,同时释放自己占有的锁资源,和notify( )搭配使用 ...
    • sleep( ) 使线程在一定的时间内进入阻塞状态,不能得到cpu时间,但不会释放锁资源。指定的时间一过,线程重新进入可执行状态

    • wait( ) 使线程进入阻塞状态,同时释放自己占有的锁资源,和notify( )搭配使用

    • suspend( ) 使线程进入阻塞状态,并且不会自动恢复,必须其对应的resume( )被调用,才能使线程重新进入可执行状态

     

    区别:

    yield( ) 使得线程放弃当前分得的CPU时间,但是不使线程阻塞,即线程任然处于可执行状态,随时可能再次分得CPU时间。

    其中sleep(),suspend(),rusume(),yield()均为Thread类的方法,wait()为Object类的方法

    展开全文
  • 线程的几种状态转换

    千次阅读 2020-12-21 11:49:03
    线程在一定条件下,状态会发生变化。线程一共有以下几种状态:1、新建状态(New):新创建了一个线程对象。2、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态线程位于“可运行...
  • Java线程状态线程停止、线程阻塞

    千次阅读 2015-05-28 08:59:44
    Java线程状态线程停止、线程阻塞
  • 假设您询问Thread.State.BLOCKED和Thread.State.WAITING状态之间的区别(即,由t.getState()返回)?I want to know what is the difference on jvm level and what difference on the CPU从... WAITING线程和BLOCKED线...
  • 状态线程位于可运行线程池中,等待被线程调度选中,获取cpu 的使用权 。 3.运行(RUNNING):可运行状态(runnable)的线程获得了cpu 时间片(timeslice) ,执行程序代码。 4.阻塞(BLOCKED):阻...
  • 阻塞I/O在做I/O读写操作会使当前线程进入阻塞状态,而非阻塞I/O则不进入阻塞状态。对于线程,单线程情况下由一条线程负责所有客户端连接的I/O操作,而多线程情况下则由若干线程共同处理所有客户端连接的I/O操作。 ...
  • 而使用多线程一些线程发生阻塞的时候,另一些线程则仍能利用CPU,而不至于让CPU一直空闲。 利用CPU的多核并行计算能力 现在的CPU基本上都是多核的。使用多线程,可以利用多核同时执行多个线程,而不至于单线程时...
  • 你知道线程阻塞方式吗?

    千次阅读 2020-05-19 10:38:17
    sleep —— 让当前的正在执行的线程暂停指定的时间,并进入阻塞状态。在其睡眠的时间段内,该线程由于不是处于就绪状态,因此不会得到执行的机会。即使此时系统中没有任何其他可执行的线程,出于sleep()中的线程也...
  • 线程阻塞和中断

    2020-04-04 20:58:00
    阻塞和非阻塞是形容多个线程之间的相互影响的,一个线程占用了临界区资源,那么其他线程必须在临界区外等待,阻塞是操作系统层面挂起,上下文切换了,所以性能不高。如果一个线程一直占用不释放资源,那么其他需要该...
  • 线程安全问题,线程状态细化,synchronized的用法
  • 什么是线程阻塞? 在某一时刻某一个线程在运行一段代码的时候,这时候另一个线程也需要运行,但是在运行过程中的那个线程执行完成之前,另一个线程是无法获取到...1.睡眠状态一个线程执行代码的时候调用了slee...
  • 一个线程处于新建状态时,程序中的代码还没有开始运行。 就绪状态: 一个新建的线程并不能自动运行,要执行线程必须调用线程的start()方法。线程对象调用start()方法即启动了线程,start()方法创建线程运行...
  • Java中什么方法导致线程阻塞

    万次阅读 多人点赞 2018-03-24 16:45:41
    一、为什么引入线程阻塞机制? 为了解决对共享存储区的访问冲突,Java 引入了同步机制,现在让我们来考察多个线程对共享资源的访问,显然同步机制已经不够了,因为在任意时刻所要求的资源不一定已经准备好了被访问...
  • 线程共包括以下 5 种状态: 新建状态(New): 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。 ...调用线程对象start()方法便会进入就绪状态。处于就绪状态的线程,随时可能被CPU...阻塞状态
  • Java 线程阻塞、中断及优雅退出

    万次阅读 2017-06-12 19:54:17
    线程阻塞一个线程进入阻塞状态的原因可能如下(已排除Deprecated方法):sleep()sleep()使当前线程进入停滞状态(阻塞当前线程),让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源,以留一定时间给...
  • Python2:线程挂起和线程阻塞

    千次阅读 2019-08-29 17:11:31
    Python2:线程挂起和线程阻塞 ... 线程挂起操作实际上就是线程进入非可执行状态下,在这个状态下CPU不会分给线程时间片,“线程挂起“用来暂停一个线程的执行,”线程挂起“后通过唤醒线程使之恢复运行。 挂起...
  • 使用 Java 阻塞 I/O 模型读取数据,将会导致线程阻塞线程将会进入休眠,从而让出 CPU 的执行权,直到数据读取完成。这个期间如果使用 jstack 查看线程状态...
  • java多线程试题_答案

    千次阅读 2021-03-07 14:26:37
    下列哪个一个操作不能使线程从等待阻塞状态进入对象阻塞状态(D)A.等待阴塞状态下的线程被notify()唤B.等待阻塞状态下的纯种被interrput()中断C.等待时间到D.等待阻塞状态下的线程调用wait()方法3.下列哪个方法可以使...
  • Java中实现线程阻塞的方法

    千次阅读 2020-06-23 17:56:51
    使线程转到阻塞状态睡眠结束后,就转为就绪(Runnable)状态。sleep()平台移植性好。 线程等待:Object类中的wait()方法 导致当前的线程等待,直到其他线程调用此对象的 notify() 唤醒方法。wait() 使得线程
  • 线程阻塞怎么结束

    千次阅读 2017-08-10 13:01:00
    线程有read, accept 之类阻塞的函数,如果主程序退出没有及时让子线程退出,子线程会奔溃。 解决方法:close 函数关闭对应的fd, 阻塞函数就会退出
  • 线程状态及join方法

    2020-05-20 14:51:09
    线程运行状态包括新建状态、就绪状态、运行状态、阻塞状态及死亡状态。 New (新创建)  用new操作符创建一个线程时,如new Thread(r),该线程还没有开始运行。这意味它的状态是new。此时程序还没有开始运行线程...
  • 线程与进程的阻塞 线程阻塞 线程在运行的过程中因为某些...此时引起进程调度,OS把处理机分配给另一个就绪进程,而让受阻进程处于暂停状态,一般将这种状态称为阻塞状态。 进程的挂起 挂起进程在操作系统中可以定义为暂
  • Java 中如何唤醒阻塞线程

    千次阅读 2021-02-28 11:59:50
    如果线程是因为调用了wait()、sleep()或者join()方法而导致的阻塞,可以中断线程,并且通过抛出... sleep() 方法sleep(毫秒),指定以毫秒为单位的时间,使线程在该时间内进入线程阻塞状态,期间得不到cp...
  • 线程阻塞与挂起

    千次阅读 2019-06-22 09:25:15
    阻塞:一般是被动的,在抢占资源中得不到资源,被动的挂起在内存,等待某种资源或信号量(即有了资源)将他唤醒。(释放CPU,不释放内存) 另外,有一段话很形象: 首先这些术语都是对于线程来说的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 192,249
精华内容 76,899
关键字:

当线程处于阻塞状态时