重写线程类start（）方法-yiteyi-C++库

无论何时重写start（）方法，我们的start（）方法都会像普通方法调用一样执行，并且不会创建新线程。我们可以重写Thread类的start/run方法，因为它不是final。但是 不建议重写start（）方法 ，否则会破坏多线程概念。

null

                     // Java program illustrate the concept of                   
                     // overriding of start() method                   
                     class                               Bishal                               extends                               Thread {                   
                     public                               void                               start()                   
                                         {                   
                                         System.out.println(                               "Start Method"                               );                   
                                         }                   
                     public                               void                               run()                   
                                         {                   
                                         System.out.println(                               "Run Method"                               );                   
                                         }                   
                     }                               class                               Geeks {                   
                     public                               static                               void                               main(String[] args)                   
                                         {                   
                                         Bishal thread =                               new                               Bishal();                   
                                         thread.start();                   
                                         System.out.println(                               "Main Method"                               );                   
                                         }                   
                     }                   

输出：

Start Method
Main Method

注：在上面的程序中，当我们通过Bishal类的对象调用start（）方法时，将不会创建任何线程，所有函数都只由主线程完成。

JVM为上述程序提供的运行时堆栈： 图片[1]-重写线程类start（）方法-yiteyi-C++库

当我们在线程上调用start（）方法时，它会在内部用新创建的线程调用run（）方法。所以，如果我们重写start（）方法，在我们编写调用run（）方法的代码之前，不会调用run（）方法。 另一个例子：

                     class                               GThread                               extends                               Thread                   
                     {                   
                                         public                               void                               run()                   
                                         {                   
                                         System.out.println(                               "GThread: run()"                               );                   
                                         }                   
                             
                                         public                               void                               start()                   
                                         {                   
                                         System.out.println(                               "GThread: start()"                               );                   
                                         }                   
                     }                   
                             
                     class                               GRunnable                               implements                               Runnable                   
                     {                   
                                         public                               void                               run()                   
                                         {                   
                                         System.out.println(                               "GRunnable: run()"                               );                   
                                         }                   
                             
                                         public                               void                               start()                   
                                         {                   
                                         System.out.println(                               "GRunnable: start()"                               );                   
                                         }                   
                     }                   
                             
                     public                               class                               MyTest                   
                     {                   
                                         public                               static                               void                               main(String args[])                   
                                         {                   
                                         GThread gt  =                               new                               GThread();                   
                                         GRunnable gr =                               new                               GRunnable();                   
                                         Thread thread  =                               new                               Thread(gr);                   
                                         gt.start();                   
                                         thread.start();                   
                                         }                   
                     }                   