public class Hello implements Runnable {
        private int count=50;
        public void run(){
                for(int i=0;i<100;i++){
                        if （count >0）
                          Thread.sleep(1000);
                        System.out.println(count--);
                       }
                }       
               
    public static void main(String[] args) {
       
                        Hello t=new Hello();
                        Thread h =new Thread(t);
                        Thread e=new Thread(t);
                        h.start();
                        e.start();
                }
               
}
我在里面加了个 Thread.sleep(1000);  怎么 运行不了了啊

public void run(){
                for(int i=0;i<100;i++){
                        if count >0
                        System.out.println(count--);
                       }
                }  

if 后面的要用括号括起来啊,那样才能代表一个语句啊
public class Hello implements Runnable
{
    private int count=50;
    public void run(){
            for(int i=0;i<100;i++)
            {
                    if (count >0)
                    System.out.println(count--);
                   }
            }
}

朱皓 发表于 2012-2-26 22:14
public void run(){
                for(int i=0;i0
                        System.out.println(count- ...

我是说运行的结果有问题 运行结果是 50
48
47
46
45
44
43
42
41
40
39
38
37
36
35
34
33
32
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
49

语法错误,要这样if()

沙漠里的小鱼 发表于 2012-2-26 22:21
我是说运行的结果有问题 运行结果是 50
48
47

没问题，线程执行看的是优先级，不是先后顺序，所以输出结果不是预期的那样

我看是可以运行的，if条件写好。
结果是50没错啊，因为两个线程操作的是同一数据，相当于两个窗口一起出售50张票一样
要说的话就是安全问题了

你想要什么样的结果啊 ,出现这样是很正常啊,这个是两个线程公用了一份资源的结果啊
一个线程执行到49的时候被另一线程抢去了执行权,所以就从48开始输出,到这个线程执行完了,
刚刚那个线程又抢回了执行权,就把49输出了.过程就是这样
其实你因该这样写,更方便分析问题
public class Hello implements Runnable
{
    private int count=50;
    public void run()
    {
            for(int i=0;i<100;i++)
            {
                    if (count >0)
                    System.out.println(Thread.currentThread().getName()+":"+ count--);
            }
     }
}

蓝色火焰 发表于 2012-2-26 22:24
没问题，线程执行看的是优先级，不是先后顺序，所以输出结果不是预期的那样 ...

那我加了咯 Thread.sleep(1000); 怎么程序就运行不了了

你没抛出异常吧

下面是加了Thread.Sleep(1000)的运行结果
50504948474746464544434342424140393938373636343533323131·······

蓝色火焰 发表于 2012-2-26 22:36
下面是加了Thread.Sleep(1000)的运行结果
50504948474746464544434342424140393938373636343533323131·· ...

我加Thread.Sleep(1000)怎么运行不了啊

没捕获异常，怎么运行。伤不起

程序报错了没？有没有抛出异常啊，还有把Thread.Sleep(1000)和输出语句用大括号括起来

1. class MyThread implements Runnable{
   
2. 
   
3.         private int count=50;
   
4.         public void run() {
   
5.                 // TODO Auto-generated method stub
   
6.                 for(int i=0;i<100;i++){
   
7.                         if(count>0){
   
8.                                 try {
   
9.                                         Thread.sleep(1000);
   
10.                                 } catch (InterruptedException e) {
    
11.                                         // TODO Auto-generated catch block
    
12.                                         e.printStackTrace();
    
13.                                 }
    
14.                                 System.out.print(count--);
    
15.                         }
    
16.                 }
    
17.         }
    
18.        
    
19. }

复制代码

试试这个

你让每个线程都休1000秒那多线程的乱序性当然就体现不出来了。
多线程最主要体现它的乱序性，每个线程运行到sleep都会休息等下个线程运行，
所以结果都是连续的。

张乃智 发表于 2012-2-26 23:35
你让每个线程都休1000秒那多线程的乱序性当然就体现不出来了。
多线程最主要体现它的乱序性，每个线程运行 ...

1000毫秒哦！=1秒！

额，是这样的，你这个问题首先是：
1.你的if语句没有加大括号
2.你if后面的"()"是中文的括号
3.你在线程挂起(休眠)时没有进行异常处理
下面是我的代码，你看看吧，希望有所帮助：

1. public class Hello implements Runnable {
   
2.         private int count=50;
   
3.         public void run(){
   
4.                 for(int i=0;i<100;i++){
   
5.                         if (count >0){
   
6.                           try {
   
7.                                                         Thread.sleep(1000);
   
8.                                                 } catch (InterruptedException e) {
   
9.                                                         // TODO Auto-generated catch block
   
10.                                                         e.printStackTrace();
    
11.                                                 }
    
12.                         System.out.println(count--);
    
13.                        }
    
14.                 }
    
15.                 }        
    
16.                
    
17.     public static void main(String[] args) {
    
18.         
    
19.                         Hello t=new Hello();
    
20.                         Thread h =new Thread(t);
    
21.                         Thread e=new Thread(t);
    
22.                         h.start();
    
23.                         e.start();
    
24.                 }
    
25.                
    
26. }

复制代码

运行结果：

50
49
48
47
46
45
44
43
42
41
40
39
38
37
36
35
34
33
32
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0

舞动的心弦 发表于 2012-2-27 13:26
1000毫秒哦！=1秒！

额   一时没注意:L