1. 
   
2. class MyThread extends Thread
   
3. {
   
4. private String name ;
   
5. public MyThread(String name){
   
6. this.name = name ;
   
7. }
   
8. public void run()
   
9. {
   
10. for(int i=0;i<10;i++)
    
11. {
    
12. System.out.println(name + "运行，i = " + i) ;
    
13. }
    
14. }
    
15. };
    
16. public class Thread01{
    
17. public static void main(String args[]){
    
18. MyThread mt1 = new MyThread("线程A ") ;
    
19. MyThread mt2 = new MyThread("线程B ") ;
    
20. mt1.run() ;
    
21. mt2.run() ;
    
22. }
    
23. };

复制代码

运行结果如图:

两个线程没有交替运行，反而顺序执行？

mt1.run() ;

mt2.run() ;
改成
要调用mt1.start();
mt2.start();
run方法是自动调用的

class MyThread extends Thread
{
private String name ;
public MyThread(String name){
this.name = name ;
}
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println(name + "运行，i = " + i) ;
}
}
};
public class Thread01{
public static void main(String args[]){
MyThread mt1 = new MyThread("线程A ") ;
MyThread mt2 = new MyThread("线程B ") ;
mt1.start(); //run() ;
mt2.start(); //run() ;
}
};

class MyThread extends Thread
{
private String name ;
public MyThread(String name){
this.name = name ;
}
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println(name + "运行，i = " + i) ;
}
}
};
public class Thread01{
public static void main(String args[]){
MyThread mt1 = new MyThread("线程A ") ;
MyThread mt2 = new MyThread("线程B ") ;
mt1.start(); //run() ;
mt2.start(); //run() ;
}
};

多线程开启的方法(或者说是模式吧)是：线程名.start()<mt.start()>,
在调用start()时会自动调用你重写的run方法并且开启一个新的线程。
而线程名.run()<mt.run()>你可以理解为就是常见的方法调用它只能调用
一个方法而不能开启一个线程.其作用与下面的类A的对象a调用show()方法的作用是一样的.

class A
{
        public void show()
        {
                System.out.println("show run");
        }
}

class B
{
        public static void main(String [] args)
        {
                 A a = new A();
                 a.show();
        }
}

希望以上的分析对你的学习有帮助，如有不妥之处请指正，大家一起进步。

创建线程的第一种方式：继承Thread类。
步骤：
1，定义类继承Thread。
2，复写Thread类中的run方法。
        目的：将自定义代码存储在run方法。让线程运行。

3，调用线程的start方法，
        该方法两个作用：启动线程，调用run方法。

class MyThread extends Thread
{
private String name ;
public MyThread(String name){
this.name = name ;
}
public void run()
{
for(int i=0;i<10;i++)     //次数少了你也看不到现象，你让循环次数多点  100，200的。
{
System.out.println(name + "运行，i = " + i) ;
}
}
};
public class Thread01{
public static void main(String args[]){
MyThread mt1 = new MyThread("线程A ") ;
MyThread mt2 = new MyThread("线程B ") ;
mt1.start();  //注意格式是start
mt2.start(); //注意格式是start

//mt1.run() ;   若按你的方式则会当成简单的函数按顺序运行下来
//mt2.run() ;
}
}

mt1.start();//mt1.run() ;   
mt2.start();//mt2.run() ;
这两句话改为调用start方法，如果调用run方法，那么在main方法执行到 mt1.run(); 读入的线程就是mt1现在所调用的run方法，他没有实现Java规定的多线程机制（多线程：需调用start方法，start会自动调用线程子类中的run方法，主函数在执行到mt1.start()时不会停顿去调用run方法，而是去执行mt2.start()，然后再执行主函数中其他的语句），这是单线程，因为mt1在调用run方法时，main方法会直到run方法执行完才会继续执行后面的语句。
在多线程问题中，虽然线程会有进入内存的先后顺序，但是执行顺序是随机的，原因是cpu每一次都是独立的执行一个线程（cpu在进程间的切换速度很快，可以达到我们所认知的同步运行），而其他线程就会被阻塞（有执行资格，但是没有cpu的执行权限），所以会出现先被执行的线程比后被执行的线程晚执行完，我们看到的打印状态可能是杂乱无章的，A线程可能会比B线程先打印。

进程可以同时开启，但在某一个时刻，CPU只在执行一个程序，在一段时间内CPU做的是在多个进程直接做快速切换执行,也就是说，多线程具有随机性。调用start（）方法时作用就是既要启动线程，又要调用父类的run（）方法，也就存在了线程抢夺CPU资源的问题，所以结果会有随机性。调用run（）方法是仅仅是对对象的run（）方法的调用，并没有启动进程。