黑马程序员技术交流社区

标题: 菜鸟求问题解答.. [打印本页]
作者: 芦青    时间: 2013-1-27 13:49
标题: 菜鸟求问题解答..
本帖最后由 张向辉 于 2013-1-29 11:44 编辑

class xc implements Runnable
{
        public void run()
        {
                //复写Runnable的Run方法..
        }
}

public class lei
{
        public static void main(String[] args)
        {
        {        
                xc a=new xc();
               
                Thread  t=new Thread(a);
               
                t.start();
               
        }
}



为什么Runnable接口的子类对象当成实际参数传递给Thread构造函数的时候..当Thread调用Start方法开启线程时，就可以调用到


Runnable接口的子类对象中的run方法了？？求精辟点，易理解的语言...
作者: 刘军亭    时间: 2013-1-27 14:19
在Thread类的构造函数时候可以接受一个对象，但是为了安全规范这个对象必须实现Runnable接口。Thread类还有判断创建Thread对象时候传进来的对象是否为null，如果不为null就运行传进来的Runnable对象的run()方法


         
作者: vmvm555    时间: 2013-1-27 16:35
托你的福，我第一次跑去看源码了，下面附上源代码
  1.     public Thread(Runnable target) {
  2.         init(null, target, "Thread-" + nextThreadNum(), 0);
  3.     }
  4.     private void init(ThreadGroup g, Runnable target, String name,
  5.                       long stackSize) {
  6.         if (name == null) {
  7.             throw new NullPointerException("name cannot be null");
  8.         }

  10.         Thread parent = currentThread();
  11.         SecurityManager security = System.getSecurityManager();
  12.         if (g == null) {
  13.             /* Determine if it's an applet or not */

  15.             /* If there is a security manager, ask the security manager
  16.                what to do. */
  17.             if (security != null) {
  18.                 g = security.getThreadGroup();
  19.             }

  21.             /* If the security doesn't have a strong opinion of the matter
  22.                use the parent thread group. */
  23.             if (g == null) {
  24.                 g = parent.getThreadGroup();
  25.             }
  26.         }

  28.         /* checkAccess regardless of whether or not threadgroup is
  29.            explicitly passed in. */
  30.         g.checkAccess();

  32.         /*
  33.          * Do we have the required permissions?
  34.          */
  35.         if (security != null) {
  36.             if (isCCLOverridden(getClass())) {
  37.                 security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
  38.             }
  39.         }

  41.         g.addUnstarted();

  43.         this.group = g;
  44.         this.daemon = parent.isDaemon();
  45.         this.priority = parent.getPriority();
  46.         this.name = name.toCharArray();
  47.         if (security == null || isCCLOverridden(parent.getClass()))
  48.             this.contextClassLoader = parent.getContextClassLoader();
  49.         else
  50.             this.contextClassLoader = parent.contextClassLoader;
  51.         this.inheritedAccessControlContext = AccessController.getContext();
  52.         this.target = target;//看懂这句话就行了
  53.         setPriority(priority);
  54.         if (parent.inheritableThreadLocals != null)
  55.             this.inheritableThreadLocals =
  56.                 ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
  57.         /* Stash the specified stack size in case the VM cares */
  58.         this.stackSize = stackSize;

  60.         /* Set thread ID */
  61.         tid = nextThreadID();
  62.     }
复制代码
  1.     public synchronized void start() {
  2.         /**
  3.          * This method is not invoked for the main method thread or "system"
  4.          * group threads created/set up by the VM. Any new functionality added
  5.          * to this method in the future may have to also be added to the VM.
  6.          *
  7.          * A zero status value corresponds to state "NEW".
  8.          */
  9.         if (threadStatus != 0)
  10.             throw new IllegalThreadStateException();

  12.         /* Notify the group that this thread is about to be started
  13.          * so that it can be added to the group's list of threads
  14.          * and the group's unstarted count can be decremented. */
  15.         group.add(this);

  17.         boolean started = false;
  18.         try {
  19.             start0();
  20.             started = true;
  21.         } finally {
  22.             try {
  23.                 if (!started) {
  24.                     group.threadStartFailed(this);
  25.                 }
  26.             } catch (Throwable ignore) {
  27.                 /* do nothing. If start0 threw a Throwable then
  28.                   it will be passed up the call stack */
  29.             }
  30.         }
  31.     }
  32.     private native void start0();

  34.     /**
  35.      * If this thread was constructed using a separate
  36.      * <code>Runnable</code> run object, then that
  37.      * <code>Runnable</code> object's <code>run</code> method is called;
  38.      * otherwise, this method does nothing and returns.
  39.      * <p>
  40.      * Subclasses of <code>Thread</code> should override this method.
  41.      *
  42.      * @see     #start()
  43.      * @see     #stop()
  44.      * @see     #Thread(ThreadGroup, Runnable, String)
  45.      */
  46.     @Override
  47.     public void run() {
  48.         if (target != null) {
  49.             target.run();//这句话看的懂吧
  50.         }
  51.     }
复制代码
乱七八糟的英文不用看，只看构造方法和start()方法就行了，因为你没抛出异常，所以catch语句和finally语句也无需看，这样就简单了
作者: 杨玲    时间: 2013-1-27 17:05
本帖最后由 杨玲 于 2013-1-27 17:18 编辑

楼上源码都帖出来了,呵呵,不过简单总结一下就是在Thread类中定义了一个Runnable接口的引用,并实现了Runnable接口,覆写了它的run方法,在该方法中会先判断这个引用是否为空,如果是以继承Thread形式存在的话,这个run方法就被覆写了,它会调用被子类覆写的run方法,如果是实现Runnable接口的,并把其作为参数传递时,那么这时这个Runnable的引用不为空,在run方法中就会调用这个引用中的run方法.



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2