1. public class ThreadTest {
   
2.         public static void main(String args[]) {
   
3.                 MyThread t = new MyThread();               
   
4.                 t.run();
   
5.                
   
6.                 t.start();
   
7.                 System.out.println("A");
   
8.         }
   
9. }
   
10. 
    
11. class MyThread extends Thread {
    
12.         public void run() {
    
13.                 try {
    
14.                         Thread.sleep(3000);
    
15.                 } catch (InterruptedException e) {
    
16.                 }
    
17.                 System.out.println("B");
    
18.         }
    
19. }

复制代码

看不懂为什么运行结果为BAB ？
难道不是函数和t抢资源吗？

问题已解决

public class A {
        public static void main(String args[]) {
                MyThread t = new MyThread();               
                t.run();//你这里调用了MyTread对象的run()方法，是把run()方法单做一个普通的方法
                                //调用的，这跟MyTread是不是继承了Thread没有关系，就是普通的方法调用
                                  //所以就先打印了run()方法的打印语句里的B
               
                t.start();//当调用start()方法时，就启动了一个线程并执行里面的run()方法
                                       
                System.out.println("A");
        }
}

class MyThread extends Thread {
        public void run() {
                try {
                        Thread.sleep(3);//由于你在方法中调用了sleep方法，所以执行到这此线程就
                                                        //停止了，下面的打印没执行到CPU就去执行主线程了打印了A
                } catch (InterruptedException e) {
                }
                System.out.println("B");//等sleep时间到接着往下执行，打印B，所以结果是BAB
        }

}

另外抢资源的是t这个线程就是MyThrea里的run()方法执行，与主函数的执行之间强资源，

网路出问题了，一连发了2遍，是一样的内容

public class ThreadTest {
        public static void main(String args[]) {
                MyThread t = new MyThread();               
                t.run();  1.你这里调用的是run()方法，并没有开启线程，而是主函数在运行run()方法中的内容
               
                t.start();3.主线程将副线程也就是你建立的线程开启了，这是有2个线程在运行，副线程开启后去执行run()方法中的内容了，而主线程继续向下执行。
                System.out.println("A");4.主线程运行到了这里，为什么副线程没有抢到资源，因为副线程在下面被sleep了，主线程在这里打了"A".        }
}

class MyThread extends Thread {
        public void run() {   2.主函数的线程运行到了这里，主线程睡了3秒，然后打印了"B",
                try {
                        Thread.sleep(3000);
                } catch (InterruptedException e) {
                }
                System.out.println("B");5.副线程醒了以后打印了"B",程序结束。
        }
}
所以结果当然是BAB了，线程拿到执行权是随机的，但是对线程进行控制。
红色的字是我写的5个步骤，希望对你有帮助。

public class ThreadTest {
        public static void main(String args[]) {
                MyThread t = new MyThread();               
                t.run();  1.你这里调用的是run()方法，并没有开启线程，而是主函数在运行run()方法中的内容
               
                t.start();3.主线程将副线程也就是你建立的线程开启了，这是有2个线程在运行，副线程开启后去执行run()方法中的内容了，而主线程继续向下执行。
                System.out.println("A");4.主线程运行到了这里，为什么副线程没有抢到资源，因为副线程在下面被sleep了，主线程在这里打了"A".        }
}

class MyThread extends Thread {
        public void run() {   2.主函数的线程运行到了这里，主线程睡了3秒，然后打印了"B",
                try {
                        Thread.sleep(3000);
                } catch (InterruptedException e) {
                }
                System.out.println("B");5.副线程醒了以后打印了"B",程序结束。
        }
}
所以结果当然是BAB了，线程拿到执行权是随机的，但是对线程进行控制。
红色的字是我写的5个步骤，希望对你有帮助。