1. public class Demo extends Thread
   
2. {
   
3.         
   
4.         public void run()
   
5.         {
   
6.         
   
7.                 for (int x = 0; x <= 100; x++)
   
8.                 {
   
9.                         System.out.println("demo----run" + x);
   
10.                 }
    
11.         }
    
12. }
    
13. 
    
14. public class ThreadDemo
    
15. {
    
16.         
    
17.         public static void main(String[] args)
    
18.         {
    
19.         
    
20.                 Demo demo = new Demo();
    
21.                 demo.start();
    
22.                 for (int x = 0; x <= 100; x++)
    
23.                 {
    
24.                         System.out.println("hello world" );
    
25.                 }
    
26.         }
    
27. }

复制代码

这种情况下，我运行了好几次，把循环改成一千也不交替执行。
但是当把代码改成下面这样就能有交替执行的效果了。

1. public class Demo extends Thread
   
2. {
   
3.         
   
4.         public void run()
   
5.         {
   
6.         
   
7.                 for (int x = 0; x <= 100; x++)
   
8.                 {
   
9.                         System.out.println("demo----run" + x);
   
10.                 }
    
11.         }
    
12. }
    
13. 
    
14. public class ThreadDemo
    
15. {
    
16.         
    
17.         public static void main(String[] args)
    
18.         {
    
19.         
    
20.                 Demo demo = new Demo();
    
21.                 demo.start();
    
22.                 for (int x = 0; x <= 100; x++)
    
23.                 {
    
24.                         System.out.println("hello world"+x );
    
25.                 }
    
26.         }
    
27. }

复制代码

public class Demo extends Thread
{
        
        public void run()
        {
        
                for (int x = 0; x <= 100; x++)
                {
                        System.out.println("demo----run" + x);
                }
        }
}

public class ThreadDemo
{
        
        public static void main(String[] args)
        {
        
                Demo demo = new Demo();
                demo.start();
                for (int x = 0; x <= 100; x++)
                {
                        System.out.println("hello world" );
                }
        }
}

我个人的理解是，其实是这个没有抢过主线程的执行权。 如果加上x那就会慢下来，就会看到交替执行，如果不加的话太快了。

sunhaodi 发表于 2012-6-19 22:56
public class Demo extends Thread
{
        

可是我把循环次数后面调到1000了还是个这，不理解。。。

线程中定义了方法run，称为线程体方法，指定线程所要执行的命令序列，创建一个线程并调用start方法启动线程，run方法会自动调用，如果在Thread的子类中覆盖run方法，则线程启动后子类中定义的run方法被调用。
这是我写的一个典型例子：看看。
class ThreadDemo
{
        public static void main(String[] args)
        {
                 new Test().start();   //这里调用的是start（）方法
                 //new Test().run();

                while(true){
                        System.out.println("主线程运行！");
        }
}
}
class Test extends Thread{   //继承Thread类
        public void run(){
                while(true){
                        System.out.println(Thread.currentThread().getName()+"正在运行！");
}
}
}

胡大强 发表于 2012-6-19 23:00
线程中定义了方法run，称为线程体方法，指定线程所要执行的命令序列，创建一个线程并调用start方法启动线程 ...

能给我解释一下我这个是怎么回事么？
希望给点建议。。。我有点不理解。。。
是不是就是次数少的问题？没有执行上？

薄炳鑫 发表于 2012-6-19 23:06
能给我解释一下我这个是怎么回事么？
希望给点建议。。。我有点不理解。。。
是不是就是次数少的问题？没 ...

就是线程中定义了run方法，并调用start的方法，就代表启动这个线程了，

你那个就是次数少， 要不你用下sleep(1000); 试一下

sunhaodi 发表于 2012-6-19 23:10
就是线程中定义了run方法，并调用start的方法，就代表启动这个线程了，

你那个就是次数少， 要不你用下s ...

忘记了，我试验一下。

sunhaodi 发表于 2012-6-19 23:10
就是线程中定义了run方法，并调用start的方法，就代表启动这个线程了，

你那个就是次数少， 要不你用下s ...

使用这个方法试验出来了，就是次数太少了。那会想了半天也忘记用这个方法试验了。
下面是我刚才调试的代码。

1. public class ThreadDemo
   
2. {
   
3.        
   
4.         public static void main(String[] args) throws InterruptedException
   
5.         {
   
6.        
   
7.                 Demo demo = new Demo();
   
8.                 demo.start();
   
9.                 for (int x = 0; x <= 100; x++)
   
10.                 {
    
11.                         Thread.sleep(1000);
    
12.                         System.out.println("hello world" + x);
    
13.                 }
    
14.         }
    
15.        
    
16. }
    
17. 
    
18. public class Demo extends Thread
    
19. {
    
20.        
    
21.         public void run()
    
22.         {
    
23.        
    
24.                 for (int x = 0; x <= 100; x++)
    
25.                 {
    
26.                         try
    
27.                         {
    
28.                                 Thread.sleep(1000);
    
29.                         }
    
30.                         catch (InterruptedException e)
    
31.                         {
    
32.                                 e.printStackTrace();
    
33.                         }
    
34.                         System.out.println("demo----run" + x);
    
35.                 }
    
36.         }
    
37. }

复制代码

谢谢了。。。

薄炳鑫 发表于 2012-6-19 23:06
能给我解释一下我这个是怎么回事么？
希望给点建议。。。我有点不理解。。。
是不是就是次数少的问题？没 ...

我想跟次数没有关系。。次数只是一个循环问题。。。
你将那个System。out。print（“hello world”+x）这句改一下：
System.out.print（Thread.currentThread().getName()+"正在运行"）；//获得当前线程的名字。。

public class Demo extends Thread   //我用EditPlus运行的,你这个类中定义了两个公共类.给文件命名的时候你用那个呢?
{
        
        public void run()
        {
        
                for (int x = 0; x <= 100; x++)
                {
                        System.out.println("demo----run" + x);
                }
        }
}
public class ThreadDemo
{
        
        public static void main(String[] args)
        {
        
                Demo demo = new Demo();
                demo.start();
             demo.setPriority(Thread.MAX_PRIORITY);
                for (int x = 0; x <= 100; x++)
                {
                        System.out.println("hello world" );
                }
        }
}//在主线程中调用了start()方法,开启了另外的一个线程
//.加上主线程就有2个线程了.就有了多线程.我去掉了没有主函数的public,运行了你的代码,是OK的
//线程的交替出现是随机性的.看谁强到CPU执行权就执行谁.这就是体现了随机性.另外线程是有优先级的.优先级是[1-10]一般主线程优先级高默认为5
.如果你看不到效果的话可以给demo设置优先级.