1. public class ThreadDemo extends Thread
   
2. {
   
3. 
   
4. 
   
5. private int a;
   
6. public void start()
   
7. {
   
8. super.start();
   
9. }
   
10. public void run(){
    
11. System.out.println("线程"+currentThread().getName()+"启动");
    
12. for(a=0;a<40;a++){
    
13. System.out.println(currentThread().getName()+":"+a);
    
14. }
    
15. }
    
16. public static void main(String[] args) {
    
17. ThreadDemo m1 = new ThreadDemo();
    
18. m1.start();
    
19. ThreadDemo m2 = new ThreadDemo();
    
20. m2.start();
    
21. for(int x=0;x<40;x++)
    
22. {
    
23. System.out.println("main线程:"+x);
    
24. }
    
25. }
    
26. }
    

复制代码

1. public class Machine3 extends Thread{
   
2. private int a;
   
3. public void start(){
   
4. run();
   
5. }
   
6. public void run(){
   
7. for(a=0;a<40;a++){
   
8. System.err.println(currentThread().getName()+":"+a);
   
9. }
   
10. }
    
11. public static void main(String[] args) {
    
12. Machine3 m1 = new Machine3();
    
13. m1.start(); //试一下去掉start方法后的结果
    
14. Machine3 m2 = new Machine3();
    
15. m2.start();
    
16. }
    
17. }

复制代码

重写start方法能用第二段吗？

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. 
    
33.     private native void start0();
    
34. 
    
35.     /**
    
36.      * If this thread was constructed using a separate
    
37.      * <code>Runnable</code> run object, then that
    
38.      * <code>Runnable</code> object's <code>run</code> method is called;
    
39.      * otherwise, this method does nothing and returns.
    
40.      * <p>
    
41.      * Subclasses of <code>Thread</code> should override this method.
    
42.      *
    
43.      * @see     #start()
    
44.      * @see     #stop()
    
45.      * @see     #Thread(ThreadGroup, Runnable, String)
    
46.      */
    
47.     @Override
    
48.     public void run() {
    
49.         if (target != null) {
    
50.             target.run();
    
51.         }
    
52.     }

复制代码

start()的源代码附上，是调用了系统底层的strat0()方法，所以你这样重写应该是不可以的，会有很多安全隐患
被native修饰的方法就表示是系统底层的方法

客gou你好，{:soso_e113:}

线程要执行的代码都保存在run方法中了，而start()方法是开启线程的，你却把线程要执行的代码，放到了开启线程的方法里。
前一个代码是调用父类的空的构造函数，所以线程开始了。后一个代码是调用了该线程要运行的代码。

有些个人观点在里面。

袁梦希 发表于 2013-4-26 10:38
客gou你好，

线程要执行的代码都保存在run方法中了，而start()方法是开启线程的，你却把线程 ...

感动狗啊这贴考验黑马学员了，仔细看看 代码2和线程有关系吗？

尹丽峰 发表于 2013-4-26 10:40
感动狗啊这贴考验黑马学员了，仔细看看 代码2和线程有关系吗？

我说有关系了么，你根本都没开启线程，也没调用start()方法   哪来的线程呢   我说的是主线程    哈哈哈哈。小样{:soso_e113:}

袁梦希 发表于 2013-4-26 10:50
我说有关系了么，你根本都没开启线程，也没调用start()方法   哪来的线程呢   小样 ...

亲 你运行一下代码2 看看有没？看看启动没？

尹丽峰 发表于 2013-4-26 10:53
亲 你运行一下代码2 看看有没？看看启动没？

第一个有运行线程了
但是第二个也运行线程
但是只有一个主线程而已...

我想问一下调用父类的start方法和调用本身的start方法有什么区别。
源码我是没看懂，求高人解释

刘胜寒 发表于 2013-4-26 18:43
第一个有运行线程了
但是第二个也运行线程
但是只有一个主线程而已...

高级黑马真是名不虚传，感谢你的回答，你回答的完全正确，第二个没启动别的线程只是一个主线程在执行，super.start();是直接调用了父类的start方法，而第二段代码中的start只是一个start方法并没有重写父类的start方法

尹丽峰 发表于 2013-4-26 20:43
高级黑马真是名不虚传，感谢你的回答，你回答的完全正确，第二个没启动别的线程只是一个主线程在执行，su ...

我没去黑马...
只是准备去黑马...
我想问一下第一个代码
调用父类的start和调用本身的start有什么区别...
但是运行第一个结果好像是没区别

如果仍有问题，请继续追问，如果问题已解决，请将分类改为已解决，谢谢