9

I understand that sleep() is used to sleep a thread for specified time. I made tow examples - in example 1 I am getting output as 1,2, 3,4 because I created only one. In example 2, I created 2 instances of the thread and I'm getting output 1,1,2,2,3,3,4,4.

Why the output is not 1,2, 3, 4 for the first thread followed by 1,2,3,4 for the second one?.

Example 1:

// Using sleep() method
  public class Aaa extends Thread{
    public void run(){
        for(int i=1;i<5;i++){
        try{
           Thread.sleep(500); 
        } catch(InterruptedException e){
            System.out.println(e);
        }
        System.out.println(i);
        }
    }
    public static void main(String[] args){
        Aaa m1=new Aaa();
        m1.start();
    }
  }

Output:
    1
    2
    3
    4

Example 2:

    // Using sleep() method
  public class Aaa extends Thread{
    public void run(){
        for(int i=1;i<5;i++){
        try{
           Thread.sleep(500); // sleeps thread
        } catch(InterruptedException e){
            System.out.println(e);
        }
        System.out.println(i);
        }
    }
    public static void main(String[] args){        
       Aaa m1=new Aaa(); // creating one object
       Aaa m2=new Aaa(); // creating second object of a class
       m1.start(); // calls run method
       m2.start();
    }
  }


Output:
    1
    1
    2
    2
    3
    3
    4
    4
4

5 回答 5

7

您已经创建了两个Runnable对象。如果你通过调用他们的run方法来运行它们，你会得到你想象的：

   Aaa m1=new Aaa(); // creating one object
   Aaa m2=new Aaa(); // creating second object of a class
   System.out.println("Calling m1.run()");
   m1.run(); // we call run method
   System.out.println("Calling m2.run()");
   m2.run();

输出

Calling m1.run()
1
2
3
4
Calling m2.run()
1
2
3
4

因为该方法执行两次，一个接一个。

请注意，调用runa 的方法Runnable/Thread不是运行线程的正常方式。您通常会使用该start方法。

但是，如果您将每个都放在 aThread和start它们中：

   Aaa m1=new Aaa(); // creating one object
   Aaa m2=new Aaa(); // creating second object of a class
   System.out.println("Calling m1.start()");
   m1.start(); // thread calls run method
   System.out.println("Calling m2.start()");
   m2.start();

现在每个对象都在自己的线程中并行运行，因此输出是交错的：

Calling m1.start()
Calling m2.start()
1 < From thread 1
1 < From thread 2
2 ...
2
3
3
4
4

顺序显然会根据线程交错的方式而有所不同。

可能让您感到困惑的一件事是您选择了extend Thread. 这是不鼓励的。最好是implement Runnable- 像这样：

public class Aaa implements Runnable {
  public void run() {
    for (int i = 1; i < 5; i++) {
      try {
        Thread.sleep(500); // sleeps thread
      } catch (InterruptedException e) {
        System.out.println(e);
      }
      System.out.println(i);
    }
  }

  public static void main(String[] args) {
    Aaa m1 = new Aaa(); // creating one object
    Thread t1 = new Thread(m1); // Its thread
    Aaa m2 = new Aaa(); // creating second object of a class
    Thread t2 = new Thread(m2); // Its thread
    t1.start(); // calls m's run method in a new thread.
    t2.start();
  }

}

现在更清楚的是，您的对象正在两个不同的线程中运行，因此是并行运行的。

于 2013-09-30T12:03:53.587 回答
1

m1 和 m2 从主线程获得相同的优先级并同时工作。sleep() 允许线程进入阻塞状态 x 毫秒。当线程进入睡眠状态时，它不会释放锁。

于 2013-09-30T11:11:42.500 回答
1

两个线程同时工作——这是线程使用的重点。如果你想在主线程上做一些事情 - 你启动一个新线程。或者两个如果需要执行两个任务并且每个任务都在它自己的线程上工作而不等待另一个。

于 2013-09-30T11:04:24.653 回答
0

要获得所需的输出 1,2,3,4,1,2,3,4，请使用 join() 方法。您可以使用此方法控制线程执行。

Aaa m1=new Aaa();// 创建一个对象
Aaa m2=new Aaa();// 创建一个类的第二个对象
m1.start(); // 调用运行方法
m1.join()；
m2.start();

于 2014-11-05T13:26:22.587 回答
0

sleep 将暂停特定时间段的执行。这是使 cpu 可供其他线程并行运行的有效方法。睡眠不会释放锁。但需要注意的是，调用 sleep 并不意味着线程将在给定的时间内挂起。

于 2015-04-04T10:07:34.997 回答