【Java之多线程（二）】（***重要***）Java多线程中常见方法的区别，如object.wait()和Thread.sleep()的区别等

时间：2021-01-19 23:59:39

1、Java中Thread和Runnable的区别？？？

区别：

在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：

  • 避免点继承的局限，一个类可以继承多个接口。
  • 适合于资源的共享

联系：

public class Thread extends Object implements Runnable

发现Thread类也是Runnable接口的子类。

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

在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。

下面看例子：

 
 
    

  1. package org.thread.demo;  
    2. 
  
  
  2. 
class MyThread extends Thread{  

    3. 
  
  
  3. 
private String name;  

    4. 
  
  
  4. 
public MyThread(String name) {  

    5. 
  
  
  5. 
super();  

    6. 
  
  
  6. 
this.name = name;  

    7. 
  
  
  7. }  
    8. 
  
  
  8. 
public void run(){  

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

    10. 
  
  
  10. 
System.out.println("线程开始："+this.name+",i="+i);  

    11. 
  
  
  11. }  
    12. 
  
  
  12. }  
    13. 
  
  
  13. }  
    14. 
  
  
  14. 
package org.thread.demo;  

    15. 
  
  
  15. 
public class ThreadDemo01 {  

    16. 
  
  
  16. 
public static void main(String[] args) {  

    17. 
  
  
  17. 
MyThread mt1=new MyThread("线程a");  

    18. 
  
  
  18. 
MyThread mt2=new MyThread("线程b");  

    19. 
  
  
  19. mt1.run();  
    20. 
  
  
  20. mt2.run();  
    21. 
  
  
  21. }  
    22. 
  
  
  22. } 
    23.

但是，此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在JDK的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。下面启动start()方法启动线程：

 
 
    

  1. package org.thread.demo;  
    2. 
  
  
  2. 
public class ThreadDemo01 {  

    3. 
  
  
  3. 
public static void main(String[] args) {  

    4. 
  
  
  4. 
MyThread mt1=new MyThread("线程a");  

    5. 
  
  
  5. 
MyThread mt2=new MyThread("线程b");  

    6. 
  
  
  6. mt1.start();  
    7. 
  
  
  7. mt2.start();  
    8. 
  
  
  8. }  
    9. 
  
  
  9. }; 
    10.

这样程序可以正常完成交互式运行。那么为啥非要使用start();方法启动多线程呢？

在JDK的安装路径下，src.zip是全部的java源程序，通过此代码找到Thread中的start()方法的定义，可以发现此方法中使用了private native void start0();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（java Native Interface）

Runnable接口

在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。

 
 
    

  1. public interface Runnable{  
    2. 
  
  
  2. 
public void run();  

    3. 
  
  
  3. } 
    4.

例子：

 
 
    

  1. package org.runnable.demo;  
    2. 
  
  
  2. 
class MyThread implements Runnable{  

    3. 
  
  
  3. 
private String name;  

    4. 
  
  
  4. 
public MyThread(String name) {  

    5. 
  
  
  5. 
this.name = name;  

    6. 
  
  
  6. }
    7. 
  
  
  7. 
public void run(){  

    8. 
  
  
  8. 
for(int i=0;i<100;i++){  

    9. 
  
  
  9. 
System.out.println("线程开始："+this.name+",i="+i);  

    10. 
  
  
  10. }  
    11. 
  
  
  11. }  
    12. 
  
  
  12. }; 
    13.

但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable targer)此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。（start()可以协调系统的资源）：

 
 
    

  1. package org.runnable.demo;  
    2. 
  
  
  2. 
import org.runnable.demo.MyThread;  

    3. 
  
  
  3. 
public class ThreadDemo01 {  

    4. 
  
  
  4. 
public static void main(String[] args) {  

    5. 
  
  
  5. 
MyThread mt1=new MyThread("线程a");  

    6. 
  
  
  6. 
MyThread mt2=new MyThread("线程b");  

    7. 
  
  
  7. 
new Thread(mt1).start();  

    8. 
  
  
  8. 
new Thread(mt2).start();  

    9. 
  
  
  9. }  
    10. 
  
  
  10. } 
    11.

两种实现方式的区别和联系：

在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：

  • 避免点继承的局限，一个类可以继承多个接口。
  • 适合于资源的共享

以卖票程序为例，通过Thread类完成：

 
 
    

  1. package org.demo.dff;  
    2. 
  
  
  2. 
class MyThread extends Thread{  

    3. 
  
  
  3. 
private int ticket=10;  

    4. 
  
  
  4. 
public void run(){  

    5. 
  
  
  5. 
for(int i=0;i<20;i++){  

    6. 
  
  
  6. 
if(this.ticket>0){  

    7. 
  
  
  7. 
System.out.println("卖票：ticket"+this.ticket--);  

    8. 
  
  
  8. }  
    9. 
  
  
  9. }  
    10. 
  
  
  10. }  
    11. 
  
  
  11. }; 
    12.

下面通过三个线程对象，同时卖票：

 
 
    

  1. package org.demo.dff;  
    2. 
  
  
  2. 
public class ThreadTicket {  

    3. 
  
  
  3. 
public static void main(String[] args) {  

    4. 
  
  
  4. 
MyThread mt1=new MyThread();  

    5. 
  
  
  5. 
MyThread mt2=new MyThread();  

    6. 
  
  
  6. 
MyThread mt3=new MyThread();  

    7. 
  
  
  7. 
mt1.start();//每个线程都各卖了10张，共卖了30张票  

    8. 
  
  
  8. 
mt2.start();//但实际只有10张票，每个线程都卖自己的票  

    9. 
  
  
  9. 
mt3.start();//没有达到资源共享  

    10. 
  
  
  10. }  
    11. 
  
  
  11. } 
    12.

如果用Runnable就可以实现资源共享，下面看例子：

 
 
    

  1. package org.demo.runnable;  
    2. 
  
  
  2. 
class MyThread implements Runnable{  

    3. 
  
  
  3. 
private int ticket=10;  

    4. 
  
  
  4. 
public void run(){  

    5. 
  
  
  5. 
for(int i=0;i<20;i++){  

    6. 
  
  
  6. 
if(this.ticket>0){  

    7. 
  
  
  7. 
System.out.println("卖票：ticket"+this.ticket--);  

    8. 
  
  
  8. }  
    9. 
  
  
  9. }  
    10. 
  
  
  10. }  
    11. 
  
  
  11. }  
    12. 
  
  
  12. 
package org.demo.runnable;  

    13. 
  
  
  13. 
public class RunnableTicket {  

    14. 
  
  
  14. 
public static void main(String[] args) {  

    15. 
  
  
  15. 
MyThread mt=new MyThread();  

    16. 
  
  
  16. 
new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一  

    17. 
  
  
  17. 
new Thread(mt).start();//个实例化对象mt，就会出现异常  

    18. 
  
  
  18. 
new Thread(mt).start();  

    19. 
  
  
  19. }  
    20. 
  
  
  20. }; 
    21.

虽然现在程序中有三个线程，但是一共卖了10张票，也就是说使用Runnable实现多线程可以达到资源共享目的。

2、Object类的wait()和notify()、notifyAll()

 他们主要是为了进行线程间通信。

这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用。synchronized关键字用于保护共享数据，阻止其他线程对共享数据的存取，但是这样程序的流程就很不灵活了，如何才能在当前线程还没退出synchronized数据块时让其他线程也有机会访问共享数据呢？此时就用这三个方法来灵活控制。

（1）wait()方法：使当前线程暂停执行并释放对象锁标示，让其他线程可以进入synchronized数据块，当前线程被放入对象等待池中。

（2）当调用notify()方法后，将从对象的等待池中移走一个任意的线程并放到锁标志等待池中，只有锁标志等待池中线程能够获取锁标志；如果锁标志等待池中没有线程，则notify()不起作用。

（3）notifyAll()：则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。

注意 这三个方法都是java.lang.Object的方法。

Q1、模拟单个线程对多个线程的唤醒      模拟线程之间的协作。Game类有2个同步方法prepare()和go()。标志位start用于判断当前线程是否需要wait()。Game类的实例首先启动所有的Athele类实例，使其进入wait()状态，在一段时间后，改变标志位并notifyAll()所有处于wait状态的Athele线程。Game.java
package concurrency;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

class Athlete implements Runnable {
    private final int id;
    private Game game;

    public Athlete(int id, Game game) {
      this.id = id;
      this.game = game;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Athlete))
        return false;
      Athlete athlete = (Athlete) o;
      return id == athlete.id;
    }

    public String toString() {
      return "Athlete<" + id + ">";
    }

    public int hashCode() {
      return new Integer(id).hashCode();
    }

    public void run() {
      try {
        game.prepare(this);
      } catch (InterruptedException e) {
        System.out.println(this + " quit the game");
      }
    }
  }

public class Game implements Runnable {
    private Set<Athlete> players = new HashSet<Athlete>();
    private boolean start = false;

    public void addPlayer(Athlete one) {
      players.add(one);
    }

    public void removePlayer(Athlete one) {
      players.remove(one);
    }

    public Collection<Athlete> getPlayers() {
      return Collections.unmodifiableSet(players);
    }

    public void prepare(Athlete athlete) throws InterruptedException {
      System.out.println(athlete + " ready!");
      synchronized (this) {
        while (!start)
        wait();
        if (start)
          System.out.println(athlete + " go!");
      }
    }

    public synchronized void go() {
      notifyAll();
    }

    public void ready() {
      Iterator<Athlete> iter = getPlayers().iterator();
      while (iter.hasNext())
        new Thread(iter.next()).start();
    }

    public void run() {
      start = false;
      System.out.println("Ready......");
      System.out.println("Ready......");
      System.out.println("Ready......");
      ready();
      start = true;
      System.out.println("Go!");
      go();
    }

    public static void main(String[] args) {
      Game game = new Game();
      for (int i = 0; i < 10; i++)
        game.addPlayer(new Athlete(i, game));
      new Thread(game).start();
    }
}
结果：
Ready......
Ready......
Ready......
Athlete<0> ready!
Athlete<1> ready!
Athlete<2> ready!
Athlete<3> ready!
Athlete<4> ready!
Athlete<5> ready!
Athlete<6> ready!
Athlete<7> ready!
Athlete<8> ready!
Athlete<9> ready!
Go!
Athlete<9> go!
Athlete<8> go!
Athlete<7> go!
Athlete<6> go!
Athlete<5> go!
Athlete<4> go!
Athlete<3> go!
Athlete<2> go!
Athlete<1> go!
Athlete<0> go!

 Q2.模拟忙等待过程      MyObject类的实例是被观察者，当观察事件发生时，它会通知一个Monitor类的实例（通知的方式是改变一个标志位）。而此Monitor类的实例是通过忙等待来不断的检查标志位是否变化。 BusyWaiting.java 
import java.util.concurrent.TimeUnit;

class MyObject implements Runnable {
    private Monitor monitor;

    public MyObject(Monitor monitor) {
      this.monitor = monitor;
    }

    public void run() {
      try {
        TimeUnit.SECONDS.sleep(3);
        System.out.println("i'm going.");
        monitor.gotMessage();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
}

class Monitor implements Runnable {
    private volatile boolean go = false;

    public void gotMessage() throws InterruptedException {
      go = true;
    }

    public void watching() {
      while (go == false)
        ;
      System.out.println("He has gone.");
    }

    public void run() {
      watching();
    }
}

public class BusyWaiting {
    public static void main(String[] args) {
      Monitor monitor = new Monitor();
      MyObject o = new MyObject(monitor);
      new Thread(o).start();
      new Thread(monitor).start();
    }
}
结果： i'm going. He has gone. 下面使用wait()与notify()改写上面的例子 下面的例子通过wait()来取代忙等待机制，当收到通知消息时，notify当前Monitor类线程。 Wait.java 
package concurrency.wait;

import java.util.concurrent.TimeUnit;

class MyObject implements Runnable {
    private Monitor monitor;

    public MyObject(Monitor monitor) {
      this.monitor = monitor;
    }

    public void run() {
      try {
        TimeUnit.SECONDS.sleep(3);
        System.out.println("i'm going.");
        monitor.gotMessage();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
}

class Monitor implements Runnable {
    private volatile boolean go = false;

    public synchronized void gotMessage() throws InterruptedException {
      go = true;
      notify();
    }

    public synchronized void watching() throws InterruptedException {
      while (go == false)
        wait();
      System.out.println("He has gone.");
    }

    public void run() {
      try {
        watching();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
}

public class Wait {
    public static void main(String[] args) {
      Monitor monitor = new Monitor();
      MyObject o = new MyObject(monitor);
      new Thread(o).start();
      new Thread(monitor).start();
    }
}
结果： i'm going. He has gone.

详解： 

在Java中，可以通过配合调用Object对象的wait（）方法和notify（）方法或notifyAll（）方法来实现线程间的通信。在线程中调用wait（）方法，将阻塞等待其他线程的通知（其他线程调用notify（）方法或notifyAll（）方法），在线程中调用notify（）方法或notifyAll（）方法，将通知其他线程从wait（）方法处返回。

      Object是所有类的超类，它有5个方法组成了等待/通知机制的核心：notify（）、notifyAll（）、wait（）、wait（long）和wait（long，int）。在Java中，所有的类都从Object继承而来，因此，所有的类都拥有这些共有方法可供使用。而且，由于他们都被声明为final，因此在子类中不能覆写任何一个方法。

      这里详细说明一下各个方法在使用中需要注意的几点：

       1、wait（）

      public final void wait()  throws InterruptedException,IllegalMonitorStateException

     该方法用来将当前线程置入休眠状态，直到接到通知或被中断为止。在调用wait（）之前，线程必须要获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait（）方法。进入wait（）方法后，当前线程释放锁。在从wait（）返回前，线程与其他线程竞争重新获得锁。如果调用wait（）时，没有持有适当的锁，则抛出IllegalMonitorStateException，它是RuntimeException的一个子类，因此，不需要try-catch结构。

      2、notify（）

     public final native void notify() throws IllegalMonitorStateException

        该方法也要在同步方法或同步块中调用，即在调用前，线程也必须要获得该对象的对象级别锁，的如果调用notify（）时没有持有适当的锁，也会抛出IllegalMonitorStateException。

     该方法用来通知那些可能等待该对象的对象锁的其他线程。如果有多个线程等待，则线程规划器任意挑选出其中一个wait（）状态的线程来发出通知，并使它等待获取该对象的对象锁（notify后，当前线程不会马上释放该对象锁，wait所在的线程并不能马上获取该对象锁，要等到程序退出synchronized代码块后，当前线程才会释放锁，wait所在的线程也才可以获取该对象锁），但不惊动其他同样在等待被该对象notify的线程们。当第一个获得了该对象锁的wait线程运行完毕以后，它会释放掉该对象锁，此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，会继续阻塞在wait状态，直到这个对象发出一个notify或notifyAll。这里需要注意：它们等待的是被notify或notifyAll，而不是锁。这与下面的notifyAll（）方法执行后的情况不同。 

      3、notifyAll（）

     public final native void notifyAll() throws IllegalMonitorStateException

      该方法与notify（）方法的工作方式相同，重要的一点差异是：

      notifyAll使所有原来在该对象上wait的线程统统退出wait的状态（即全部被唤醒，不再等待notify或notifyAll，但由于此时还没有获取到该对象锁，因此还不能继续往下执行），变成等待获取该对象上的锁，一旦该对象锁被释放（notifyAll线程退出调用了notifyAll的synchronized代码块的时候），他们就会去竞争。如果其中一个线程获得了该对象锁，它就会继续往下执行，在它退出synchronized代码块，释放锁后，其他的已经被唤醒的线程将会继续竞争获取该锁，一直进行下去，直到所有被唤醒的线程都执行完毕。

      4、wait（long）和wait（long,int）

     显然，这两个方法是设置等待超时时间的，后者在超值时间上加上ns，精度也难以达到，因此，该方法很少使用。对于前者，如果在等待线程接到通知或被中断之前，已经超过了指定的毫秒数，则它通过竞争重新获得锁，并从wait（long）返回。另外，需要知道，如果设置了超时时间，当wait（）返回时，我们不能确定它是因为接到了通知还是因为超时而返回的，因为wait（）方法不会返回任何相关的信息。但一般可以通过设置标志位来判断，在notify之前改变标志位的值，在wait（）方法后读取该标志位的值来判断，当然为了保证notify不被遗漏，我们还需要另外一个标志位来循环判断是否调用wait（）方法。

        深入理解：

   如果线程调用了对象的wait（）方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。

   当有线程调用了对象的notifyAll（）方法（唤醒所有wait线程）或notify（）方法（只随机唤醒一个wait线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。

   优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用wait（）方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了synchronized代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。


3、object.wait()和Thread.sleep()的区别

（1）这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。

sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。

（2）最主要是sleep方法没有释放锁，而了wait方法释放锁（但没释放同步资源），使得其他线程可以使用同步控制块或者方法。

sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。

Thread.Sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。

（3）使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用 
   synchronized(x){ 
      x.notify() 
     //或者wait() 
   }

（4）sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常


4、Thread中sleep()、join()和yield()区别

（1）sleep()

使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。

例如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程执行完毕后，低优先级的线程才能够执行；但是高优先级的线程sleep(500)后，低优先级就有机会执行了。

总之，sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。

（2）join()

join()方法使调用该方法的线程在此之前执行完毕，也就是等待该方法的线程执行完毕后再往下继续执行。注意该方法也需要捕捉InterruptedException异常。 

package test.core.threads;

public class JoinExample
{
   public static void main(String[] args) throws InterruptedException
   {
      Thread t = new Thread(new Runnable()
         {
            public void run()
            {
               System.out.println("First task started");
               System.out.println("Sleeping for 2 seconds");
               try
               {
                  Thread.sleep(2000);
               } catch (InterruptedException e)
               {
                  e.printStackTrace();
               }
               System.out.println("First task completed");
            }
         });
      Thread t1 = new Thread(new Runnable()
         {
            public void run()
            {
               System.out.println("Second task completed");
            }
         });
      t.start(); // Line 15
      t.join(); // Line 16
      t1.start();
   }
}

Output:

First task started
Sleeping for 2 seconds
First task completed
Second task completed

（3）yield()

该方法与sleep()类似，只是不能由用户指定暂停多长时间，并且yield（）方法只能让同优先级的线程有执行的机会。

Thread.yield();

//或者
try {
     Thread.sleep(100);//睡眠100毫秒
     } catch (Exception e) {
    e.printStackTrace();
}
       yield()是静态方法，使正在运行的线程进入就绪状态。
       yield()方法声明没有抛出异常。
       yield()方法是让系统的线程调度器重新调度当前线程。可能：当某个线程调用yield()方法之后，线程调度器又将其调度出来重新进入到运行状态执行。

实际上，yield()方法对应了如下操作；先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把CPU的占有权交给次线程，否则继续运行原来的线程，所以yield()方法称为“退让”，它把运行机会让给了同等级的其他线程。

sleep 方法允许较低优先级的线程获得运行机会，但yield（）方法执行时，当前线程仍处在可运行状态，所以不可能让出较低优先级的线程此时获取CPU占有权。在一个运行系统中，如果较高优先级的线程没有调用sleep方法，也没有受到I/O阻塞，那么较低优先级线程只能等待所有较高优先级的线程运行结束，方可有机会运行。

yield()只是使当前线程重新回到可执行状态，所有执行yield()的线程有可能在进入到可执行状态后马上又被执行，所以yield()方法只能使同优先级的线程有执行的机会。

注：通常不用yield()方法，而用sleep()方法。


5、Thread中start()和run()的区别？？？

         把需要处理的代码放到run()方法中，start()方法启动线程将自动调用run()方法，这个由java的内存机制规定的。并且run()方法必需是public访问权限，返回值类型为void。

       注：线程对象调用start()方法启动线程时，线程不一定立即启动，因为start()方法只是建议JVM启动该线程，具体何时启动有JVM决定。

               类似垃圾回收机制中，调用System.gc()也是建议JVM回收某对象，而不能强制立即回收。

（1）区别：

      start() : 它的作用是启动一个新线程，新线程会执行相应的run()方法。start()不能被重复调用。
      run()   : run()就和普通的成员方法一样，可以被重复调用。单独调用run()的话，会在当前线程中执行run()，而并不会启动新线程！

下面以代码来进行说明。

class MyThread extends Thread{  
public void run(){
        ...
    } 
};
MyThread mythread = new MyThread();

mythread.start()会启动一个新线程，并在新线程中运行run()方法。
而mythread.run()则会直接在当前线程中运行run()方法，并不会启动一个新线程来运行run()。

（2）实例：

下面，通过一个简单示例演示它们之间的区别。源码如下：

【Java之多线程（二）】（***重要***）Java多线程中常见方法的区别，如object.wait()和Thread.sleep()的区别等
 1 // Demo.java 的源码
 2 class MyThread extends Thread{  
 3     public MyThread(String name) {
 4         super(name);
 5     }
 6 
 7     public void run(){
 8         System.out.println(Thread.currentThread().getName()+" is running");
 9     } 
10 }; 
11 
12 public class Demo {  
13     public static void main(String[] args) {  
14         Thread mythread=new MyThread("mythread");
15 
16         System.out.println(Thread.currentThread().getName()+" call mythread.run()");
17         mythread.run();
18 
19         System.out.println(Thread.currentThread().getName()+" call mythread.start()");
20         mythread.start();
21     }  
22 }
【Java之多线程（二）】（***重要***）Java多线程中常见方法的区别，如object.wait()和Thread.sleep()的区别等

运行结果：

main call mythread.run()
main is running
main call mythread.start()
mythread is running

结果说明：
(01) Thread.currentThread().getName()是用于获取“当前线程”的名字。当前线程是指正在cpu中调度执行的线程。
(02) mythread.run()是在“主线程main”中调用的，该run()方法直接运行在“主线程main”上。
(03) mythread.start()会启动“线程mythread”，“线程mythread”启动之后，会调用run()方法；此时的run()方法是运行在“线程mythread”上。

（3）源码分析

Thread.java中start()方法的源码如下：

【Java之多线程（二）】（***重要***）Java多线程中常见方法的区别，如object.wait()和Thread.sleep()的区别等
public synchronized void start() {
// 如果线程不是"就绪状态"，则抛出异常！
if (threadStatus != 0)
throw new IllegalThreadStateException();

// 将线程添加到ThreadGroup中
    group.add(this);

boolean started = false;
try {
// 通过start0()启动线程
 start0();
// 设置started标记
        started = true;
    } finally {
try {
if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
        }
    }
}
【Java之多线程（二）】（***重要***）Java多线程中常见方法的区别，如object.wait()和Thread.sleep()的区别等

说明：start()实际上是通过本地方法start0()启动线程的。而start0()会新运行一个线程，新线程会调用run()方法。

private native void start0();

 

Thread.java中run()的代码如下：

public void run() {
if (target != null) {
        target.run();
    }
}

说明：target是一个Runnable对象。run()就是直接调用Thread线程的Runnable成员的run()方法，并不会新建一个线程。


标签：

相关文章