"多线程"学过编程的都知道，但我现在才算真的明白他是用来干什么的。就像是完成某一目的，把它分成不同方向，同时运行实施，最后由主方向完成结束。这样就达到高效率低消耗的目的了。　　每一秒显示一次系统时间，这一项目很容易但是很容易造成死循环而跳不出程序从而结束了，我们就可以利用多线程来轻而易举的实现：

　　import java.util.*;;public class ClockThreadTest {
/**
* @param args
*/
        public static void main(String[] args){
                ClockThread clockThread = new ClockThread();
                clockThread.start();
                System.out.println("end");
                }
        }
class ClockThread extends Thread {
        @Override
        public void run(){
                //super.run();
                while (true) {
                        System.out.println(new Date());
                        try {
                                Thread.sleep(1000);
                                }
                        catch (InterruptedException e){
                                        e.printStackTrace();
                        }
                }
        }
}
看出线程的具体体现了吗，每一秒显示系统时间就是多线程，而end则是在主线程里。这样就不会出现死循环的问题了。

准确来说，cpu是单核的时候，线程并不是同时运行，而是cpu在不停的切换，切换速度很快，让你感觉像是同时运行，这叫做并行性。而多核的Cpu是可以同时运行多个线程的。在上述程序的复写的run方法中，super.run（）有什么作用

end和线程没有关系吧，如果不手动停止线程，线程会一直执行，并且end可以被先执行，因为end和线程类的start属于不同的线程，是多线程同步

希望有助于进一步理解线程

1. import java.io.BufferedReader;
   
2. import java.io.IOException;
   
3. import java.io.InputStreamReader;
   
4. import java.util.Date;
   
5. 
   
6. public class Demo02 {
   
7.        
   
8.         public static void main(String[] args) throws Exception {
   
9.                
   
10.                 final ClockThread clockThread = new ClockThread();
    
11.                 clockThread.start();       
    
12.                
    
13.                 Thread t = new Thread(new Runnable(){
    
14.                         public void run() {       
    
15.                                 BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    
16.                                 String line;
    
17.                                 try {
    
18.                                         while(!"exit".equals(line = reader.readLine()))
    
19.                                         {
    
20.                                                 System.out.println(line);
    
21.                                         }
    
22.                                         clockThread.b = false;        //当在控制台输入exit时，clockThread线程终止循环
    
23.                                 } catch (IOException e) {
    
24.                                         e.printStackTrace();
    
25.                                 }
    
26.                         }
    
27.                        
    
28.                 });
    
29.                 t.start();
    
30.         }       
    
31. }
    
32. 
    
33. class ClockThread extends Thread {
    
34.         boolean b = true;
    
35.         public void run() {
    
36.                 super.run();
    
37.                 while (b){
    
38.                         System.out.println(new Date());
    
39.                         try {
    
40.                                 Thread.sleep(1000);
    
41.                         } catch (InterruptedException e) {
    
42.                                 e.printStackTrace();
    
43.                         }   
    
44.                 }
    
45.         }
    
46. }
    

复制代码

熊冠银 发表于 2013-3-10 08:01
准确来说，cpu是单核的时候，线程并不是同时运行，而是cpu在不停的切换，切换速度很快，让你感觉像是同时运 ...

我想原作者的意图是为了让父类Thread先进行初始化动作才写super.run()的，我测试了一下，他的代码是有问题的，改了改，已经更正了，注释这句话，也能运行，似乎是没区别

王亚东 发表于 2013-3-10 08:21
希望有助于进一步理解线程

写的不错，这个只是个测试测试程序。原作者不是为了让程序停下来，而是在测试多线程不会造成出现某些死循环的优点。就像生活中，钟表一个小时响一次，是不需要停下来的。