黑马程序员技术交流社区

标题: 多线程实例——每一秒显示一次系统时间【非原创】 [打印本页]
作者: 黄玉昆    时间: 2013-3-10 07:33
标题: 多线程实例——每一秒显示一次系统时间【非原创】
本帖最后由 黄玉昆 于 2013-3-10 08:57 编辑

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

　　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则是在主线程里。这样就不会出现死循环的问题了。

作者: 熊冠银    时间: 2013-3-10 08:01
准确来说，cpu是单核的时候，线程并不是同时运行，而是cpu在不停的切换，切换速度很快，让你感觉像是同时运行，这叫做并行性。而多核的Cpu是可以同时运行多个线程的。在上述程序的复写的run方法中，super.run（）有什么作用
作者: 王亚东    时间: 2013-3-10 08:04
end和线程没有关系吧，如果不手动停止线程，线程会一直执行，并且end可以被先执行，因为end和线程类的start属于不同的线程，是多线程同步
作者: 王亚东    时间: 2013-3-10 08:21
希望有助于进一步理解线程
  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.util.Date;

  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. }

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

我想原作者的意图是为了让父类Thread先进行初始化动作才写super.run()的，我测试了一下，他的代码是有问题的，改了改，已经更正了，注释这句话，也能运行，似乎是没区别
作者: 黄玉昆    时间: 2013-3-10 09:02
王亚东 发表于 2013-3-10 08:21
希望有助于进一步理解线程

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



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2