`
为了明天
  • 浏览: 115461 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

多线程sleep,yield,wait区别

 
阅读更多
sleep()
1)    sleep ()函数有一个参数,通过参数可使线程在指定的时间内进入停滞状态,当指定的时间过后,线程则自动进入可执行状态。
2)    当调用sleep ()函数后,线程不会释放它的“锁标志”。

class TestThreadMethod extends Thread{ 
        class TestThreadMethod extends Thread{ 
        public static int shareVar = 0; 
        public TestThreadMethod(String name){ 
            super(name); 
        } 
        public synchronized void run(){ 
            for(int i=0; i<3; i++){ 
                System.out.print(Thread.currentThread().getName()); 
                System.out.println(" : " + i); 
                try{ 
                    Thread.sleep(100); //(4) 
                } 
                catch(InterruptedException e){ 
                    System.out.println("Interrupted"); 
                } 
            } 
        } 
    } 
    public class TestThread{ 
        public static void main(String[] args){ 
            TestThreadMethod t1 = new TestThreadMethod("t1"); 
            TestThreadMethod t2 = new TestThreadMethod("t2"); 
            t1.start(); (1) 
            t1.start(); (2) 
            //t2.start(); (3) 
        } 
} 


运行结果为:
t1 : 0
t1 : 1
t1 : 2
t1 : 0
t1 : 1
t1 : 2


由结果可证明,虽然在run()中执行了sleep(),但是它不会释放对象的“锁标志”,所以除非代码(1)的线程执行完run()函数并释放对象的“锁标志”,否则代码(2)的线程永远不会执行。
                 如果把代码(2)注释掉,并去掉代码(3)的注释,结果将变为:
t1 : 0
t2 : 0
t1 : 1
t2 : 1
t1 : 2
t2 : 2
由于t1和t2是两个对象的线程,所以当线程t1通过sleep()进入停滞时,排程器会从线程池中调用其它的可执行线程,从而t2线程被启动

class TestThreadMethod extends Thread{ 
        public static int shareVar = 0; 
        public TestThreadMethod(String name){ 
            super(name); 
        } 
        public synchronized void run(){ 
            for(int i=0; i<5; i++){ 
                System.out.print(Thread.currentThread().getName()); 
                System.out.println(" : " + i); 
                try{ 
                    if(Thread.currentThread().getName().equals("t1")) 
                        Thread.sleep(200); 
                    else 
                        Thread.sleep(100); 
                } 
                catch(InterruptedException e){ 
                    System.out.println("Interrupted"); 
                } 
            } 
        } 
    } 
    public class TestThread{ 
        public static void main(String[] args){ 
            TestThreadMethod t1 = new TestThreadMethod("t1"); 
            TestThreadMethod t2 = new TestThreadMethod("t2"); 
            t1.start(); 
            //t1.start(); 
            t2.start(); 
        } 
    } 



运行结果为:
t1 : 0
t2 : 0
t2 : 1
t1 : 1
t2 : 2
t2 : 3
t1 : 2
t2 : 4
t1 : 3
t1 : 4
由于线程t1调用了sleep(200),而线程t2调用了sleep(100),所以线程t2处于停滞状态的时间是线程t1的一半,从从结果反映出来的就是线程t2打印两倍次线程t1才打印一次。


yield() 


1)    通过yield ()函数,可使线程进入可执行状态,排程器从可执行状态的线程中重新进行排程。所以调用了yield()的函数也有可能马上被执行。
2)    当调用yield ()函数后,线程不会释放它的“锁标志”。

class TestThreadMethod extends Thread{ 
        public static int shareVar = 0; 
        public TestThreadMethod(String name){ 
            super(name); 
        } 
        public synchronized void run(){ 
            for(int i=0; i<4; i++){ 
                System.out.print(Thread.currentThread().getName()); 
                System.out.println(" : " + i); 
                Thread.yield(); 
            } 
        } 
    } 
    public class TestThread{ 
        public static void main(String[] args){ 
            TestThreadMethod t1 = new TestThreadMethod("t1"); 
            TestThreadMethod t2 = new TestThreadMethod("t2"); 
            t1.start(); 
            t1.start(); //(1) 
            //t2.start(); (2) 
        } 
} 



运行结果为:
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 0
t1 : 1
t1 : 2
t1 : 3
从结果可知调用yield()时并不会释放对象的“锁标志”。
                如果把代码(1)注释掉,并去掉代码(2)的注释,结果为:
t1 : 0
t1 : 1
t2 : 0
t1 : 2
t2 : 1
t1 : 3
t2 : 2
t2 : 3
从结果可知,虽然t1线程调用了yield(),但它马上又被执行了。


sleep()和yield()的区别

1)    sleep()使当前线程进入停滞状态,所以执行sleep()的线程在指定的时间内肯定不会执行;yield()只是使当前线程重新回到可执行状态,所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
2)    sleep()可使优先级低的线程得到执行的机会,当然也可以让同优先级和高优先级的线程有执行的机会;yield()只能使同优先级的线程有执行的机会。


class TestThreadMethod extends Thread{ 
        public static int shareVar = 0; 
        public TestThreadMethod(String name){ 
            super(name); 
        } 
        public void run(){ 
            for(int i=0; i<4; i++){ 
                System.out.print(Thread.currentThread().getName()); 
                System.out.println(" : " + i); 
                //Thread.yield(); (1) 
                /* (2) */ 
                try{ 
                    Thread.sleep(3000); 
                } 
                catch(InterruptedException e){ 
                    System.out.println("Interrupted"); 
                } 

            } 
        } 
    } 
    public class TestThread{ 
        public static void main(String[] args){ 
            TestThreadMethod t1 = new TestThreadMethod("t1"); 
            TestThreadMethod t2 = new TestThreadMethod("t2"); 
            t1.setPriority(Thread.MAX_PRIORITY); 
            t2.setPriority(Thread.MIN_PRIORITY); 
            t1.start(); 
            t2.start(); 
        } 
} 



运行结果为:
t1 : 0
t1 : 1
t2 : 0
t1 : 2
t2 : 1
t1 : 3
t2 : 2
t2 : 3
由结果可见,通过sleep()可使优先级较低的线程有执行的机会。注释掉代码(2),并去掉代码(1)的注释,结果为:
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t2 : 0
t2 : 1
t2 : 2
t2 : 3
可见,调用yield(),不同优先级的线程永远不会得到执行机会。

join()


使调用join()的线程执行完毕后才能执行其它线程,在一定意义上,它可以实现同步的功能。


class TestThreadMethod extends Thread{ 
        public static int shareVar = 0; 
        public TestThreadMethod(String name){ 
            super(name); 
        } 
        public void run(){ 
            for(int i=0; i<4; i++){ 
                System.out.println(" " + i); 
                try{ 
                    Thread.sleep(3000); 
                } 
                catch(InterruptedException e){ 
                    System.out.println("Interrupted"); 
                } 
            } 
        } 
    } 
    public class TestThread{ 
        public static void main(String[] args){ 
            TestThreadMethod t1 = new TestThreadMethod("t1"); 
            t1.start(); 
            try{ 
                t1.join(); 
            } 
            catch(InterruptedException e){} 
            t1.start(); 
        } 
} 


运行结果为:
0
1
2
3
0
1
2
3
分享到:
评论

相关推荐

    Java线程中wait,await,sleep,yield,join用法总结.pdf

    本文将总结五个关键的线程控制方法:wait()、await()、sleep()、yield()和join()。这些方法各自有独特的用途和不同的工作机制。 一、wait()、notify()、notifyAll()用法 wait()、notify()和notifyAll()是Object类...

    java中yieldsleep以及wait的区别.pdf

    Java中的多线程编程涉及到许多关键概念,包括`yield()`, `sleep()`, 和 `wait()`,这些都是控制线程执行的重要方法。理解它们的区别对于编写高效并发程序至关重要。 首先,`yield()`方法的作用是让当前正在执行的...

    线程中sleep、join、yield、wait的区别

    本文将详细解析线程中`sleep()`, `join()`, `yield()`, 和 `wait()` 四个方法的区别。 1. `sleep()` `sleep()` 方法是 `java.lang.Thread` 类的一个静态方法,它允许当前正在执行的线程在指定的毫秒数内暂停执行。...

    sleep()、wait()、yield()和join()方法特点及区别.docx

    本文将深入探讨Java中的四个关键方法:`sleep()`, `wait()`, `yield()`和`join()`,以及它们各自的特点和区别。 首先,我们来看`sleep()`和`wait()`的区别: 1. **来源不同**:`sleep()`是`Thread`类的方法,它...

    【IT十八掌徐培成】Java基础第08天-01.多线程-yield.zip

    今天我们将深入探讨由IT十八掌徐培成讲解的Java基础课程中的第八天主题——多线程,特别是关于`yield()`方法的知识点。 首先,我们要明白什么是线程。线程是程序执行的最小单位,每个线程都代表程序的一个独立控制...

    java多线程Demo

    在多线程环境下,可能会出现数据竞争问题,为了解决这个问题,Java提供了多种同步机制,如synchronized关键字、wait/notify机制、Lock锁(ReentrantLock)等。synchronized用于控制对共享资源的访问,而wait/notify...

    高薪程序员面试题精讲系列63之说说sleep()、yield()、join()、wait()的区别.pdf,这是一份不错的文件

    本资源主要讲解了Java中四个常用的线程控制方法:sleep()、yield()、join()和wait(),它们是Java多线程编程中的重要组成部分。下面是对每个方法的详细讲解: 1. sleep()方法: sleep()方法是Thread类...

    Java多线程技术精讲

    Java多线程技术是Java编程中的重要组成部分,它允许程序同时执行多个任务,极大地提高了程序的效率和响应性。在现代计算机系统中,多线程是实现并发处理的关键技术,尤其在服务器端应用和高性能计算中不可或缺。 ...

    Java多线程详解(超详细)_狂神说笔记完整版_项目代码_适合小白随课程学习

    Java多线程详解 在Java编程中,多线程是一种重要的技术,它使得程序能够同时执行多个任务,提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念,包括线程的创建、状态、同步以及高级主题,旨在帮助初学者...

    Java线程中yield与join方法的区别

    之前,我讨论了一个wait()和sleep()方法区别的问题,这一次,我将会讨论join()和yield()方法的区别。坦白的说,实际上我并没有用过其中任何一个方法,所以,如果你感觉有不恰当的地方,请提出讨论。  Java线程调度...

    多线程

    在IT领域,多线程是程序设计中的一个重要概念,尤其在服务器端开发和高并发场景中,它的应用广泛且至关重要。多线程是指一个进程中同时存在多个执行流,每个线程都代表了进程的一部分独立执行的任务。理解并掌握多...

    多线程经典例子

    在编程领域,多线程是实现并发执行任务的关键技术,特别是在现代计算机系统中,它能够充分利用多核处理器的计算能力,提高程序的运行效率。本文将深入探讨多线程的经典应用,以及如何在实际开发中有效地使用多线程。...

    详解Java中的线程让步yield()与线程休眠sleep()方法

    `yield()`和`wait()`的一个主要区别在于,`yield()`仅将线程状态从运行变为就绪,而不涉及同步锁的释放;而`wait()`则会让线程进入等待状态并释放锁,以便其他线程能够获得锁并执行同步代码。 线程休眠`sleep()`...

    java 多线程编程指南

    在Java编程领域,多线程是一项至关重要的技术,它允许程序同时执行多个任务,从而提高系统效率和响应性。这份“Java多线程编程指南”深入探讨了这一主题,为中级到高级的Java开发者提供了宝贵的资源。 首先,多线程...

    java多线程知识讲解及练习题

    1. sleep() 和 wait() 的区别 sleep() 是 Thread 类的方法,导致线程暂停执行指定时间,给执行机会给其他线程,但是监控状态依然保持,到时后会自动恢复。调用 sleep 不会释放对象锁。wait 是 Object 类的方法,...

    多线程,day2,B站狂神,代码Lesson.rar

    在Java编程语言中,多线程是程序设计中的一个重要概念,尤其在开发高效能和响应迅速的应用时。"多线程,day2,B站狂神,代码Lesson.rar"这个资源可能是一个关于Java多线程的第二日课程,由B站(哔哩哔哩)上的一位...

    多线程】_认识多线程

    在计算机科学中,多线程是一种程序执行方式,允许单个进程内同时执行多个不同的线程,从而提高系统的效率和响应性。本文将深入探讨多线程的概念、创建与使用,以及在实际应用中需要注意的事项。 一、多线程的基本...

    多线程使用操作大全

    ### 多线程使用操作大全 #### 知识点概览 本文主要围绕多线程在Java中的使用展开,深入探讨了线程控制的基本方法及其应用场景,并提供了具体的示例代码来帮助理解。主要包括线程的生命状态检查、优先级管理、线程间...

    JAVA多线程(精典总结)

    Java多线程是Java编程中不可或缺的部分,尤其在面试中,多线程的知识点经常被问及。本文将深入探讨Java多线程的核心概念、创建方式、线程状态转换、线程调度以及线程优先级调整。 首先,理解线程的基本概念至关重要...

Global site tag (gtag.js) - Google Analytics