想问：为什么程序会一直运行下去，不是tick=0时程序就不停止运行结束了吗？
class Ticket implements Runnable//extends Thread
{
        private int tick = 100;
        public void run()
        {
                while (true)
                {
                        if(tick > 0)
                        {
                                System.out.println(Thread.currentThread().getName()+"....sale: " + tick--);
                        }
                }
        }
}

class  TicketDemo
{
        public static void main(String[] args)
        {
                Ticket t = new Ticket();

                Thread t1 = new Thread(t);//创建了一个线程;
                Thread t2 = new Thread(t);//创建了一个线程;
                Thread t3 = new Thread(t);//创建了一个线程;
                Thread t4 = new Thread(t);//创建了一个线程;
                t1.start();
                t2.start();
                t3.start();
                t4.start();


                //Ticket t1 = new Ticket();
                //t1.start();
        }
}

你没有设置tick不大于0时的条件，在你的程序中就算ticket=0或小于0还是执行while里面的语句，因为while的条件是true，是死循环，这样就好了

1.   while (true)
   
2.                 {
   
3.                         if(tick > 0)
   
4.                         {
   
5.                                 System.out.println(Thread.currentThread().getName()+"....sale: " + tick--);
   
6.                         }
   
7.                         else
   
8.                         {
   
9.                                 break;
   
10.                                
    
11.                         }
    
12.                 }

复制代码

1. class Ticket implements Runnable//extends Thread
   
2. {
   
3.         private int tick = 100;
   
4.         public void run()
   
5.         {
   
6.                 while (true)//看到这里没有，你一直while(true),他会无限循环的，顶多tick小于0的时候不执行if语句而已
   
7.                 {
   
8.                         if(tick > 0)
   
9.                         {
   
10.                                 System.out.println(Thread.currentThread().getName()+"....sale: " + tick--);
    
11.                         }
    
12. 
    
13.                 }
    
14.         }
    
15. }
    
16. //这块你可以这么写，定义一个标志位
    
17. class Ticket implements Runnable//extends Thread
    
18. {
    
19.         private int tick = 100;
    
20.         private boolean flag=true;//这是标志位，用于控制while语句运行
    
21.         public void run()
    
22.         {
    
23.                 while (flag)
    
24.                 {
    
25.                         if(tick > 0)
    
26.                         {
    
27.                                 System.out.println(Thread.currentThread().getName()+"....sale: " + tick--);
    
28.                         }
    
29.                         else
    
30.                         {
    
31.                                 flag=false;//这里如果tick小于0，标志位为flase，不再进入while循环
    
32.                          }
    
33. 
    
34.                 }
    
35.         }
    
36. }

复制代码

而且你的程序中没有加锁，容易造成数据的错误，像我下面的代码，在程序中加个锁就好了

1. while (true) {
   
2.                         if (tick > 0) {
   
3.                                 synchronized (Ticket.class) {
   
4. 
   
5.                                         if (tick > 0) {
   
6.                                                 try {
   
7.                                                         Thread.sleep(22);
   
8.                                                 } catch (Exception e) {
   
9.                                                 }
   
10.                                                 System.out.println(Thread.currentThread().getName()
    
11.                                                                 + "....sale: " + tick--);
    
12.                                         } else {
    
13.                                                 break;
    
14.                                         }
    
15.                                 }
    
16.                         }
    
17.                 }

复制代码

因为while的条件一直为TRUE,所以程序还是一直在做while循环，你要这样做：先设置一个flag标示，并加入一个if判断句，当tick == 100时把flag标示设为false就行了。

1. public class Runable {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.             Ticket t = new Ticket();
   
8. 
   
9.             Thread t1 = new Thread(t);//创建了一个线程;
   
10.             Thread t2 = new Thread(t);//创建了一个线程;
    
11.             Thread t3 = new Thread(t);//创建了一个线程;
    
12.             Thread t4 = new Thread(t);//创建了一个线程;
    
13.             t1.start();
    
14.             t2.start();
    
15.             t3.start();
    
16.             t4.start();
    
17. 
    
18. 
    
19.             //Ticket t1 = new Ticket();
    
20.             //t1.start();
    
21.     }
    
22. }
    
23. class Ticket implements Runnable{
    
24.         private boolean flag = true;
    
25.     private int tick = 100;
    
26.     public void run()
    
27.     {
    
28.             while (flag){
    
29.                     if(tick > 0)
    
30.                     {
    
31.                             System.out.println(Thread.currentThread().getName()+"....sale: " + tick--);
    
32.    
    
33.                     }
    
34.                     if(tick == 0){
    
35.                             flag = false;
    
36.                     }
    
37.             }
    
38.     }
    
39. }

复制代码

创建线程有两种方式
创建线程的第一种方式：继承Thread类
步骤：
1，定义类继承Thread
2，复写Thread类中的run方法
        目的：将自定义的代码存储在run方法。让线程运行
3，调用start方法
        该方法有两个作用：启动线程，调用run方法

创建线程的第二种方式：实现Runnable借口
步骤：
1，定义类实现Runnable借口
2，覆盖Runnable接口中的run方法
        将线程要运行的代码存放在run方法中
3，通过Thread类建立线程对象
4，将Runnable类接口的子类对象作为实际参数传递给Thread类的构造函数
        为什么要将Runnable接口的子类对象传递给Thread的构造函数？
                因为自定义的run方法所属的对象是Runnable接口的子类对象
                所以要让线程去指定对象的run方法；就必须明确该方法所属的对象

5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

为什么要覆盖run方法呢？
Thread类用于描述线程
该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法

当程序开始运行时，是主线程先运行，当调用到t1.start()时，线程t1开始运行，之后线程t1,t2,t3,t4,和主线程抢占cpu，谁抢到谁执行，但是你run方法中是一个while循环，没有结束标记，老师是为了演示现象才用while循环的
，如果想结束，按Ctrl+c 或者 eclipse中 结束控制台的运行就好了，或者在循环中判断结束标记，然后break

1. while(true){
   
2.       if(tick>0)
   
3.           System.out.println(Thread.currentThread()+" "+tick--);
   
4.       else
   
5.           break;
   
6. }

复制代码

也许依然 发表于 2014-4-19 11:24
创建线程有两种方式
创建线程的第一种方式：继承Thread类
步骤：

谢谢，看来系我没认真听啊、、:handshake

月光海 发表于 2014-4-19 10:55
你没有设置tick不大于0时的条件，在你的程序中就算ticket=0或小于0还是执行while里面的语句，因为while的条 ...

嗯嗯，谢谢

新人发帖，不知道格式，不好意思啊。

package com.isoftstone.interview;

public class Ticket implements Runnable {

        private int ticket = 100;

        public void run() {
                        //线程 RUN 方法，
                while (true) {
                        if (ticket > 1) {
                                System.out.println(Thread.currentThread().getName() + " "
                                                + ticket--);

                        } else {
                                break;   //这里你缺少了 一个判断，
                        }
                }

        }
}




package com.isoftstone.interview;

public class TicketDemo {
        public static void main(String[] args) {
                Ticket t = new Ticket();

                Thread t1 = new Thread(t);// 创建了一个线程;
                Thread t2 = new Thread(t);// 创建了一个线程;
                Thread t3 = new Thread(t);// 创建了一个线程;
                Thread t4 = new Thread(t);// 创建了一个线程;
                // 4个线程一起 调用 ticket类 中，100ticket 参数，
                t1.start();
                t2.start();
                t3.start();
                t4.start();
        }

}

class Ticket implements Runnable
{
         private int tick = 100;
         boolean flag = true;
         public void run()
         {
                 while (flag)
                 {
                         if(tick > 0)
                         {
                                 System.out.println(Thread.currentThread().getName()+"....sale: " + tick--);
                         }
                         else{ flag = false;  }
                 }
         }
}
定一个标志位，控制while循环

你这是死循环呀，
public void run()
        {
                while (true)
                {
                        if(tick > 0)
                        {
                                System.out.println(Thread.currentThread().getName()+"....sale: " + tick--);  //当tick等于0时，if语句不会在运行，而while还是会运行的                                                                                                                                                 //想要结束while循环，有两种方式，一个是return和break。
                        }else {
                                //return;
                               break;
                        }
                }
        }

因为你while循环中设置的是true,所以程序是将一直循环下去。。。所以程序一直运行下去。。。在i

1. 在if{...}后加上
   
2. else
   
3. break;
   
4. 即可。。
   

复制代码

此外，此段代码还需要同步代码块去解决安全问题哦。。。