• Tags
  •         
  • www.breakyizhan.com
  •    

    我们可以通过使用Thread类的以下方法之一来阻止线程的执行。

      1. yield():假设有三个线程t1,t2和t3。线程t1获取处理器并开始执行,线程t2和t3处于Ready / Runnable状态。线程t1的完成时间是5小时,t2的完成时间是5分钟。由于t1将在5小时后完成执行,因此t2必须等待5个小时才能完成5分钟的工作。在一个线程花费太多时间来完成其执行的情况下,我们需要一种方法来防止在重要的东西挂起时在其间执行线程。yeild()帮助我们这样做。
        yield()基本上意味着线程没有做任何特别重要的事情,如果需要运行任何其他线程或进程,它们应该运行。否则,当前线程将继续运行。

        • Java的并发 - yield(),sleep()和join()方法

        使用java.lang.Thread.yield()方法:

        • 每当一个线程调用java.lang.Thread.yield方法时,它就会向线程调度程序提示它已准备好暂停其执行。线程调度程序可以忽略此提示。
        • 如果任何线程执行yield方法,则线程调度程序检查是否存在与此线程具有相同或高优先级的线程。如果处理器找到具有更高或相同优先级的任何线程,则它将当前线程移动到Ready / Runnable状态并将处理器提供给其他线程,如果不是 - 当前线程将继续执行。

        句法:

         

        public static native void yield()
        // Java program to illustrate yield() method
        // in Java
        import java.lang.*;
        
        // MyThread extending Thread
        class MyThread extends Thread
        {
            public void run()
            {
                for (int i=0; i<5 ; i++)
                    System.out.println(Thread.currentThread().getName()
                                        + " in control");
            }
        }
        
        // Driver Class
        public class yieldDemo
        {
            public static void main(String[]args)
            {
                MyThread t = new MyThread();
                t.start();
        
                for (int i=0; i<5; i++)
                {
                    // Control passes to child thread
                    Thread.yield();
        
                    // After execution of child Thread
                    // main thread takes over
                    System.out.println(Thread.currentThread().getName()
                                        + " in control");
                }
            }
        }
        

        输出:

        Thread-0 in control
        Thread-0 in control
        Thread-0 in control
        Thread-0 in control
        Thread-0 in control
        main in control
        main in control
        main in control
        main in control
        main in control

        输出可能因机器而异,但yield()线程执行的可能性首先高于另一个线程,因为主线程始终暂停其执行并给予子线程(具有相同优先级)的机会。

        注意:

        • 一旦线程执行了yield方法并且有许多具有相同优先级的线程正在等待处理器,那么我们就不能首先指定哪个线程将获得执行机会。
        • 执行yield方法的线程将从Running状态进入Runnable状态。
        • 一旦线程暂停其执行,我们就无法指定它何时会再次获得机会,这取决于线程调度程序。
        • 如果我们使用yield方法,底层平台必须为抢先调度提供支持。
      2. sleep():此方法使当前正在执行的线程休眠指定的毫秒数,具体取决于系统计时器和调度程序的精度和准确性。
        句法:

        //sleep指定的毫秒数
        public static void sleep(long millis)抛出InterruptedException
        
        //sleep指定的毫秒数加纳秒
        public static void sleep(long millis,int nanos) 
                                 抛出InterruptedException

        使用sleep()方法

         
        // Java program to illustrate
        // sleep() method in Java
        import java.lang.*;
         
        public class SleepDemo implements Runnable
        {
            Thread t;
            public void run()
            {
                for (int i = 0; i < 4; i++)
                {
                    System.out.println(Thread.currentThread().getName()
                                                           + "  " + i);
                    try
                    {
                        // thread to sleep for 1000 milliseconds
                        Thread.sleep(1000);
                    }
         
                    catch (Exception e)
                    {
                        System.out.println(e);
                    }
                }
            }
         
            public static void main(String[] args) throws Exception
            {
                Thread t = new Thread(new SleepDemo());
         
                // call run() function
                t.start();
         
                Thread t2 = new Thread(new SleepDemo());
         
                // call run() function
                t2.start();
            }
        }
        

        输出:

        Thread-0  0
        Thread-1  0
        Thread-0  1
        Thread-1  1
        Thread-0  2
        Thread-1  2
        Thread-0  3
        Thread-1  3

        注意:

        • 根据要求,我们可以使线程处于睡眠状态一段指定的时间
        • Sleep()会导致线程在给定的时间内明确停止执行; 如果不需要运行其他线程或进程,CPU将处于空闲状态(可能进入省电模式)。

    yield()vs sleep()

    yield :()表示线程没有做任何特别重要的事情,如果需要运行任何其他线程或进程,它们可以。否则,当前线程将继续运行。

    sleep():使线程在给定的时间内明确停止执行; 如果不需要运行其他线程或进程,CPU将处于空闲状态(可能进入省电模式)。

    1. join(): Thread实例的join()方法用于将线程执行的开始连接到其他线程的执行结束,这样在另一个线程结束之前线程不会开始运行。如果在Thread实例上调用join(),则当前运行的线程将阻塞,直到Thread实例完成执行。
      join()方法最多等待这个线程死的这么多毫秒。超时为0意味着永远等待
      语法:

      //等待这个帖子死掉
      public final void join()抛出InterruptedException
      
      //最多等待这个线程死了这么多毫秒
      public final void join(long millis) 
                    抛出InterruptedException
      
      //等待此线程死亡时最多毫秒加上纳秒。
      java.lang.Thread.join(long millis,int nanos)
      // Java program to illustrate join() method in Java
      import java.lang.*;
      
      public class JoinDemo implements Runnable
      {
          public void run()
          {
              Thread t = Thread.currentThread();
              System.out.println("Current thread: "
                                     + t.getName());
      
              // checks if current thread is alive
              System.out.println("Is Alive? "
                                     + t.isAlive());
          }
      
          public static void main(String args[]) throws Exception
          {
              Thread t = new Thread(new JoinDemo());
              t.start();
      
              // Waits for 1000ms this thread to die.
              t.join(1000);
      
              System.out.println("\nJoining after 1000"+
                                   " mili seconds: \n");
              System.out.println("Current thread: " +
                                          t.getName());
      
      
              // Checks if this thread is alive
              System.out.println("Is alive? " + t.isAlive());
          }
      }
      

      输出:

      Current thread: Thread-0
      Is Alive? true
      
      Joining after 1000 mili seconds: 
      
      Current thread: Thread-0
      Is alive? false

      注意:

      • 如果任何执行的线程t1在t2上调用join(),即; t2.join()立即t1将进入等待状态,直到t2完成执行。
      • 在join()内给出超时,将使join()效果在特定超时后无效。

     
    转载请保留页面地址:https://www.breakyizhan.com/java/4939.html