精华内容
下载资源
问答
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,...

    Java 多线程基础(七)线程休眠 sleep

    一、线程休眠 sleep

    sleep() 方法定义在Thread.java中,是 static 修饰的静态方法。

    sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,从而等待cpu的调度执行。

    二、sleep示例

    public classSleepTest {private static Object obj = newObject();public static voidmain(String[] args) {

    Thread t1= new MyThread("t1");t1.start();

    }static class MyThread extendsThread{publicMyThread(String name) {super(name);

    }public voidrun() {synchronized(obj) {try{for(int i = 0;i < 5;i++) {

    System.out.println(Thread.currentThread().getName()+ "--" +i);if (i % 4 == 0)

    Thread.sleep(1000);//i能被4整除时,休眠1秒

    }

    }catch(Exception e) {

    e.printStackTrace();

    }

    }

    }

    }

    }

    //运行结果

    t1--0t1--1t1--2t1--3t1--4

    说明:

    在主线程main中启动线程t1。t1启动之后,当t1中的计算i能被4整除时,t1会通过Thread.sleep(100)休眠100毫秒。

    三、sleep(long millis) 与 wait(long timeout)

    我们知道,wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时,也会释放同步锁。而sleep()的作用是也是让当前线程由“运行状态”进入到“休眠(阻塞)状态”。

    但是,wait() 会释放对象的同步锁,而 sleep() 则不会释放锁。

    通过下面的代码,演示 sleep() 不会释放锁的:

    public classSleepTest {private static Object obj = newObject();public static voidmain(String[] args) {

    Thread t1= new MyThread("t1");

    Thread t2= new MyThread("t2");

    t1.start();

    t2.start();

    }static class MyThread extendsThread{publicMyThread(String name) {super(name);

    }public voidrun() {synchronized(obj) {try{for(int i = 0;i < 5;i++) {

    System.out.println(Thread.currentThread().getName()+ "--" +i);Thread.sleep(1000);//休眠1秒

    }

    }catch(Exception e) {

    e.printStackTrace();

    }

    }

    }

    }

    }

    //执行结果

    t1--0t1--1t1--2t1--3t1--4t2--0t2--1t2--2t2--3t2--4

    说明:

    主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁,即synchronized(obj)。在t1运行过程中,虽然它会调用Thread.sleep(1000) 进入休眠状态;但是,t2是不会获取CPU执行权的。因为,t1并没有释放“obj所持有的同步锁”!

    注意,若我们注释掉 synchronized (obj) 后再次执行该程序,t1和t2是可以相互切换执行的,原因是:在没有同步锁的情况下,当一个线程进入“休眠(阻塞)状态“时,会放弃CPU的执行权,另一个线程就会获取CPU执行权。

    通过下面的代码,演示 wait() 会释放锁的:

    public classSleepTest {private static Object obj = newObject();public static voidmain(String[] args) {

    Thread t1= new MyThread("t1");

    Thread t2= new MyThread("t2");

    t1.start();

    t2.start();

    }static class MyThread extendsThread{publicMyThread(String name) {super(name);

    }public voidrun() {synchronized(obj) {try{for(int i = 0;i < 5;i++) {

    System.out.println(Thread.currentThread().getName()+ "--" +i);

    obj.wait(1000);//等待1秒

    }

    }catch(Exception e) {

    e.printStackTrace();

    }

    }

    }

    }

    }

    //执行结果

    t1--0t2--0t1--1t2--1t2--2t1--2t2--3t1--3t2--4t1--4

    说明:

    主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁,即synchronized(obj)。在t1运行过程中,调用 obj.wait(1000) 进入等待状态,释放同步锁;此时,t2会获取CPU执行权的。

    展开全文
  • 线程休眠:我们希望人为地控制线程,使得正在执行的线程暂停,将CPU让给别的线程,我们可以使用静态方法sleep(long millis),该方法可以让当前正在执行的线程暂停一段时间,进入休眠等待状态。线程让步:线程让步可以...

    线程休眠:我们希望人为地控制线程,使得正在执行的线程暂停,将CPU让给别的线程,我们可以使用静态方法sleep(long millis),该方法可以让当前正在执行的线程暂停一段时间,进入休眠等待状态。

    线程让步:线程让步可以通过yield() 方法来实现,该方法和sleep()有点相似,都可以让当前正在运行的线程暂停,区别在于yield()方法不会阻塞该线程,他只是将线程转换成就绪状态,让系统调度器重新调度一次。当某个线程调用yield()方法之后,只有与当前线程优先级相同或者更高的线程才能获得执行的机会。

    线程休眠简单实例:

    public classThreadSleep {public static voidmain(String[] args) {new Thread(newSleepThread()).start();for(int i=1;i<=10;i++) {if(i == 5) {

    System.out.println("mainThread start sleep!");try{

    Thread.sleep(20000);

    }catch(InterruptedException e) {//TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    System.out.println("mainThread is inputting:"+i);try{

    Thread.sleep(500);

    }catch(InterruptedException e) {//TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    }class SleepThread implementsRunnable {

    @Overridepublic voidrun() {//TODO Auto-generated method stub

    for (int i = 0; i < 10; i++) {if (i == 3) {

    System.out.println("deputyThread start sleep!");try{

    Thread.sleep(5000);

    }catch(InterruptedException e) {//TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    System.out.println("deputyThread is inputting:"+i);try{

    Thread.sleep(500);

    }catch(InterruptedException e) {//TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    }

    线程让步简单实例:

    public class ThreadYield {

    public static void main(String[] args) {

    new Thread(new YieldThread(),"Thread A").start();

    new Thread(new YieldThread(),"Thread B").start();

    new Thread(new YieldThread(),"Thread C").start();

    new Thread(new YieldThread(),"Thread E").start();

    new Thread(new YieldThread(),"Thread F").start();

    new Thread(new YieldThread(),"Thread G").start();

    new Thread(new YieldThread(),"Thread H").start();

    }

    }

    class YieldThread implements Runnable{

    @Override

    public void run() {

    // TODO Auto-generated method stub

    for(int i = 0;i <=10;i++) {

    if(i == 4) {

    System.out.println(Thread.currentThread().getName()+" that is inputting "+i+" has yielded!");

    continue;

    }

    System.out.println(Thread.currentThread().getName()+" is inputting :"+i);

    }

    }

    }

    展开全文
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态...

    本章涉及到的内容包括:

    1. sleep()介绍

    2. sleep()示例

    3. sleep() 与 wait()的比较

    1. sleep()介绍

    sleep() 定义在Thread.java中。

    sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,从而等待cpu的调度执行。

    2. sleep()示例

    下面通过一个简单示例演示sleep()的用法。

    // SleepTest.java的源码

    class ThreadA extends Thread{

    public ThreadA(String name){

    super(name);

    }

    public synchronized void run() {

    try {

    for(int i=0; i <10; i++){

    System.out.printf("%s: %d\n", this.getName(), i);

    // i能被4整除时,休眠100毫秒

    if (i%4 == 0)

    Thread.sleep(100);

    }

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    public class SleepTest{

    public static void main(String[] args){

    ThreadA t1 = new ThreadA("t1");

    t1.start();

    }

    }

    运行结果:

    t1: 0

    t1: 1

    t1: 2

    t1: 3

    t1: 4

    t1: 5

    t1: 6

    t1: 7

    t1: 8

    t1: 9

    结果说明:

    程序比较简单,在主线程main中启动线程t1。t1启动之后,当t1中的计算i能被4整除时,t1会通过Thread.sleep(100)休眠100毫秒。

    sleep() 与 wait()的比较

    我们知道,wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时,也会释放同步锁。而sleep()的作用是也是让当前线程由“运行状态”进入到“休眠(阻塞)状态”。

    但是,wait()会释放对象的同步锁,而sleep()则不会释放锁。

    下面通过示例演示sleep()是不会释放锁的。

    // SleepLockTest.java的源码

    public class SleepLockTest{

    private static Object obj = new Object();

    public static void main(String[] args){

    ThreadA t1 = new ThreadA("t1");

    ThreadA t2 = new ThreadA("t2");

    t1.start();

    t2.start();

    }

    static class ThreadA extends Thread{

    public ThreadA(String name){

    super(name);

    }

    public void run(){

    // 获取obj对象的同步锁

    synchronized (obj) {

    try {

    for(int i=0; i <10; i++){

    System.out.printf("%s: %d\n", this.getName(), i);

    // i能被4整除时,休眠100毫秒

    if (i%4 == 0)

    Thread.sleep(100);

    }

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    }

    }

    运行结果:

    t1: 0

    t1: 1

    t1: 2

    t1: 3

    t1: 4

    t1: 5

    t1: 6

    t1: 7

    t1: 8

    t1: 9

    t2: 0

    t2: 1

    t2: 2

    t2: 3

    t2: 4

    t2: 5

    t2: 6

    t2: 7

    t2: 8

    t2: 9

    结果说明:

    主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁,即synchronized(obj)。在t1运行过程中,虽然它会调用Thread.sleep(100);但是,t2是不会获取cpu执行权的。因为,t1并没有释放“obj所持有的同步锁”!

    注意,若我们注释掉synchronized (obj)后再次执行该程序,t1和t2是可以相互切换的。下面是注释调synchronized(obj) 之后的源码:

    // SleepLockTest.java的源码(注释掉synchronized(obj))

    public class SleepLockTest{

    private static Object obj = new Object();

    public static void main(String[] args){

    ThreadA t1 = new ThreadA("t1");

    ThreadA t2 = new ThreadA("t2");

    t1.start();

    t2.start();

    }

    static class ThreadA extends Thread{

    public ThreadA(String name){

    super(name);

    }

    public void run(){

    // 获取obj对象的同步锁

    //            synchronized (obj) {

    try {

    for(int i=0; i <10; i++){

    System.out.printf("%s: %d\n", this.getName(), i);

    // i能被4整除时,休眠100毫秒

    if (i%4 == 0)

    Thread.sleep(100);

    }

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    //            }

    }

    }

    }

    展开全文
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,...

    sleep()介绍

    sleep() 定义在Thread.java中。

    sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,从而等待cpu的调度执行。

    6980cbce916810d0f90b64849dca063c.png

    sleep()方法

    表示放弃当前cpu的资源,使当前线程不占用计算机的任何资源。如果当前线程获取到了锁,sleep()方法是不会放弃锁的,如果线程被打断会抛出InterruptException异常。

    package com.xxx.util;

    import java.util.Date;

    /**

    * Created with IntelliJ IDEA.

    * Date: 15-3-27

    * Time: 上午8:51

    * To change this template use File | Settings | File Templates.

    */

    public class ThreadSleep implements Runnable {

    @Override

    public void run() {

    for(int i=0;i<15;i++){

    System.out.printf("startTime:%sn",new Date());

    try {

    Thread.sleep(1000);

    } catch (InterruptedException e) {

    //线程中断在此处理

    System.out.println("The thread has bean interrupted");

    }

    }

    }

    }

    wait()方法:线程必须在同步代码块(synchronized)中调用wait()方法,如果在同步代码块之外调用wait()方法,jvm将会抛出IllegalMonitorStateException。当一个线程调用wait()方法时,jvm会把这个线程陷入休眠,并释放掉锁,同时允许其他线程得到锁。

    Java并发API中,还有另外一个方法可以让线程让出CPU。这就是yield()方法,调用该方法就是想Java虚拟机发送消息说明线程可以让出CPU给其他线程。Java虚拟机并不保证响应这个请求。一般情况下,该方法仅仅在调试程序时使用。

    展开全文
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,...
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,...
  • 本文对javaThread中sleep()方法进行介绍,sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”,大家参考使用吧
  • sleep()的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠时间会大于/等于该休眠时间;在线程被重新唤醒时,它会由“阻塞状态”变为“就绪状态”,...
  • 原标题:Java线程休眠和回复Java线程休眠和回复sleep()方法:表示放弃当前cpu的资源,使当前线程不占用计算机的任何资源。如果当前线程获取到了锁,sleep()方法是不会放弃锁的,如果线程被打断会抛出Interrupt...
  • 第二个方法是我们自动化中经常使用的,线程休眠。 1.currentThread() 获取的是当前线程对象,是对象不是对象名称,如果要获取名称,需要对象.getName()实现。 package thread; public class Demo5_Thread { ...
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。下面通过实例代码给大家介绍Java线程休眠的知识,需要的朋友参考下吧
  •   在Java多线程中,可以使用sleep()方法在指定毫秒数内让当前正在执行的线程休眠。   下面这段代码,使得主函数的main线程休眠了2000ms,最后输出的间隔时间也是2000ms。 public class MyThread extends ...
  • 本节摘要:sleep()功能介绍,sleep()用法示例一、功能介绍让当前线程(调用sleep()方法的线程)休息一会,即是让当前线程由运行状态进入到阻塞状态,进而使其他线程有机会继续执行任务。虽然使线程休眠,但是并不释放...
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,...
  • Java线程休眠

    2019-05-10 17:42:56
    线程休眠: 在当前线程的执行中,暂停指定的毫秒数,释放CPU的时间片 作用: 没有线程的休眠,我们无法控制多个线程的运行顺序, 当有休眠时,我们可以可控制线程的执行顺序,干涉CUP执行的时间,到达我们想...
  • 当前线程休眠 当前线程会从 [运行状态] 进入 [休眠或者阻塞状态] sleep() 会指定休眠时间: 当线程休眠的时间大于或者等于该休眠时间时,线程被唤醒,会由 [阻塞状态] 进入 [就绪状态], 等待CPU的调度执行 ...
  • java多线程--线程休眠

    千次阅读 2016-06-23 10:50:02
    sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,...
  • 线程休眠:我们希望人为地控制线程,使得正在执行的线程暂停,将CPU让给别的线程,我们可以使用静态方法sleep(long millis),该方法可以让当前正在执行的线程暂停一段时间,进入休眠等待状态。 线程让步:线程让步...
  • Java.lang.Thread的sleep()方法能使当前线程暂停运行一段时间(单位毫秒)。需要注意的是,sleep()方法的参数不能为负,否则会抛出IllegalArgumentException异常。除此之外,还有另一个方法sleep(long millis, int ...
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,...
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,...
  • 线程休眠: sleep时间指定当前线程阻塞的毫秒数 sleep存在异常 InterruptedException sleep时间达到线程后线程进入就绪状态 sleep可以模拟网络延时,倒计时等 每一个对象都有一个锁,sleep不会释放锁 模拟网络延时,...
  • 休眠是与放弃yield相比是更有力的放弃方式, 放弃只是表示当前线程愿意暂停当前线程,让其他有相同优先级的等待线程有机会获得cpu资源。而进入休眠sleep不同,不管有没有其他线程在等待资源,都进入暂停,这样一来...
  • 一、线程休眠 sleep package ThreadTest; import java.text.SimpleDateFormat; import java.util.Date; // 模拟时间打表 public class TestSleep { public static void main(String[] args) { //获取系统当前...
  • sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 659
精华内容 263
关键字:

java当前线程休眠

java 订阅