java定时器类Timer和多线程介绍及实例

向右看齐 2022-05-11 14:38 205阅读 0赞

### 任务要求： ###

*  完成一个java application应用程序，使用定时器编程，在实时显示当前时间，每1秒时钟内容更新一次。
 *  完成一个java application应用程序，在应用程序主进程中新开一个线程，此线程进行死循环，每1秒被激活一次，激活时即在输出显示当前时间。
 *  完成一个java application应用程序，此应用程序公共类有一个double型类属性（变量）x，初始值为0；在应用程序主进程中新开两个线程，这两个线程都进行死循环；第1个线程每隔300ms激活一次，令类属性x自加1.0并输出显示；第2个线程每隔400ms激活一次，令类属性x自加0.1并输出显示。

# 一、定时器类Timer #

### （一）介绍 ###

**Time类**主要负责完成定时计划任务的功能,就是在指定的时间的开始执行某个任务.

**Timer类**的作用是设置计划任务,而封装任务内容的类是TimerTask类.此类是一个抽象类,继承需要实现一个run方法.

**Timer构造函数：**

![img][]

**Timer的方法：**

![img][img 1]

### （二）实例：使用定时器编程，在实时显示当前时间，每1秒时钟内容更新一次。 ###

**任务步骤：**

1.创建一个Timer对象;

2.创建MyTask类继承自TimerTask，在MyTask类中定义run方法，具体任务的实现写在run方法中;

3.通过Timer提供的schedule()方法实现定时.

**代码如下：**

import java.util.Timer;
    import java.util.TimerTask;
    import java.util.Date;
    import java.text.SimpleDateFormat;
    
    class MyTask extends TimerTask
    { 
    	@Override//验证@Override下面的方法名是否是父类中所有的，如果没有则报错
        public void run() //run方法
    	{        
    		Date date =new Date();//初始化date对象
    		SimpleDateFormat ft=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//日期格式化
    		System.out.println("当前时间:"+ft.format(date));	
        }
    }
    class TimerDemo 
    { 
        public static void main(String[] args) 
    	{        
            Timer t=new Timer();//创建定时器Timer对象
    		MyTask task=new MyTask();//创建MyTask类
    		t.scheduleAtFixedRate(task,0, 1000); //间隔1秒的速率执行MyTask类中的run方法
        }
    }

**结果如下：**  
![在这里插入图片描述][70]

#### 注： ####

**SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行 。**

`SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");`

这一行代码确立了转换的格式，其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是时、分、秒。（有的格式大写，有的格式小写，例如 MM 是月份，mm 是分；HH 是 24 小时制，而 hh 是 12 小时制。）

# 二.多线程 #

### （一）介绍 ###

#### 什么是线程? ####

> 在同一个进程中可以执行多个任务,每一个任务可以看做一个线程.

> 线程是程序的执行单元,执行路径,使程序使用cpu的最基本单位
> 
> 一个进程如果只有一条执行路径,那么就是单线程的
> 
> 一个进程如果有多个执行路径,那么就是多线程的

#### 多线程的意义: ####

> 多进程的存在是为了提高CPU的利用率,多线程的存在,不是为了提高程序的执行速度,而是为了提高应用程序的使用率.
> 
> 程序的执行其实都是在抢CPU的资源,即CPU的执行权.
> 
> 多个进程在抢这个资源,而其中一个进程如果有多个执行路径,即多个线程,那么就有更高的几率抢到CPU的执行权

#### 创建一个线程 ####

Java 提供了三种创建线程的方法：

*  通过实现 Runnable 接口；
 *  通过继承 Thread 类本身；
 *  通过 Callable 和 Future 创建线程。

### （二）实例1：在应用程序主进程中新开一个线程，此线程进行死循环，每1秒被激活一次，激活时即在输出显示当前时间。 ###

**任务步骤:**

1.创建一个ThreadDate类继承于父类Thread

2.在ThreadDate类类中定义run方法，具体任务的实现写在run方法中（Thread.sleep(1000);//休眠时间为一秒，线程每隔一秒激活一次）;

3.开启线程 t.start();

**代码如下：**

import java.util.Date;
    import java.text.SimpleDateFormat;
    class ThreadDate extends Thread//ThreadDate类继承于父类Thread
    { 
    	public void run()//run方法，包含所需执行的任务
    	{ 
    		while(true)//死循环
    		{ 		
    			try
    			{ 
    				
    				Thread.sleep(1000);//线程每隔一秒激活一次
    				SimpleDateFormat ft=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//日期格式化
    				System.out.println("时间："+ft.format(new Date()));//输出当前时间
    			}
    			catch (InterruptedException e)
    			{ 
    			}
    		}
    	}
    }
    class ThDemo 
    { 
        public static void main(String[] args) 
    	{        
            ThreadDate t = new ThreadDate();//创建一个ThreadDate类
    		t.start();//开启线程
        }
    }

**结果如下：**  
![在这里插入图片描述][70 1]

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

**任务步骤:**

1.公共类定义double型属性x（static double x=0;//定义静态变量）,创建两个线程（通过Runnable接口来创建），；  
2.在线程1和线程2中定义各自的run方法；  
3.开启两个线程

**代码如下：**

class ThDemo1 
    { 
    	static double x=0;//公共类double属性的变量x，赋值0
    	public static void main(String[] args) 
    	{        
    		ThreadDemo1 th1=new ThreadDemo1();//创建线程1
    		ThreadDemo2 th2=new ThreadDemo2();
    		Thread t1 = new Thread(th1);//创建Thread类
    		Thread t2 = new Thread(th2);
    		
    		t1.start();//开启线程1
    		t2.start();//开启线程2
    
        }
    	public static class ThreadDemo1 implements Runnable//线程1
    	{ 
    		public void run()//run方法，包含所需执行的任务
    		{ 
    			while(true)//死循环
    			{ 		
    				try
    				{ 
    				
    					Thread.sleep(3000);//线程每隔三秒激活一次
    					x+=1;//x1=x1+1
    					System.out.println("x1："+x);//输出x1
    				}
    				catch (InterruptedException e){ }
    			}
    		}
    	}
    	public static class ThreadDemo2 implements Runnable//线程2
    	{ 
    		public void run()//run方法，包含所需执行的任务
    		{ 	
    			while(true)//死循环
    			{ 		
    				try
    				{ 		
    					Thread.sleep(4000);//线程每隔四秒激活一次
    					x+=0.1;//x2=x2+1
    					System.out.println("x2："+x);//输出x2
    				}
    				catch (InterruptedException e){ }				
    			}
    		}
    	}
    }

**结果如下：**  
![在这里插入图片描述][70 2]

[img]: /images/20220505/eacbee36677c4d6ca718a0c25966ce46.png
[img 1]: /images/20220505/addb2f3ca6be4dbfbaada44ff4e3aa88.png
[70]: /images/20220505/6ac4123ea2c04fa9b05d884b6447249d.png
[70 1]: /images/20220505/d9e0ea6cd19d42b8a6d9cbca790bf372.png
[70 2]: /images/20220505/761e09b7cb9543ee90a2b4a9895cd8c3.png