通过Handler与线程嵌套TimerTask实现循环交替任务

创建两个循环交替任务：10秒后，A任务执行。 A任务里面创建一个B任务200毫秒后执行，B任务里面又创建一个A任务10秒后执行，如此往复。

1，首先采用Handler与线程的sleep(long)方法；

Handler主要用来处理接受到的消息。这只是最主要的方法，当然Handler里还有其他的方法供实现，有兴趣的可以去查API，这里不过多解释。

1. 定义一个Handler类，用于处理接受到的Message。

  1. Handler handler = new Handler() {
  2. public void handleMessage(Message msg) {
  3. // 要做的事情
  4. super.handleMessage(msg);
  5. }
  6. };

2. 新建一个实现Runnable接口的线程类，如下：

  1. public class MyThread implements Runnable {
  2. @Override
  3. public void run() {
  4. // TODO Auto-generated method stub
  5. while (true) {
  6. try {
  7. Thread.sleep(10000);// 线程暂停10秒，单位毫秒
  8. Message message = new Message();
  9. message.what = 1;
  10. handler.sendMessage(message);// 发送消息
  11. } catch (InterruptedException e) {
  12. // TODO Auto-generated catch block
  13. e.printStackTrace();
  14. }
  15. }
  16. }
  17. }

3. 在需要启动线程的地方加入下面语句：

new Thread(new MyThread()).start();

4.测试类

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;  

/**
 * @author Administrator
 */
public class TraditionalTime2 {  

    /*
     * 创建两个循环交替任务：10秒后，A任务执行。
     * A任务里面创建一个B任务200毫秒后执行，B任务里面又创建一个A任务10秒后执行，如此往复。
     *
     */
    public static void main(String[] args) {
        TraditionalTime2 t2=new TraditionalTime2();
        new Timer().schedule(t2.new A(), 10000);  

         //用于打印时间秒数
        while (true) {
            System.out.println(new Date().getSeconds());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    class A extends TimerTask {
        @Override
        public void run() {
            System.out.println("A bombing!");
            new Timer().schedule(new B(), 200);  

        }  

    }  

    class B extends TimerTask {
        @Override
        public void run() {
            System.out.println("B bombing!");
            new Timer().schedule(new A(), 10000);  

        }
    }
}

完整代码：

	/**
	 * 每隔10s发一次整包查询请求，10秒后，A（发送整个包查询）任务执行。
	 * A（发送整包查询）任务里面创建一个B（发送查询一个ID包）任务200毫秒后执行
	 */
	// 查询数据
	Handler handler = new Handler() {
		public void handleMessage(Message msg) {
			// 要做的事情发送查询请求
			System.out.println("每隔10s发一次查询包请求");
			/**
			 * 枚举类型的遍历
			 * 间隔200ms，发下一个包;
			 */
			PackageId[] allPackageId = PackageId.values();
			for (PackageId aPackageId : allPackageId) {
//				System.out.println("200ms发一次查询id!");
				System.out.println(" 当前名字： " + aPackageId.name());
				System.out.println(" 当前序号： " + aPackageId.ordinal());
				// System. out .println( " 当前： " + aPackageId);
				byte[] data = { 0x01 };
				PumpPackage myPackage = new PumpPackage(aPackageId, data);
				util.writePort(myPackage.getSendArray());
				// new Thread(new QueryThread()).start();
				new Timer().schedule(new QueryPackageId(), 5000);//QueryPackageId 200毫秒后执行
			}

			super.handleMessage(msg);
		}
	};

	public class QueryThread implements Runnable {
		@Override
		public void run() {
			while (true) {
				try {
					Thread.sleep(10000);// 线程暂停10秒，单位毫秒
					Message message = new Message();
					message.what = 1;
					handler.sendMessage(message);// 发送消息
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 间隔200毫秒发一个包id查询请求
	 * @author sooner
	 *
	 */
	class QueryPackageId extends TimerTask {
		@Override
		public void run() {
			System.out.println("200ms发一次查询id!");
		}
	}

@Override

public void didPackageReceived(blePort port, byte[] Received) {

// 接收到数组 解码为包

PumpPackage package1 = new PumpPackage(Received);

// 返回数据有问题

if (package1.isValid()) {

mReceivedData = package1.toString();

mReceivedId = package1.getPackageId();

// mReceivedValue =package1.getDataArray().toString();

// 包中需要的数据部分

try {

mReceivedValue = PumpPackage.bytesToInt(package1

.getDataArray());

} catch (Exception e) {

e.printStackTrace();

}

System.out.println(mReceivedData);

System.out.println(mReceivedId);

System.out.println(mReceivedValue);

//

cs = String.valueOf(mReceivedValue);

System.out.println(cs);

// 接收到数据后更新UI状态

PumpFragmentConnect.updateUiObjectState();

PumpFragmentConnect.runRow();

PumpFragmentConnect.updateUiObject((String) cs);

}

runOnUiThread(new Runnable() {

@Override

public void run() {

PumpFragmentConnect.updateUiObject((String) cs);

// mLastSecondTotalReceiveSize = mTotalReceiveSize;

}

});

}

调试记录：

07-24 17:49:50.169: I/System.out(5251):  当前名字： UMToSlave_QuerySeq

07-24 17:49:50.169: I/System.out(5251):  当前序号： 15

07-24 17:49:50.179: D/ACSUtilityService(5251): There are 1 datas to be sended...

07-24 17:49:50.179: D/ACSUtilityService(5251): sending data...count0

07-24 17:49:50.179: D/ACSUtilityService(5251): writePort 1

07-24 17:49:50.179: D/ACSUtilityService(5251): writePort 2

07-24 17:49:50.179: D/ACSUtilityService(5251): writePort 3

07-24 17:49:50.179: D/ACSUtilityService(5251): writePort 4

07-24 17:49:50.179: D/ACSUtilityService(5251): data: [[email protected]

07-24 17:49:50.179: D/BluetoothGatt(5251): writeCharacteristic() - uuid: 0000ffb2-0000-1000-8000-00805f9b34fb

07-24 17:49:50.189: D/BluetoothGatt(5251): onCharacteristicWrite() - Device=B4:99:4C:6E:33:1B UUID=0000ffb2-0000-1000-8000-00805f9b34fb Status=0

07-24 17:49:50.189: D/ACSUtilityService(5251): onCharacteristicWrite

07-24 17:49:50.189: D/ACSUtilityService(5251): notify workerThread

07-24 17:49:50.189: D/ACSUtilityService(5251): synchronized...

07-24 17:49:50.189: D/ACSUtilityService(5251): send succeed

07-24 17:49:50.189: E/ACSUtility(5251): EventHandler got a message.flag is 8

07-24 17:49:52.649: D/BluetoothGatt(5251): onNotify() - Device=B4:99:4C:6E:33:1B UUID=0000ffb2-0000-1000-8000-00805f9b34fb

07-24 17:49:52.649: D/ACSUtilityService(5251): onCharacteristicChanged

07-24 17:49:52.649: D/ACSUtilityService(5251): data line : length = 10

07-24 17:49:52.659: E/ACSUtility(5251): EventHandler got a message.flag is 5

07-24 17:49:52.659: W/System.err(5251): java.lang.ArrayIndexOutOfBoundsException: length=1; index=1

07-24 17:49:52.659: W/System.err(5251): at com.brio.bluetooth.PumpPackage.bytesToInt(PumpPackage.java:234)

07-24 17:49:52.659: W/System.err(5251): at com.brio.activity.StartActivity$1.didPackageReceived(StartActivity.java:186)

07-24 17:49:52.659: W/System.err(5251): at com.brio.util.ACSUtility$2.handleMessage(ACSUtility.java:136)

07-24 17:49:52.659: W/System.err(5251): at android.os.Handler.dispatchMessage(Handler.java:102)

07-24 17:49:52.659: W/System.err(5251): at android.os.Looper.loop(Looper.java:136)

07-24 17:49:52.659: W/System.err(5251): at android.app.ActivityThread.main(ActivityThread.java:5050)

07-24 17:49:52.659: W/System.err(5251): at java.lang.reflect.Method.invokeNative(Native Method)

07-24 17:49:52.659: W/System.err(5251): at java.lang.reflect.Method.invoke(Method.java:515)

07-24 17:49:52.659: W/System.err(5251): at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:793)

07-24 17:49:52.659: W/System.err(5251): at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:609)

07-24 17:49:52.659: W/System.err(5251): at dalvik.system.NativeStart.main(Native Method)

07-24 17:49:52.659: I/System.out(5251): id:  UpperMoni_CmdInValid  length: 1  data: [-86, -69, 2, 0, 1, 102, -60, -12, -26, -73]

07-24 17:49:52.659: I/System.out(5251): UpperMoni_CmdInValid

07-24 17:49:52.659: I/System.out(5251): 0

07-24 17:49:52.659: I/System.out(5251): 0

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-10-19 17:32:05

通过Handler与线程嵌套TimerTask实现循环交替任务的相关文章

Android 使用handler实现线程间发送消息 （主线程 与 子线程之间）、（子线程 与 子线程之间）

keyword:Android 使用handler实现线程间发送消息 (主线程 与 子线程之间).(子线程 与 子线程之间) 相信大家平时都有使用到异步线程往主线程(UI线程)发送消息的情况. 本文主要研究Handler的消息发送. 包含主线程往子线程发送消息,子线程之间互相发送消息. 一.主线程向子线程发送消息. 实现过程比較简单: 主线程发送消息到异步线程.异步线程接收到消息后在再发送一条消息给主线程. 1. 初始化主线程的Handler,用来接收子线程的消息. 2. 启动异步线程.在异步线

Handler+ExecutorService(线程池)+MessageQueue模式+缓存模式

android线程池的理解,晚上在家无事 预习了一下android异步加载的例子,也学习到了一个很重要的东东 那就是线程池+缓存  下面看他们的理解. [size=1.8em]Handler+Runnable模式 我们先看一个并不是异步线程加载的例子,使用 Handler+Runnable模式. 这里为何不是新开线程的原因请参看这篇文章:Android Runnable 运行在那个线程 这里的代码其实是在UI 主线程中下载图片的,而不是新开线程. 我们运行下面代码时,会发现他其实是阻塞了整个界面

TMsgThread, TCommThread -- 在delphi线程中实现消息循环（105篇博客，好多研究消息的文章）

在delphi线程中实现消息循环 在delphi线程中实现消息循环 Delphi的TThread类使用很方便,但是有时候我们需要在线程类中使用消息循环,delphi没有提供. 花了两天的事件研究了一下win32的消息系统,写了一个线程内消息循环的测试. 但是没有具体应用过,贴出来给有这方面需求的DFW参考一下.希望大家和我讨论. {----------------------------------------------------------------------------- Unit

Chromium线程模型、消息循环

多线程的麻烦 多线程编程是一件麻烦的事,相信很多人深有体会.执行顺序的不确定性,资源的并发访问一直困扰着众多程序员.解决多线程编程问题的方法分为两类:一是对并发访问的资源直接加锁:二是避免并发访问资源:Chromium采用第二种思想来设计多线程模型,通过在线程之间传递消息来实现跨进程通讯. 设计原则 Chromium希望尽量保持UI处于响应状态.为此遵循如下设计原则: 1 不在UI线程上执行任何阻塞I/O操作,以及其它耗时操作. 2 少用锁和线程安全对象 3 避免阻塞I/O线程 4 线程之间不要

Handler与线程通信(二)

1. 准备Looper对象 2. 在WorkerThread当中生成Handler对象 3. 在MainThread当中发送消息 这个过程与上一篇相反 由MainThread里面的Handler发送消息, WorkerThread里面的HandlerMessage来处理 Handler与线程通信(二)

【转】Handler+ExecutorService(线程池)+MessageQueue模式+缓存模式

http://www.cnblogs.com/wanqieddy/archive/2013/09/06/3305482.html android线程池的理解,晚上在家无事 预习了一下android异步加载的例子,也学习到了一个很重要的东东 那就是线程池+缓存  下面看他们的理解. [size=1.8em]Handler+Runnable模式 我们先看一个并不是异步线程加载的例子,使用 Handler+Runnable模式. 这里为何不是新开线程的原因请参看这篇文章:Android Runnabl

面试题，子线程10次子线程2执行20次与主线程100次来回循环执行50次

// 面试题,子线程2执行10次子线程2执行20次 与主线程100次来回循环执行50次 public class interview { public static void main(String[] args) { final Business b = new Business(); new Thread(new Runnable(){ @Override public void run() { for (int i = 1; i <= 50; i++) { b.sub2(i); } } }

在delphi线程中实现消息循环

http://delphi.cjcsoft.net//viewthread.php?tid=635 在delphi线程中实现消息循环 Delphi的TThread类使用很方便,但是有时候我们需要在线程类中使用消息循环,delphi没有提供. 花了两天的事件研究了一下win32的消息系统,写了一个线程内消息循环的测试. 但是没有具体应用过,贴出来给有这方面需求的DFW参考一下.希望大家和我讨论. {--------------------------------------------------

多线程 创建子父线程 保证一件事 子线程执行三次后 父线程执行5次 循环10次

package Thread; /** * 创建子父线程 保证一件事 子线程执行三次后 父线程执行5次 循环10次 * 父线程main线程则为Console台项目的主线程 * 在main线程中调用了start线程则为子线程 * */ public class FatherAndSonTest { public static void main(String[] args) { final FatherAndSon fs = new FatherAndSon(); new Thread(new R