java定时器和多线程

java定时器和多线程

一、相关知识学习

1、 Java定时器Timer

  用于Java线程里指定时间或周期运行任务。Timer是线程安全的，但不提供实时性(real-time)保证。
schdule方法:

• schedule(TimerTask task, long delay)
  以当前时间为基准，延迟指定的毫秒后执行一次TimerTask任务。
• schedule(TimerTask task, Date time)
  在指定的日期执行一次TimerTask任务。
  如果日期time早于当前时间，则立刻执行。
• schedule(TimerTask task, long delay, long period)
  以当前时间为基准，延迟指定的毫秒后，再按指定的时间间隔地无限次数的执行TimerTask任务。
• schedule(TimerTask task, Date firstTime, long period)
  在指定的日期之后，按指定的时间间隔地无限次数的执行TimerTask任务。

scheduleAtFixedRate方法:

• scheduleAtFixedRate(TimerTask task, long delay, long period)
  以当前时间为基准，延迟指定的毫秒后，再按指定的时间间隔周期性地无限次数的执行TimerTask任务。
  如果日期firstTime早于当前时间，则立刻执行，且不执行在时间差内的任务。
• scheduleAtFixedRate(TimerTask task, Date firstTime, long period)
  在指定的日期之后，按指定的时间间隔周期性地无限次数的执行TimerTask任务。
  如果日期firstTime早于当前时间，则立即执行，并补充性的执行在时间差内的任务。

2、 Java多线程学习

  在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。
java多线程之继承Thread类创建线程类的步骤如下：

• 1.创建Thread类的子类，并重写run()方法。
• 2.创建Thread子类的实例即线程对象3.调用线程对象的start()方法
• 3.调用线程对象的start()方法

Thread类有以下常用构造方法：

• 1.Thread()
• 2.Thread(String name)
• 3.Thread(Runnable r)
• 4.Thread(Runnable r,String name)

使用Thread类创建线程类，多个线程之间无法共享线程类的实例变量。

实现Runnable接口比继承Thread类所具有的优势：

• 1.适合多个相同的程序代码的线程去处理同一个资源
• 2.可以避免java中的单继承的限制
• 3.增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
• 4.线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

二、训练

1、完成一个java application应用程序，使用定时器编程，在实时显示当前时间，每1秒时钟内容更新一次。

java程序（test1.java）

import java.util.*;//导入java.util包下的所有类

public class test1 {
    private static Timer timer = new Timer();//创建一个Timer类的实例
    public static class MyTask extends TimerTask {//创建一个MyTask类继承于父类TimerTask
        @Override
        public void run() {
            System.out.println("Now Time: " + new Date().toString());//输出当前时间信息
        }
    }
    public static void main(String[] args) {
        MyTask task = new MyTask();
        timer.schedule(task, 0, 1000);//以当前基准时间延迟0秒后执行一次，以后按指定间隔时间1秒无限次数的执行。
    }
}

运行效果图

2、完成一个java application应用程序，在应用程序主进程中新开一个线程，此线程进行死循环，每1秒被激活一次，激活时即在输出显示当前时间。

java程序（test2.java）

import java.util.*;//导入java.util包下的所有类

public class test2 {
    public static void main(String[] args) {
    	FirstThread a=new FirstThread();//创建一个FirstThread类对象
        a.start();//开启线程
    }
}
class FirstThread extends Thread{//创建Thread子类
    public void run(){
            try{//异常处理
               while (true){//定义死循环
                Thread.sleep(1000);//线程每隔1秒激活一次
                System.out.println("Now Time: " + new Date().toString());//输出当前时间信息
               }
            }
            catch(InterruptedException e){
            }
    }
}

运行效果图

3、完成一个java application应用程序，此应用程序公共类有一个double型类属性（变量）x，初始值为0；在应用程序主进程中新开两个线程，这两个线程都进行死循环；第1个线程每隔300ms激活一次，令类属性x自加1.0并输出显示；第2个线程每隔400ms激活一次，令类属性x自加0.1并输出显示。

java程序（test3.java）

public class test3{
   static double x=0; //定义一个double型变量并赋值
   public static void main(String[] args){
       new Thread(new OneThread()).start();//开启线程
       new Thread(new TwoThread()).start();//开启线程
       }
public static class OneThread implements Runnable{//通过实现Runnable接口来创建线程类
    public void run(){
    	while (true){//定义死循环
            try{//异常处理
                Thread.sleep(300);//线程每隔300ms激活一次
                x=x+1;
                System.out.println("one:"+x);//输出x
            }
            catch(InterruptedException e){
            }
        }
        }
    }
public static class TwoThread implements Runnable{//通过实现Runnable接口来创建线程类
    public void run(){
    	while (true){//定义死循环
            try{//异常处理
                Thread.sleep(400);//线程每隔400ms激活一次
                x=x+0.1;
                System.out.println("two:"+x);//输出x
            }
            catch(InterruptedException e){
            }
        }
        }
}
}

运行效果图