精华内容
下载资源
问答
  • 初始化:可以指定单个线程池和多个线程池 ScheduledExecutorService executorService= ...(否则scheduleAtFixedRate 按任务开始计时的话会无限的占用更多的线程,不合理)。此时两种执行方式实际效果一样。  
    初始化:可以指定单个线程池和多个线程池
      ScheduledExecutorService executorService= Executors.newSingleThreadScheduledExecutor();
      ScheduledExecutorService executorService= Executors.newScheduledThreadPool(2);

     scheduleWithFixedDelay //按任务结束计时,保证任务间隔

    executorService.scheduleWithFixedDelay(new Runnable() {
                @Override
                public void run() {
                    System.out.println("1 "+simpleDateFormat.format(new Date(System.currentTimeMillis())));
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },0,4, TimeUnit.SECONDS);

     第一次直接开始,每隔6秒执行一次。

     

     scheduleAtFixedRate //按任务开始计时,准时开始,保证频率

    executorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println("2 "+simpleDateFormat.format(new Date(System.currentTimeMillis())));
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },0,4, TimeUnit.SECONDS);

    第一次直接开始,每隔4秒执行一次。

     ***如果任务执行时间大于设置的时间间隔,则会等待任务结束在进行下一次执行。(否则scheduleAtFixedRate 按任务开始计时的话会无限的占用更多的线程,不合理)。此时两种执行方式实际效果一样。

     

    展开全文
  • java定时器线程

    2017-07-16 19:13:38
    TimerTaskTimer这个类是线程安全的:多个线程可以共享一个单一的Timer对象而不需要外部同步。电子时钟简例 import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class T
    • 可以定时执行指定的任务,可以用于做电子时钟,闹钟,窗口的晃动(根据特定的时间段改变窗口对于桌面的位置)

    TimerTask

    Java API中的tTimerTask介绍

    方法

    Timer

    这个类是线程安全的:多个线程可以共享一个单一的Timer对象而不需要外部同步。

    Timer

    构造器

    方法

    电子时钟简例

    
    import java.util.Date;
    import java.util.Timer;
    import java.util.TimerTask;
    
    
    public class TimerDemo{
    
        public static void main(String[] args) {
            Timer timer=new Timer();
            System.out.println("begining");
            timer.schedule(new TimerTask(){
                @Override
                public void run() {
                    System.out.println(new Date().toLocaleString());
                }
            },3000, 1000);
            //3000表示上次任务执行完3秒后执行定时器任务
            //1000表示,每1秒钟执行一次定时器任务
        }
    }   
    

    线程组

    ThreadGroup类,对一组线程统一管理,ThreadGroup中的方法和Thread类中的方法差不多。

    Thread类中也有带有ThreadGroup类对象的构造方法。
    Thread类中构造方法

    展开全文
  • java定时器、多线程(池)、java队列的demodemo,下载看看看吧
  • java定时器和多线程

    千次阅读 2018-10-07 00:05:25
    java定时器和多线程 一、相关知识学习 1、 Java定时器Timer   用于Java线程里指定时间或周期运行任务。Timer是线程安全的,但不提供实时性(real-time)保证。 schdule方法: schedule(TimerTask task, long delay) ...

    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){
                }
            }
            }
    }
    }
    
    运行效果图

    在这里插入图片描述

    展开全文
  • java定时器+多线程(池)+java队列Demo
  • JAVA定时器和多线程

    千次阅读 2018-11-10 16:10:51
    这篇博客介绍java定时器类Timer, 和多线程类Thread. 任务一: 完成一个java application应用程序,使用定时器编程,在实时显示当前时间,每1秒时钟内容更新一次。 主要方法: Modifier ...


    这篇博客介绍java的定时器类Timer, 和多线程类Thread.

    任务一:

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

      主要方法:

    ModifierConstructorDescription
    protectedTimerTask()Creates a new timer task.
    Timer()Creates a new timer.
    MethodDescription
    scheduleAtFixedRate(TimerTask task, long delay, long period)Schedules the specified task for repeated fixed-rate execution,beginning after the specified delay.
    run()The action to be performed by this timer task.

    程序:

    import java.util.Timer;
    import java.util.TimerTask;
    import java.util.Date;
    
    public class JavaTimer {
    	public static void main(String args[]) {
    		TimerTask task = new TimerTask() { //创建一个新的timer task 
    			public void run() { //定时器任务执行的操作
    				Date date = new Date();//创建Date对象
    				String hour = String.format("%tH",date);//格式化输出时间
    				String minute = String.format("%tM",date);
    				String second = String.format("%tS",date);
    				
    				System.out.println("现在是:" + hour + "时" +minute+"分" + second +"秒");
    				
    			}
    		};
    		
    		Timer timer = new Timer();//创建一个定时器
    		long delay = 0;
    		long PeriodTime = 1 * 1000;
    		timer.scheduleAtFixedRate(task, delay, PeriodTime);
    		//重复执行特定任务,第一个参数为要执行的任务,第二个为执行任务之前延迟的时间,第三个为时间间隔
    		//单位都是毫秒
    	}
    }
    

    运行结果:

    在这里插入图片描述

    任务二:

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

    主要方法:

    Modifier and TypeMethodDescription
    static voidsleep(long millis)Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds
    voidstart()Causes this thread to begin execution; the Java Virtual Machine
    calls the run method of this thread.

    程序:

    import java.text.SimpleDateFormat;
    import java.util.Date;
    public class ThreadTest extends Thread {
    	
    	public void run() {
    		while(true) {
    			try {
    				Thread.sleep(1000);//程序眠1秒,括号内参数以毫秒为单位
    				SimpleDateFormat ft = new SimpleDateFormat("yyy-MM-dd hh:mm:ss");//格式化输出时间
    				String time = ft.format(new Date());
    				System.out.println("现在时刻:" + time);//输出时间
    				
    			}
    			catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	public static void main(String[] args) {
    		new ThreadTest().start();//启动线程
    	}
    }
    

    运行结果:

    在这里插入图片描述

    任务三:

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

    主要方法:

    分别开启两个线程

    程序:

    public class ThreDemo {
    	static double x = 0;
    	public static void main(String args[]) {
    		Thread t1 = new Thread(new Thread1());//创建线程
    		Thread t2 = new Thread(new Thread2());
    		
    		t1.start();//开启线程
    		t2.start();
    		
    	}
    	public static class Thread1 extends Thread {
    		public void run() { //run方法,里面包含要执行的任务
    			while(true){
    				try{
    					Thread.sleep(300);//线程休眠300毫秒
    					x +=1.0;
    					System.out.println("x+1: " + x);//输出值
    				}
    				catch(InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    	public static class Thread2 extends Thread {
    		public void run() {
    			while(true){
    				try{
    					Thread.sleep(300);
    					x +=0.1;
    					System.out.println("x+0.1: " + x);
    				}
    				catch(InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }
    

    运行结果:

    在这里插入图片描述

    展开全文
  • java 线程定时器

    2019-04-17 15:29:26
    java 线程定时器
  • java定时器和多线程实践记录

    千次阅读 2015-12-14 17:46:54
    这几天因为需要测试mongodb读写分离的问题,因此写了个定时查询程序,并且用到了多线程,以达到定时启动多个线程查询数据库的效果,下边代码记录备忘: package timmer; import java.util.Timer; import java.util....
  • java中的定时器Timer类位于java.util包下,线程用其安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行。定时器类Timer是线程安全的,多个线程可以共享单个Timer对象而无需进行外部同步,并且该...
  • 线程(死循环)执行后等待 使用计时器控制 5s后唤醒,重复执行 public class Test { public static void main(String[] args) { Lock lock=new Lock();//创建锁对象 //实现runnable接口,实现runnable方法 ...
  • 定时器线程

    2014-02-23 21:44:45
    定时器线程 有时候需要每隔一段时间去执行某个任务。Java 中有两个特殊的类,用来实现定时任务调度: java.util.Timer 和 java.util.TimerTask。 Timer 类是 Java 中一种线程设施,用于安排以后在后台线程中执行...
  • 1、当启动web时就开启线程。 在web.xml里添加: <!-- 线程:完整包名+类名 --> <listener> <listener-class>com.irs.util.protocol.TimerUtilPolice&...
  • 主要介绍了Java线程定时器Timer原理及实现,涉及Timer的schedule的使用,定时器Timer的schedule等相关内容以及代码示例,具有一定参考价值,需要的朋友可以了解下。
  • Java 线程定时器

    2019-08-29 00:15:52
    Java 线程定时器 定时器是一个应用比较广泛的线程工具,可以用来调度多个定时任务,以后台的方式执行。可以通过Timer和TimerTask来实现功能。 Timer是一个普通的类,其中有几个重要的方法;而TimerTask则是一个抽象...
  • Java定时器

    2018-12-24 22:05:10
    在Java多线程中,有的时候,我们需要按照指定间隔时间来执行一些任务,这时,我们就要用到定时器。我们在这里以Java中的Timer定时器为例,演示定时器的应用。... * Java定时器 */ public class Test { ...
  • Java守护线程定时器

    2021-03-16 17:38:02
    Java语言中线程分为两大类: 一类是:用户线程 一类是:守护线程(后台线程) 其中具有代表性的就是:垃圾回收线程(守护线程)、主线程main(用户线程) 守护线程的特点: 一般守护线程是一个死循环,所有的用户...
  • 完成一个java application应用程序,在应用程序主进程中新开一个线程,此线程进行死循环,每1秒被激活一次,激活时即在输出显示当前时间。 2.思路分析 任务1主要是使用定时器类实现。首先需要创建定时器对象,然后...
  • java线程定时器学习

    热门讨论 2012-01-11 18:54:39
    java线程定时器学习,代码和文档都有,很详细
  • Java线程定时器任务

    2018-10-17 17:16:28
    Java定时器任务---基于多线程实现的。 import com.carapi.services.inspect.InspectService; import com.util.timer.TImer; import org.apache.log4j.Logger; import org.springframework.beans....
  • 当前java程序中能够实现定时的主要有三种方式,分别是:java定时器,spring定时器,quartz定时器。 下面依次讲讲他们的应用! java定时器的应用 其实java很早就有解决定时器任务的方法了,java提供了类java.util....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,063
精华内容 12,825
关键字:

java定时器线程

java 订阅