精华内容
下载资源
问答
  • Java线程休眠

    2019-05-10 17:42:56
    线程休眠: 在当前线程的执行中,暂停指定的毫秒数,释放CPU的时间片 作用: 没有线程的休眠,我们无法控制多个线程的运行顺序, 当有休眠时,我们可以可控制线程的执行顺序,干涉CUP执行的时间,到达我们想...

    线程休眠:

    在当前线程的执行中,暂停指定的毫秒数,释放CPU的时间片

    作用:

     没有线程的休眠,我们无法控制多个线程的运行顺序,

    当有休眠时,我们可以可控制线程的执行顺序,干涉CUP执行的时间,到达我们想要的目的

    休眠方法: 

    public static native void sleep(long millis) ;

    以毫秒为单位,millis为负数 抛出异常IllegalArgumentException

    public static void sleep(long millis, int nanos) ;

    以毫秒,纳秒为单位。更加精确

    public static native Thread currentThread(); 

    返回当前正在执行的线程对象的引用

    例:Thread.currentThread().getName();获取当前正在执行的线程名

     

    展开全文
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。下面通过实例代码给大家介绍Java线程休眠的知识,需要的朋友参考下吧
  • java线程休眠方法详解

    千次阅读 2018-04-13 22:54:47
    ------------------------------------java线程休眠方法详解--------------------- 线程的休眠 线程的休眠是很必要,在做服务器端的时候为了减少服务器的压力我们需要休眠。 如果休眠是在同步代码中执行,休眠...

    ------------------------------------java线程休眠方法详解---------------------

     

    线程的休眠

      

    线程的休眠是很必要,在做服务器端的时候为了减少服务器的压力我们需要休眠。

     

    如果休眠是在同步代码中执行,休眠不会让出锁对象。

     

    public  class SaleTicket implements Runnable{

        // 因为是共享对象所以不用静态属性

        private  int tickets = 10;

     

        //创建一个同步锁

        private Object obj = new Object();

       

        @Override

        public void run() {

            while (true) {

               //同步代码块

               synchronized (this) {

                   try {

                       //测试线程在休眠的时候会不会让出同步锁

                       Thread.sleep(10);

                       System.out.println("-----------");

                   } catch (InterruptedException e) {

                       e.printStackTrace();

                   }

                   if (tickets > 0) {

                       System.out.println(Thread.currentThread().getName()+ "正在买票" + tickets-- + "张票");

                   } else {

                       System.out.println("票已售完");

                       break;

                   }

               }

            }

        }  

    }

      

    --------------------------------------------------------

     

    public  class SleepTest {

     

        public  static  void main(String[] args) {

    /*      SleepDemo sd = new SleepDemo();

            Thread t = new Thread(sd);

            t.start();*/

            SaleTicket st = new SaleTicket();

            Thread t = new Thread(st,"窗口1");

            Thread t1 = new Thread(st,"窗口2");

           

            t.start();

            t1.start();

           

    /*      -----------

            窗口1正在买票10张票

            -----------

            窗口1正在买票9张票

            -----------

            窗口1正在买票8张票

            -----------

            窗口1正在买票7张票

            -----------

            窗口1正在买票6张票

            -----------

            窗口1正在买票5张票

            -----------

            窗口1正在买票4张票

            -----------

            窗口2正在买票3张票

            -----------

            窗口2正在买票2张票

            -----------

            窗口2正在买票1张票

            -----------

            票已售完

            -----------

            票已售完*/

        }

    }

     

    展开全文
  • 线程休眠(sleep方法) 线程休眠:让线程暂缓执行,等到预计时间之后再恢复执行。 线程休眠会交出cpu,让cpu去执行其他任务,但是不会释放锁。 比如:当前线程sleep休眠了,但是如果此线程在休眠前持有某个对象的锁,...

    线程休眠(sleep方法)

    线程休眠:让线程暂缓执行,等到预计时间之后再恢复执行。

    线程休眠会交出cpu,让cpu去执行其他任务,但是不会释放锁。
    比如:当前线程sleep休眠了,但是如果此线程在休眠前持有某个对象的锁,那就算它休眠了其他线程也不能获取到这个对象的锁。

    注意:调用sleep结束后线程会重新回到就绪状态,只需要等待获取cpu执行就可以。

    方法:

    public static native void sleep(long millis) throws InterruptedException
    

    休眠的时间是以毫秒为单位
    使用:

    class MyThread implements Runnable{
        @Override
        public void run() {
            for(int i = 0; i < 5; i++){
                try {
                    sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+" i=" + i);
            }
        }
    }
    
    public class Test{
        public static void main(String[] args){
            MyThread myThread = new MyThread();
            new Thread(myThread).start();
            new Thread(myThread).start();
            new Thread(myThread).start();
        }
    }
    

    线程让步(yield()方法)

    yield():暂停当前正在执行的线程对象,并执行其他线程。

    线程让步会交出cpu权限,让cpu去执行其他的线程。和sleep方法类似,同样不会释放锁,但是yield不能控制具体交出cpu的时间,并且,yield方法只能让拥有相同优先级的线程有获取cpu执行的机会。

    注意:调用yield结束后线程会重新回到就绪状态,只需要等待获取cpu执行就可以。

    使用:

    class MyThread implements Runnable{
        @Override
        public void run() {
            for(int i = 0; i < 5; i++){
                Thread.yield();
                System.out.println(Thread.currentThread().getName()+" i=" + i);
            }
        }
    }
    
    public class Test{
        public static void main(String[] args){
            MyThread myThread = new MyThread();
            new Thread(myThread).start();
            new Thread(myThread).start();
            new Thread(myThread).start();
        }
    }
    

    等待其他线程终止-join()方法

    意思就是说如果在主线程中调用这个方法时会让主线程休眠,让调用该方法的线程run方法先执行完毕后再开始执行主线程。
    在这里插入图片描述
    join放发实际上是对wait方法的封装。

    我们来看join的源码

    public final void join() throws InterruptedException {
            join(0);
        }
    

    我们可以看到join方法实际上是调用了join(0);

    join(long millis)方法如下:

    
        public final synchronized void join(long millis)
        throws InterruptedException {
            long base = System.currentTimeMillis();
            long now = 0;
    
            if (millis < 0) {
                throw new IllegalArgumentException("timeout value is negative");
            }
    
            if (millis == 0) {
                while (isAlive()) {
                    wait(0);
                }
            } else {
                while (isAlive()) {
                    long delay = millis - now;
                    if (delay <= 0) {
                        break;
                    }
                    wait(delay);
                    now = System.currentTimeMillis() - base;
                }
            }
        }
    

    从上面我们可以提取出join(0)调用的部分代码;如下:

    if (millis == 0) {
                while (isAlive()) {//判断当前线程是否为Running状态
                    wait(0);
                }
    

    从上面可以看出如果调用此方法的线程是正在运行的线程,那么就会调用wait(0)方法,

    关于wait()的源码:

        public final native void wait(long timeout) throws InterruptedException;
    
    

    wait(long timeout)是一个本地方法,调用本机的原生系统函数,当Thread类被加载到JVM中的时候,它就会调用注册相应的本地方法。
    wait(0)就是让其他线程一直在等待,当此线程终止时,会调用线程自身的notifyAll()方法,唤醒所有等待在该线程对象上的线程。

    使用:

    public class Test{
        public static void main(String[] args) throws InterruptedException {
    
            final Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("t1");
                }
            });
            final Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        t1.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t2");
                }
            });
            final Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        t2.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t3");
                }
            });
    
            t1.start();
            t3.start();
            
            t2.start();
    
    
        }
    }
    

    运行结果:

    t1
    t2
    t3
    

    当t2比t3start时间迟的时候,出现下面结果

    public class Test{
        public static void main(String[] args) throws InterruptedException {
    
            final Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("t1");
                }
            });
            final Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        t1.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t2");
                }
            });
            final Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        t2.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t3");
                }
            });
    
            t1.start();
            t3.start();
            Thread.sleep(2000);//让主线程休眠2秒,那么在t3调用join时t2还不是运行状态
            t2.start();
    
    
        }
    }
    

    运行结果如下:

    t1
    t3
    t2
    

    这就是因为join(0)中调用了

    if (millis == 0) {
                while (isAlive()) {//判断当前线程是否为Running状态
                    wait(0);
                }
    

    因为t2不处于运行状态所以不会执行wait(0),所以t3就不会等待,直接运行下一条语句。

    展开全文
  • !... 为什么啊,按道理两个线程变量间应该不存在关系,同时实例化2个也...如果不在上一个线程休眠时实例化下一个线程,就不会出现上述问题![图片说明](https://img-ask.csdn.net/upload/201705/01/1493609121_900585.png)
  • Java线程休眠(sleep)示例

    万次阅读 2014-05-25 15:48:37
    java.lang.Thread的sleep()方法能使当前线程暂停运行一段时间(单位毫秒)。需要注意的是,sleep()方法的参数不能为负,否则会抛出IllegalArgumentException异常。  除此之外,还有另一个方法sleep(long millis, ...

        java.lang.Threadsleep()方法能使当前线程暂停运行一段时间(单位毫秒)。需要注意的是,sleep()方法的参数不能为负,否则会抛出IllegalArgumentException异常。

        除此之外,还有另一个方法sleep(long millis, int nanos),该方法可用于使当前线程暂停millis毫秒nanos纳秒。需要注意的是,参数nanos的取值范围为[0, 999999]。

        下面的代码演示如何用Thread.sleep()方法令主线程暂停执行2秒。

        ThreadSleep.java

    package com.journaldev.threads;
    
    public class ThreadSleep {
        public static void main(String[] args) throws InterruptedException {
            long start = System.currentTimeMillis();
            Thread.sleep(2000);
            System.out.println("Sleep time in ms = " + (System.currentTimeMillis()-start));
        }
    }
        如果你运行上述程序,你会发现最后打印出来的结果会比2000略多一些,这取决于线程休眠是如何实现的,以及操作系统定义的线程调度机制。

    线程休眠要点

    1. 线程休眠总是暂停当前线程

    2. 在被唤醒并开始执行前,线程休眠的实际时间取决于系统计时器和调度器。对比较清闲的系统来说,实际休眠的时间十分接近于指定的休眠时间,但对于繁忙的系统,两者之间的差距就较大。

    3. 线程休眠并不会丢失当前线程已获取的任何监视器和锁。

    4. 其他线程可以中断当前进程的休眠,但会抛出InterruptedException异常。

    线程休眠的工作原理

        Thread.sleep()与线程调度器交互,它将当前线程设置为等待一段时间的状态。一旦等待时间结束,线程状态就会被改为可运行(runnable),并开始等待CPU来执行后续的任务。因此,当前线程的实际休眠时间取决于线程调度器,而线程调度器则是由操作系统来进行管理的。


    原文地址:Java Thread Sleep Example

    展开全文
  • java线程休眠(sleep)

    千次阅读 2015-03-27 09:11:17
    表示让一个线程进入睡眠状态,等待一定的时间之后,自动醒来进入到可运行状态,不会马上进入运行状态,因为线程调度机制恢复线程的运行也需要时间,一个线程对象调用了sleep方法之后,并不会释放他所持有的所有对象...
  • package practice; public class WaitNotifyCase { ... new Thread() { // 匿名内部类创建多线程A @Override public void run() { for (int i = 0; i < 3; i++) { // 循环执行三次等待与唤醒
  • Java线程休眠Thread.sleep()(2)

    万次阅读 2017-12-14 17:13:32
    源地址 ...Thread.sleep()方法能够已毫秒为时间单位暂停当前执行的线程,参数值为毫秒不能为负数,否则将抛出IllegalArgumentException异常。 这里有另一个重载的方法sleep(long mi
  • 主要介绍了Java线程调度之线程休眠用法,较为详细的分析了Java线程休眠的功能与实现技巧,需要的朋友可以参考下
  • 主要介绍了Java线程休眠编程实例,本文直接给出代码实例,并对休眠方法做了一番讲解,需要的朋友可以参考下
  • 改案例是一个小程序,主要适合java初学者。这个案例主要是实现java多线程对线程休眠的操作
  • 本文对javaThread中sleep()方法进行介绍,sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”,大家参考使用吧
  • 线程休眠 pulibc static void sleep(long time): 让线程按指定时间休眠, 单位为毫秒 因为是静态方法,所以可以通过Thread.sleep()调用
  • 线程休眠 java 1615477264

    2021-03-11 23:44:09
    线程休眠 java 1615477264 关于 案例 线程类 测试类 结果
  • java多线程--线程休眠

    千次阅读 2016-06-23 10:50:02
    sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,...
  • java线程之sleep方法 sleep方法指定当前线程阻塞的毫秒数; sleep存在异常interInterruptedException需要抛出; sleep时间达到后,线程进入就绪状态; sleep可以模拟网络延迟,倒计时; 每一个对象都有一把锁,...
  • Java-线程休眠

    2019-02-25 13:27:06
    package yexin.sogou.java;/** * Company: Huazhong University of science and technology * 华中科技大学电气学院聚变与等离子体研究所 * Version: V1.0 * Author: Victor * Contact: 1650996069@qq....
  • Java并发-线程休眠

    2018-04-06 08:05:32
    Java提供了两种方式来实现线程休眠: Thread.sleep(long time) TimeUnit.SECONDS.sleep(long time) 其中,TimeUnit的JDK1.5引入的,并且也是推荐使用的,因为它提供来更好的可读性。 public class SleepDemo ...
  • 07Java多线程-4. 线程API之线程休眠*
  • Java中的线程休眠大法系列(总结)

    千次阅读 2021-06-15 14:37:08
    文章目录前言一、通过一个表格,做对比二、...Java中的线程休眠大法系列(一)Thread.sleep() Java中的线程休眠大法系列(二)Object.wait() Java中的线程休眠大法系列(三)LockSupport.park() 欢迎点赞收藏!! ...
  • Java中的线程让步会让线程让出优先级,而休眠则会让线程进入阻塞状态等待被唤醒,这里我们对比线程等待的wait()方法,来详解Java中的线程让步yield()与线程休眠sleep()方法
  • Java线程休眠

    2016-07-26 21:53:51
    线程休眠指的就是让线程的执行速度稍微变慢一点。 二、休眠方法public static void sleep(long mills)throws InterruptedExceptionpublic class MyThread implements Runnable { @Override public void run() { ...
  • java线程休眠

    2012-01-09 15:24:34
    原创作品,允许转载,...Java线程:线程的调度-休眠   Java线程调度是Java多线程的核心,只有良好的调度,才能充分发挥系统的性能,提高程序的执行效率。   这里要明确的一点,不管程序员怎么编写调度,只能最
  • 一、线程休眠 sleep package ThreadTest; import java.text.SimpleDateFormat; import java.util.Date; // 模拟时间打表 public class TestSleep { public static void main(String[] args) { //获取系统当前...
  • 第二个方法是我们自动化中经常使用的,线程休眠。 1.currentThread() 获取的是当前线程对象,是对象不是对象名称,如果要获取名称,需要对象.getName()实现。 package thread; public class Demo5_Thread { ...
  • java 参赛者的比赛生活(线程休眠唤醒) java 参赛者的比赛生活(线程休眠唤醒) java 参赛者的比赛生活(线程休眠唤醒)
  • java中线程同步,线程让步,线程休眠的区别和联系是什么 线程的本质还是一个运行中的类,
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,...
  •     在学习Java多线程的时候,经常会使用“sleep(long millis)”方法让线程休眠,其目的就是让当前线程休眠一段时间之后再继续执行后面的代码。我们来看看下面的代码: public class MyRunnable implements ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,198
精华内容 24,479
关键字:

java线程休眠

java 订阅