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方法了？？求精辟点，易理解的语言...

在Thread类的构造函数时候可以接受一个对象，但是为了安全规范这个对象必须实现Runnable接口。Thread类还有判断创建Thread对象时候传进来的对象是否为null，如果不为null就运行传进来的Runnable对象的run()方法


         

托你的福，我第一次跑去看源码了，下面附上源代码

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.         }
   
9. 
   
10.         Thread parent = currentThread();
    
11.         SecurityManager security = System.getSecurityManager();
    
12.         if (g == null) {
    
13.             /* Determine if it's an applet or not */
    
14. 
    
15.             /* If there is a security manager, ask the security manager
    
16.                what to do. */
    
17.             if (security != null) {
    
18.                 g = security.getThreadGroup();
    
19.             }
    
20. 
    
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.         }
    
27. 
    
28.         /* checkAccess regardless of whether or not threadgroup is
    
29.            explicitly passed in. */
    
30.         g.checkAccess();
    
31. 
    
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.         }
    
40. 
    
41.         g.addUnstarted();
    
42. 
    
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;
    
59. 
    
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();
    
11. 
    
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);
    
16. 
    
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();
    
33. 
    
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语句也无需看，这样就简单了

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