精华内容
下载资源
问答
  • 线程sleep方法
    2020-10-21 20:12:00
    package com;
    
    /**
     * 关于sleep();
     * static void sleep (long millis)
     * 1、静态方法:Thread.sleep(1000);
     * 2、参数是毫秒
     * 3、作用是:让当前的线程进入休眠,进入”阻塞状态“,放弃占用cpu时间片,让其线程使用。
     * 这行代码出现A线程中,A线程就会进入休眠
     * 这行代码出现B线程中,B线程就会进入休眠。
     * 4、Thread.sleep方法的效果:
     * 间隔特定时间,去执行一段特定的代码,每隔多久去执行一次。
     */
    public class Test {
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
    
                //睡眠1s
                try {
                    Thread.sleep(1000);
    
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //  System.out.println("HelloWorld");//5s后执行
    
            }
        }
    }
    

    终止sleep()方法

    package com;
    
    /**
     * 怎么终止正在睡眠的的线程?
     * 注意这个不是终端线程的执行。是终止线程的睡眠。
     */
    public class Test {
        public static void main(String[] args) {
            Thread t = new Thread(new MyThread());
            t.setName("t");
            t.start();
    
    
            //希望5s后, t线程醒来。。
            try {
                Thread.sleep(1000*5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            //中断t线程的睡眠(这种中断睡眠的方式s是依靠了java的异常机制)
            t.interrupt();//干扰
        }
    }
    
    class MyThread implements Runnable {
        //重点:run方法中的异常不能throws,只能try..catch
        //因为run()方法中的父类中没有抛出任何异常,子类不能比父类,抛出更多的异常。
        public void run() {
            System.out.println(Thread.currentThread().getName() + "----->" + "begin");
            //睡眠一年
            try {
                Thread.sleep(1000 * 60 * 60 * 24 * 365);
            } catch (InterruptedException e) {
                //打印异常信息
                e.printStackTrace();
    
            }
            System.out.println(Thread.currentThread().getName() + "----->" + "end");
        }
    }
    

    结果

    t----->begin
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at com.MyThread.run(Test.java:33)
    	at java.lang.Thread.run(Thread.java:745)
    t----->end
    

    强行终止一个线程执行

    package com;
    
    /**
     * 在java中怎么强行终止一个线程执行?
     *  这种方式存在很大缺点,容易丢失数据,因为这种直接将线程杀死。
     *  线程没有保存数据,会丢失。
     *
     */
    public class Test {
        public static void main(String[] args) {
            Thread t = new Thread(new MyThread());
            t.setName("t");
            t.start();
    
    
            //希望5s后, t线程醒来。。
            try {
                Thread.sleep(1000*5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            //5s后强行终止t线程
            t.stop();//已经过时,不建议使用。
        }
    }
    
    class MyThread implements Runnable {
    
        public void run() {
            for (int i = 0; 1 <10 ; i++) {
                System.out.println(Thread.currentThread().getName()+"--->"+"begin");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }
        }
    }
    

    合理的终止一个线程的执行

    package com;
    
    public class Test {
        public static void main(String[] args) {
            MyThread r = new MyThread();
            Thread t1 = new Thread(r);
            t1.setName("t");
            t1.start();
    
    
            //希望5s后, t线程醒来。。
            try {
                Thread.sleep(1000 * 5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //终止线程
            //你想要什么时候结束,把标记为false,就结束。
            r.run = false;
        }
    }
    
    class MyThread implements Runnable {
        //打一个布尔标记
        boolean run = true;
    
        public void run() {
            for (int i = 0; 1 < 10; i++) {
    
                if (run) {
                    System.out.println(Thread.currentThread().getName() + "--->" + "begin");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
                    }
                } else {
                    //在这里保存
                    //终止当前程序
                    return;
                }
            }
        }
    }
    

    sleep面试题

    package com;
    
    
    public class Test {
        public static void main(String[] args) {
                //创建线程对象
            MyThread myThread=new MyThread();
            myThread.setName("t");
            myThread.start();
                //调用sleep方法
            /**
             * 这段代码会不会让t休眠?
             * 不会
             */
            try {
                myThread.sleep(1000*5);//这段代码让main线程休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//5s后才会执行
            System.out.println("HelloWorld");
        }}
        class MyThread extends Thread{
        public void run(){
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"---->"+i);
            }
        }
        }
    

    线程合并
    join();

    package com;
    
    public class Test {
        public static void main(String[] args) {
            Thread t = new Thread(new Thread1());
            t.setName("t");
            t.start();
            //合并线程
            try {
                t.join();//t合并到当前线程,当前线程受阻塞,t线程执行直到结束
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("main over");
        }
    }
    
    
    class Thread1 implements Runnable {
    
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+i);
            }
        }
    }
    
    更多相关内容
  • Java线程阻塞方法sleep()和wait()精炼详解

    万次阅读 多人点赞 2018-04-10 22:53:58
    sleep()和wait()方法都是Java中造成线程阻塞方法。感兴趣的读者可以参见笔者之前的文章《Java中什么方法导致线程阻塞》,里面详细讲述了为什么Java要造成线程阻塞和Java中造成线程阻塞的几种方法线程的生命...

    一、前期基础知识储备

    sleep()和wait()方法都是Java中造成线程阻塞的方法。感兴趣的读者可以参见笔者之前的文章《Java中什么方法导致线程阻塞》,里面详细讲述了为什么Java要造成线程阻塞和Java中造成线程阻塞的几种方法。

    线程的生命周期

    这是笔者在谷歌图片中找到的一张简单描述线程生命周期的图片,可以看到,一个线程正常的生命周期中会经历“创建”“就绪”“运行”“阻塞”“运行”“死亡”等几个生命周期,其中“阻塞”是我们开发者非常需要关注的,因为通过Java提供的阻塞方法,可以做到资源和线程最合理的调配,而其中sleep()和wait()方法就是Java中实现线程阻塞的关键性方法。

    (2)sleep()和wait()方法的阻塞线程的场景

    我们这里,来看第二张图片,这张图片就比较详细的向我们展现了一个线程的完整生命周期中发生的各种“事件”和调用的各种方法。我们来总结一下sleep()和wait()方法的阻塞场景。

    ①sleep()实现线程阻塞的方法,我们称之为“线程睡眠”,方式是超时等待,怎么理解?就是sleep()通过传入“睡眠时间”作为方法的参数,时间一到就从“睡眠”中“醒来”;

    wait()方法实现线程阻塞的方法,我们称之为“线程等待”,方式有两种:

    1)和sleep()方法一样,通过传入“睡眠时间”作为参数,时间到了就“醒了”;

    2)不传入时间,进行一次“无限期的等待”,只用通过notify()方法来“唤醒”。

    二、sleep()和wait()的区别

    通过上面两幅图的展示和笔者的相关描述,相信读者你已经有几分清楚了,sleep()和wait()方法的区别之一,就是实现线程阻塞的方式不一样。

    那么sleep()和wait()二者还有一个很大的区别就是,二者“是否释放同步锁”不一样。我们都知道,多线程开发中,为了实现不同线程间的同步会采用同步锁的方式——synchronized即在线程使用一个资源时为其加锁,这样其他的线程便不能访问那个资源了,直到解锁后才可以访问。感兴趣的读者可以参考笔者之前文章《利用synchronized实现线程同步》里面详细介绍了多线程开发中利用synchronized实现线程同步的方式。

    而使用sleep()和wait()两种方法对于“CPU执行权”和“同步锁”的方式不同:

    sleep()释放CPU执行权,但不释放同步锁

    wait()释放CPU执行权,也释放同步锁,使得其他线程可以使用同步控制块或者方法

    以上,就是sleep()和wait()方法的两个关键性区别

     

    总结:综上我们利用下表展示sleep()和wait()的所有区别:

    ps:谢谢博友的更正。这里进行改正: wait()为Object基类中的方法,调用时亦需要捕获异常,以下为wait()可能抛出的异常:

    PS:能用图说明的问题,我们就用图来说明,能用表说明的问题,我们就用表来说明,这样理解起来非常清晰。

     

     

    展开全文
  • Java线程中的sleep方法详解

    千次阅读 2021-03-14 20:19:09
    关于线程sleep方法 static void sleep(long mills) 1、静态方法:Thread.sleep(1000); 2、参数是毫秒 3、作用:让当前线程进入休眠,进入“阻塞”状态,放弃占有CPU时间片,让给其他线程使用。 public class ...

    1、关于线程的sleep方法

    static void sleep(long mills)

    • 1、静态方法:Thread.sleep(1000);
    • 2、参数是毫秒
    • 3、作用:让当前线程进入休眠,进入“阻塞”状态,放弃占有CPU时间片,让给其他线程使用
    public class ThreadTest06 {
        public static void main(String[] args) {
            //让当前线程进入休眠,睡眠5秒
            //当前线程是主线程!!!
            try {
                Thread.sleep(1000*5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
    		//5秒之后执行这里的代码
            System.out.println("hello world!");
        }
    }
    
    

    2、分析哪个线程休眠的

    以下代码是让main方法休眠

    public class ThreadTest06 {
        public static void main(String[] args) {
            Thread t = new MyThread();
            t.setName("t");
            t.start();
            //调用sleep方法
            try {
                //
                t.sleep(1000*5);//在执行过程中还是会被转换为:Thread.sleep(1000*5);
                //这行代码的作用是:让当前的线程进入休眠,也就是说说main线程进入休眠。
                //这样代码出现在main方法中,main线程休眠。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("hello world!");
        }
    }
    class MyThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
    }
    

    3、终止线程的休眠

    sleep睡眠太久了,如果希望半道上醒来,可以使用interrupt()方法
    注意:这个不是终断线程的执行,是终止线程的睡眠

    public class ThreadTest07 {
        public static void main(String[] args) {
    
            Thread t = new Thread(new MyRunable2());
            t.setName("t");
            t.start();
    
            //希望5秒以后,t线程醒来(5秒以后主线程的活干完了)
            try {
                Thread.sleep(1000*5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            //终断t线程的睡眠(这种终断睡眠的方式依靠了java的异常处理机制。)
            t.interrupt();//干扰,一盆冷水过去!!
        }
    }
    
    class MyRunable2 implements Runnable{
        //重点:run()当中的异常不能throws,只能try..catch
        //因为run()方法在父类中没有抛出异常,子类不能比父类抛出更多异常。
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "--> begin");
            try {
                //睡眠1年
                Thread.sleep(1000*60*60*24*365);
            } catch (InterruptedException e) {
                //打印异常信息
                e.printStackTrace();
            }
            //一年之后才会执行这里
            System.out.println(Thread.currentThread().getName() + "--> end");
        }
    }
    

    在这里插入图片描述

    4、终止线程

    强行终止线程

    stop()方法,有一个很大的缺点:容易丢失数据。因为这种方式是直接将线程杀死了。
    线程没有保存的数据将会丢失。不建议使用。

    合理的终止线程

    打一个boolean标记

    public class ThreadTest08 {
        public static void main(String[] args) {
            Thread t = new Thread();
            MyRunnable4 r = new MyRunnable4();
            t.setName("t");
            t.start();
    
            //模拟5秒
            try {
                Thread.sleep(1000 * 5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            //终止线程
            //你想要什么时候终止t的执行,那么你把标记修改为false,就结束了。
            r.run = false;
        }
    }
    class MyRunnable4 implements Runnable{
    
        //打一个boolean标记
        boolean run = true;
    
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                if (run){
                    System.out.println(Thread.currentThread().getName() + "-->" + i);
                    try {
                        Thread.sleep(1000 );
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                }else {
                    //return就结束了,在结束之前还有什么没有保存的。
                    //可以在这里保存
                    //save....
                    return;
                }
            }
        }
    }
    
    展开全文
  • Java多线程之-Sleep方法详解

    千次阅读 2019-11-13 15:31:52
    sleep方法详解 作用:我只想让线程在于其的时间执行,其他时候不要占用CPU资源。 特点 不释放锁 包括synchronize 和lock 和wait不同 public class SleepDontReleaseMonitor implements Runnable { public ...

    sleep方法详解

    • 作用:我只想让线程在于其的时间执行,其他时候不要占用CPU资源。
    • 特点
      • 不释放锁 包括synchronize 和lock 和wait不同
    public class SleepDontReleaseMonitor implements Runnable {
    
        public static void main(String[] args) {
            SleepDontReleaseMonitor sleepDontReleaseMonitor = new SleepDontReleaseMonitor();
            Thread thread1 = new Thread(sleepDontReleaseMonitor);
            Thread thread2 =new Thread(sleepDontReleaseMonitor);
            thread1.start();
            thread2.start();
        }
        public void run() {
            syn();
        }
    
        private synchronized void syn()  {
            System.out.println("线程" + Thread.currentThread().getName()+"获取到monitor。");
            try{
                Thread.sleep(5000);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("线程" + Thread.currentThread().getName()+"睡眠结束。退出同步代码块");
        }
    }
    

    在这里插入图片描述
    可以看出线程在sleep()时并不会把锁给释放。


    Sleep 同时也并不会释放Lock锁

    public class SleepDontReleaseLcok implements  Runnable {
        private static final Lock lock = new ReentrantLock();
        public void run() {
            lock.lock();
            System.out.println("线程" +Thread.currentThread().getName() +"获取到了锁");
            try {
                Thread.sleep(5000);
                System.out.println("线程" +Thread.currentThread().getName() +"已经唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
    
        }
    
        public static void main(String[] args) {
            SleepDontReleaseLcok sleepDontReleaseLcok = new SleepDontReleaseLcok();
            Thread  thread1 = new Thread(sleepDontReleaseLcok);
            Thread  thread2 = new Thread(sleepDontReleaseLcok);
            thread1.start();
            thread2.start();
        }
    }
    

    sleep方法响应中断

    1. 抛出InterruptedException
    2. 清除中断状态
    public class SleepInterrupt implements  Runnable{
        public static void main(String[] args) throws InterruptedException {
            Thread thread1 =  new Thread(new SleepInterrupt());
            thread1.start();
            Thread.sleep(6500);
            thread1.interrupt();
    
        }
    
        public void run() {
            for(int i =0;i<10;i++){
                System.out.println(new Date());
                try{
                    //sleep7小时 5 分钟 3秒
                    TimeUnit.HOURS.sleep(7);
                    TimeUnit.SECONDS.sleep(5);
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    System.out.println("被中断了!");
                    e.printStackTrace();
                }
    
            }
        }
    }
    

    在这里插入图片描述

    sleep方法可以让线程进入Watting状态,并且不占用CPU资源,但是不释放锁,直到规定时间后再执行,休眠期间如果被中断,会抛出异常并清除中断状态。

    sleep方法—常见面试问题

    wait/notify、sleep异同

    • 相同
      • 阻塞(都会阻塞线程)
      • 响应中断(都会相应线程中断 并清除中断状态)
    • 不同
      • 同步方法中(wait/notify 必须在同步方法块 中 而sleep不需要 为什么?线程更安全防止死锁和永久等待)
      • 释放锁(wait会释放锁 但是sleep不会)
      • 指定时间(sleep 要指定时间)
      • 所属类(wait/notify 属于Object 类 sleep 属于Thread类 为什么放Object类? java设计每一个类都是一把锁 对象头都有记录锁的字段)
    展开全文
  • Java中的线程让步会让线程让出优先级,而休眠则会让线程进入阻塞状态等待被唤醒,这里我们对比线程等待的wait()方法,来详解Java中的线程让步yield()与线程休眠sleep()方法
  • 文章目录sleep方法响应中断使用TimeUnit.SECONDS.sleep()方法的好处对于sleep的总结sleep面试问题 sleep方法响应中断 sleep方法响应中断 的时候, 会做两件事情, 抛出InterruptedException 清除中断状态. 如下的...
  • 一、前期基础知识储备sleep()和wait()方法都是Java中造成线程阻塞方法。感兴趣的读者可以参见笔者之前的文章《Java中什么方法导致线程阻塞》,里面详细讲述了为什么Java要造成线程阻塞和Java中造成线程阻塞的几种...
  • sleep方法指定当前线程阻塞的毫秒数; sleep存在异常interInterruptedException需要抛出; sleep时间达到后,线程进入就绪状态; sleep可以模拟网络延迟,倒计时; 每一个对象都有一把锁,sleep不会释放锁; 关于锁...
  • //java多线程中的sleep方法,这是一个手动给线程阻塞的一个方法,当调用sleep方法线程从运行到阻塞阻塞时间过后到就绪状态。sleep是一个静态方法因此直接通过Thread调用他与线程对象名无关。 //下面代码中有...
  • sleep()方法是来自Thread类的静态方法,是线程用来控制自身流程的,它会使某个线程阻塞一段时间,等计时时间一到,此线程就会自动“苏醒”。而wait()方法是来自Object类的方法,用于线程间的通信,它也可以使线程...
  • 线程可以使用等待wait()实现被阻塞,这属于条件等待的方式,当条件满足后,又会从阻塞转为等待状态。尽管可以在等待wait()条件那里放一个超时设置,但等待wait()的设计目的不是这样的,等待wait()在设计上是用于...
  • sleep(毫秒),指定以毫秒为单位的时间,使线程在该时间内进入线程阻塞状态,期间得不到cpu的时间片,等到时间过去了,线程重新进入可执行状态。(暂停线程,不会释放锁,睡眠结束,线程继续执行,线程自动释放锁)...
  • C++ 11之前并未提供专门的休眠函数。...从C++11开始,中C++标准库提供了专门的线程休眠函数,使得你的代码可以独立于不同的平台。 std::this_thread::sleep_for std::this_thread::sleep_untill 1. 让线
  • 目录   一、 sleep()和wait()方法的区别 sleep()方法 wait()方法 ...二、线程阻塞BLOCKED和等待WAITING的区别 ...sleep()方法是Thread类的方法,通过其定义可知是个native方法,在指定的时间内阻塞线程...
  • 最近有小伙伴在工作中遇到了java线程阻塞问题,面对这样的问题,大家束手无策,不知道从何下手,那么今天我们就给大家分享一些关于java避免线程阻塞方法阻塞指的是暂停一个Java线程同步的执行以等待某个条件发生...
  • 当某线程A处于Sleep状态时,另一个线程B调用了B.interrupt()方法,打断了A的Sleep过程,则A的Sleep会抛出异常。使用Catch后,线程不会等待Sleep时间,而是会立即执行。 下面的例子中,线程1的Sleep会被线程2打断,...
  • 1.线程中不使用sleep,不会造成线程切换问题。 2.线程中使用sleep,会使cpu的占有率降低。让其他线程或进程,运行得更有效。 3.使用sleep(0)和不使用sleep,效果差别不大,都不会使cpu睡眠。usleep(0)和usleep(1)...
  • 线程在运行的过程中因为某些原因而发生阻塞阻塞状态的线程的特点是:该线程放弃CPU的使用,暂停运行,只有等到导致阻塞的原因消除之后才回复运行,或者是被其他的线程中断,该线程也会退出阻塞状态,同时抛出...
  • 会使线程阻塞方法

    2021-09-08 20:59:05
    sleep( ) 使线程在一定的时间内进入阻塞状态,不能得到cpu时间,但不会释放锁资源。指定的时间一过,线程重新进入可执行状态 wait( ) 使线程进入阻塞状态,同时释放自己占有的锁资源,和notify( )搭配使用 suspend( ...
  • C++线程同步——阻塞线程方法

    千次阅读 2021-08-29 21:09:05
    sem_wait() 会阻塞当前线程 sem_trywait() 返回错误而不是阻塞调用 sem_timedwait() sem_timedwait的abs_timeout参数指定了调用应该阻塞的时间限制 信号量 信号量 (semaphore) 是一种轻量的同步原件,用于制约对...
  • 新建状态:刚new出来的状态。 就绪状态:调用start方法进入就绪状态。又 叫做可运行状态。 具有抢夺CPU时间片的权利 ,当一个线程抢到CPU时间片后,进入运行状态。开始执行run方法
  • 1、线程是靠cpu来运行的,cpu要运行一个线程,(不说别的)最起码就是要占用cpu时间,像Windows这样的多任务操作系统,可以允许多个线程同时运行,所谓的同时运行并不是真正的同时运行,而是轮流运行不同的线程,...
  • 线程sleep()和wait()的区别

    万次阅读 多人点赞 2019-04-26 10:32:27
    Java多线程是一种抢占式的机制,线程主要有以下几种状态:可运行,运行,阻塞,死亡。抢占式机制指的是有多个线程处于可运行状态,但是只有一个线程在运行。当有多个线程访问共享数据的时候,就需要对线程进行同步。...
  • There are multiple ways to pause or stop the execution of currently running thread, but putting the thread into sleep state usingThread.sleep()method is the right way to introduce pause. Some people.....
  • 线程sleep和wait的区别

    千次阅读 2019-06-19 17:19:43
    线程sleep和wait的区别 1、sleep方法是Thread类的静态方法,wait()是Object超类的成员方法 2、sleep()方法导致了程序暂停执行指定的时间,让出cpu该其他线程,但是他的监控状态依然保持者,当指定的时间到了又会自动...
  • MySQL线程阻塞处理方法

    千次阅读 2020-08-21 20:28:40
    MySQL线程阻塞处理方法 ​ by 樂小生 出现的错误: ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction 解决办法: 查看sleep的进程 mysql> ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 229,451
精华内容 91,780
关键字:

线程sleep方法造成阻塞如何解决