Observable.interval定时执行

Observable.interval方法可以定时执行自定义的逻辑,常用方法如下:
 

/**
 * 定时执行
 *
 * @param period 每次执行的间隔的时间
 * @param unit 时间单位
 * @return Observable对象
 */
public static Observable<Long> interval(long period, TimeUnit unit)

/**
 * 定时执行
 *
 * @param initialDelay 第一次执行的延迟时间
 * @param period 每次执行的间隔的时间
 * @param unit 时间单位
 * @return Observable对象
 */
public static Observable<Long> interval(long initialDelay, long period, TimeUnit unit)

举例如下:

import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;

private Disposable disposable;

/**
 * 开始定时执行
 */
private void startTimer() {
    stopTimer();
    // 每隔500毫秒执行一次逻辑代码
    disposable = Observable.interval(500, TimeUnit.MILLISECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(@io.reactivex.annotations.NonNull Long aLong) throws Exception {
                    // 逻辑代码
                }
            }, new Consumer<Throwable>() {
                @Override
                public void accept(@io.reactivex.annotations.NonNull Throwable throwable) throws Exception {
                    throwable.printStackTrace();
                }
            });
}

/**
 * 停止定时执行
 */
protected void stopTimer() {
    if (null != disposable) {
        disposable.dispose();
        disposable = null;
    }
}

 

在多线程环境下执行定时任务时,需要注意避免数据竞争和并发问题,因为定时器可能会与其他线程同时访问共享资源。以下是几种常见的处理策略: 1. **使用锁**:如果你的任务涉及到对共享数据的操作,可以使用锁定机制(如Monitor、Mutex或Semaphore)保证数据一致性。例如,使用`lock`关键字: ```csharp lock (_syncLock) { // _syncLock是一个互斥锁实例 // 执行定时任务相关的代码 } ``` 2. **使用ConcurrentDictionary或ConcurrentQueue**:这些内置的数据结构可以帮助你在多线程环境中安全地存储和访问数据。 3. **使用Task或ThreadPool**:可以创建一个新的Task,在该任务内部执行定时任务,利用Task的异步特性和并发池: ```csharp Task.Run(() => { var timer = new Timer(5000); timer.Elapsed += (sender, args) => ExecuteTask(); // 异步方法 timer.AutoReset = true; timer.Start(); }); private async void ExecuteTask() { // 在这里执行耗时任务 } ``` 4. **使用线程局部存储(ThreadLocal)**:如果任务不需要共享状态,可以考虑使用ThreadLocal变量,每个线程都有独立的副本。 5. **使用专门的并发库**:比如Reactive Extensions(Rx.NET),它的`Observable.Interval`方法可以方便地创建定时任务,而且天生就支持并行和错误处理。 在选择方法时,要考虑任务的具体需求、性能开销以及可能出现的问题。记得测试在高并发情况下的表现,确保稳定性和正确性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值