我理想的结果是test is operating!和main is operating!"交错，结果感觉还是单线程的运行结果，不过main is operating!"先运行了，想知道为什么不是交错运行？求各位大神解答，

1. package threadtest;
   
2. 
   
3. class TestThreads extends Thread{
   
4.         public void run(){
   
5.                 for(int i=0;i<=4;i++)
   
6.                         System.out.println("test is operating!");
   
7.         }
   
8. }
   
9. public class TestThread {
   
10.         public static void main(String[] args) {
    
11.                 new TestThreads().start();
    
12.                 for(int i=0;i<=4;i++){
    
13.                         System.out.println("main is operating!");
    
14.                 }
    
15.         }
    
16. }

复制代码

这是我写的，真心觉得写的不好，不过功能实现了，，，，你可以参考下。。。

1. package test;
   
2. 
   
3. import java.util.concurrent.locks.Condition;
   
4. import java.util.concurrent.locks.Lock;
   
5. import java.util.concurrent.locks.ReentrantLock;
   
6. 
   
7. class TestThreads extends Thread{
   
8.     public void run(){
   
9.            
   
10.             for(int i=0;i<=4;i++)
    
11.             {
    
12.                     TestThread.lock.lock();
    
13.                     System.out.println("test is operating!");
    
14.                     try {
    
15.                             TestThread.condition1.signal();
    
16.                                                 TestThread.condition2.await();
    
17.                                                
    
18.                                                 TestThread.lock.unlock();
    
19.                                         } catch (InterruptedException e) {
    
20.                                                 // TODO Auto-generated catch block
    
21.                                                 e.printStackTrace();
    
22.                                         }
    
23.             }
    
24.     }
    
25. }
    
26. public class TestThread {
    
27.         static Lock lock=new ReentrantLock();
    
28.         static Condition condition1=lock.newCondition();
    
29.         static Condition condition2=lock.newCondition();
    
30.         public static void main(String[] args) throws InterruptedException {
    
31.                 new TestThreads().start();
    
32.                 for(int i=0;i<=4;i++){
    
33.                         lock.lock();
    
34.                         condition1.await();
    
35.                         System.out.println("main is operating!");
    
36.                     condition2.signal();
    
37.                     lock.unlock();
    
38.                 }
    
39.         }
    
40.    
    
41. }

复制代码

循环次数有点少，搞多一点，因为类加载器会先加载main类，所以可能会先执行main中的循环.

你的电脑性能好了呗，cpu一刷就运行完了呗，你把循环次数搞高点，你就能看到效果了，或者在搞个sleep，让它睡一会

这应该和类加载器有关，main主函数是程序的入口，所以会先被加载进内存，执行里面的代码，执行start方法的时候才加载TestThreads类，运行线程。

因为这是cpu自己选择执行的，你把run方法代码抽成一个函数，把main方法的代码抽成一个函数 然后在run方法写上一个死循环 调用这俩个方法 再那俩个方法加上互斥 通讯，这个就可以交错运行了