开开向前冲
开开向前冲

AlarmManager详解

版权说明：本文为 开开向前冲 原创文章，转载请注明出处；
注：限于作者水平有限，文中有不对的地方还请指教

项目需求：AP需要在开机24小时后自检重启；
针对上述需求，我们首先想想有哪些实现方法呢？

  • 1：开机接收广播，启动一个常驻服务，在服务中轮训。轮训的方式可以通过Handler或者启动一个常驻服务，在服务中开启线程中做死循环；
  • 2：使用Timer 来定时操作；
  • 3：使用AlarmManager 来实现定时操作功能；

上述三个方法看似都可行；实际上只有最后一种可行，前两种都是不可行的，为什么不可行呢？
一：服务轮训：Handler发送消息，消息的发送依赖于Handler 线程，如果线程结束，GG！那开启一个常驻服务呢，在服务中开启一个线程做死循环，我们先不说省电问题，如果系统进入深度睡眠，即使这个while（1）的循环也不能得到执行；
二：Timer：Timer的问题也是在于如果系统进入深度睡眠，将无法唤醒；

所以只有AlarmManager。可以通过AlarmManager定时唤醒系统执行任务，即使系统处于深度睡眠也能唤醒——这就和我们的闹钟差不多；也能省电；那使用AlarmManager如果做呢？

代码敬上：

AlarmManager aManager = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
        Intent in = new Intent();
        in.setClass(context, RebootService.class);
        PendingIntent pi = PendingIntent.getService(context, 0, in, 0);
        aManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,24 * 60 * 60 * 1000, pi);

没错，AlarmManager的使用就是这个简单，在开机后24小时系统将会启动RebootService，RebootService是我自己实现的一个服务，在这个服务中任意Lifecycle中实现关机操作就OK；

            PowerManager pm = (PowerManager)this.getSystemService(Context.POWER_SERVICE);
            pm.reboot("self-inspection");

AlarmManager不仅可以唤醒服务，也可以发送广播，也可以调起Activity；需要将上述PendingIntent.getService()修改成对应的PendingIntent.getActivity()或者PendingIntent.getBroadcast()方法；

因为之前有维护过原生Clock APP，对AlarmManager有了解，正好借此机会完整机会阐述一下AlarmManager；

AlarmManager 对象获取：

 AlarmManager aManager = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);

AlarmManager 常用接口：

AlarmManager详解_第1张图片
AlarmManager.png
  • set(int type, long triggerAtMillis, PendingIntent operation)
    一次性任务；
  • setRepeating(int type, long triggerAtMillis, long intervalMillis, PendingIntent operation)
    重复任务；时间固定；
  • setInexactRepeating(int type, long triggerAtMillis, long intervalMillis, PendingIntent operation)
    重复任务，时间不固定；
  • cancel(PendingIntent operation)
    取消上述设置的定时任务；此时PendingIntent务必和需要取消的任务的PendingIntent一模一样；

这里主要介绍了几个常用于定时任务的接口；关于AlarmManager 的接口和用法，
可以参考Google官方API文档AlarmManager 文档；

接口参数详解：

  • int type
AlarmManager.RTC:硬件时间，不唤醒休眠设备；当休眠时不发起闹钟。
AlarmManager.RTC_WAKEUP:硬件时间，当闹钟发射时唤醒休眠设备；
AlarmManager.ELAPSED_REALTIME:真实时间流逝，不唤醒休眠设备；当设备休眠时不发起闹钟。
AlarmManager.ELAPSED_REALTIME_WAKEUP:真实时间流逝，当闹钟发起时唤醒手机休眠；

    RTC闹钟和ELAPSED_REALTIME 最大的差别就是前者可以通过修改手机时间触发闹钟事件，
后者要通过真实时间的流逝，即使在休眠状态，时间也会被计算。
  • long triggerAtMillis : 闹钟第一次执行时间，毫秒为单位，需与第一个type参数匹配，
    1. 如果是RTC类型，triggerAtMillis 则一般使用System.currentTimeMillis()；
    2. 如果是ELAPSED类型，triggerAtMillis 则一般使用SystemClock.elapsedRealtime();
  • long intervalMillis : 两次闹钟执行间隔
  • PendingIntent operation : 任务的执行动作，发送广播，启动activity，启动service

上述大概讲了AlarmManager接口如何使用，作为一名System Engineer，我们还需要研究研究真实的服务提供者AlarmManagerService：

从上述名字中我们知道AlarmManager 只是AlarmManagerService的代理，实际实现都是在AlarmManagerService中实现的；

AlarmManagerService启动

frameworks\base\services\java\com\android\server\SystemServer.java
private void startOtherServices() {
      ...
            mAlarmManagerService = mSystemServiceManager.startService(AlarmManagerService.class);
    //mSystemServiceManager 即是SystemServiceManger
            alarm = IAlarmManager.Stub.asInterface(
                    ServiceManager.getService(Context.ALARM_SERVICE));
      ...
}

frameworks\base\services\core\java\com\android\server\SystemServiceManager.java
public  T startService(Class serviceClass) {
...
            Constructor constructor = serviceClass.getConstructor(Context.class);
            service = constructor.newInstance(mContext);
...
            mServices.add(service);
            service.onStart(); //service 即是AlarmManagerService
}

frameworks\base\services\core\java\com\android\server\AlarmManagerService.java
@Override
    public void onStart() {
        mNativeData = init();//init方法是native 方法，调用JNI
        mNextWakeup = mNextNonWakeup = 0;

        // We have to set current TimeZone info to kernel
        // because kernel doesn't keep this after reboot
        setTimeZoneImpl(SystemProperties.get(TIMEZONE_PROPERTY));

        PowerManager pm = (PowerManager) getContext().getSystemService(Context.POWER_SERVICE);
        mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "*alarm*");

        mTimeTickSender = PendingIntent.getBroadcastAsUser(getContext(), 0,
                new Intent(Intent.ACTION_TIME_TICK).addFlags(
                        Intent.FLAG_RECEIVER_REGISTERED_ONLY
                        | Intent.FLAG_RECEIVER_FOREGROUND), 0,
                        UserHandle.ALL);
        Intent intent = new Intent(Intent.ACTION_DATE_CHANGED);
        intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
        mDateChangeSender = PendingIntent.getBroadcastAsUser(getContext(), 0, intent,
                Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT, UserHandle.ALL);
        
        // now that we have initied the driver schedule the alarm
        mClockReceiver = new ClockReceiver();
        mClockReceiver.scheduleTimeTickEvent();
        mClockReceiver.scheduleDateChangedEvent();
        mInteractiveStateReceiver = new InteractiveStateReceiver();
        mUninstallReceiver = new UninstallReceiver();
        /*
        上述代码注册了各种监听器，监听各种和时间变化相关的事务
        */
        if (mNativeData != 0) {
            AlarmThread waitThread = new AlarmThread(); //创建AlarmThread
            waitThread.start();
        } else {
            Slog.w(TAG, "Failed to open alarm driver. Falling back to a handler.");
        }

        publishBinderService(Context.ALARM_SERVICE, mService); //注册服务，调用ServiceManager.addService添加服务；
    }

最后的publishBinderService即调用ServiceManager.addService注册服务，服务

AlarmManagerService的onStart方法工作

  1. 由于重启内核没有时区信息，需要将时区信息保存到内核；
  2. 创建ClockReceiver用于监听TIME_TICK和DATE_CHANGED广播；
  3. 创建InteractiveStateReceiver，用于监听亮屏/灭屏广播；
  4. 创建UninstallReceiver，用于监听package移除/重启，sdcard不可用的广播；
  5. 创建线程”AlarmManager”；
  6. 注册服务。

AlarmManagerService中的native JNI方法：

    private native long init();
    private native void close(long nativeData);
    private native void set(long nativeData, int type, long seconds, long nanoseconds);
    private native void clear(long nativeData, int type, long seconds, long nanoseconds);
    private native int waitForAlarm(long nativeData);
    private native int setKernelTime(long nativeData, long millis);
    private native int setKernelTimezone(long nativeData, int minuteswest);

我们根据Android JNI 文件命名规范(报名中"."替换为"_")知道对应的JNI文件名为com_android_server_AlarmManagerService.cpp

static JNINativeMethod sMethods[] = {
     /* name, signature, funcPtr */
    {"init", "()J", (void*)android_server_AlarmManagerService_init},
    {"close", "(J)V", (void*)android_server_AlarmManagerService_close},
    {"set", "(JIJJ)V", (void*)android_server_AlarmManagerService_set},
    {"clear", "(JIJJ)V", (void*)android_server_AlarmManagerService_clear},
    {"waitForAlarm", "(J)I", (void*)android_server_AlarmManagerService_waitForAlarm},
    {"setKernelTime", "(JJ)I", (void*)android_server_AlarmManagerService_setKernelTime},
    {"setKernelTimezone", "(JI)I", (void*)android_server_AlarmManagerService_setKernelTimezone},
};

上述说道在AlarmManagerService.java中onStart方法中有调用native JNI init()方法；

static jlong android_server_AlarmManagerService_init(JNIEnv*, jobject)
{
    jlong ret = init_alarm_driver(); //初始化alarm driver
    if (ret) {
        return ret;
    }
    return init_timerfd(); //初始化文件描述符
}

static jlong init_alarm_driver()
{
    int fd = open("/dev/alarm", O_RDWR); //打开节点/dev/alarm，并创建Alarm驱动对象。
    if (fd < 0) {
        ALOGV("opening alarm driver failed: %s", strerror(errno));
        return 0;
    }
    AlarmImpl *ret = new AlarmImplAlarmDriver(fd);//创建AlarmImplAlarmDriver对象
    return reinterpret_cast(ret);
}

static jlong init_timerfd()
{
    int epollfd;
    int fds[N_ANDROID_TIMERFDS];
     ......
    epollfd = epoll_create(N_ANDROID_TIMERFDS);
    for (size_t i = 0; i < N_ANDROID_TIMERFDS; i++) {
        fds[i] = timerfd_create(android_alarm_to_clockid[i], 0);
       ......
    }
    AlarmImpl *ret = new AlarmImplTimerFd(fds, epollfd);//创建AlarmImplTimerFd对象

    for (size_t i = 0; i < N_ANDROID_TIMERFDS; i++) {
        epoll_event event;
        event.events = EPOLLIN | EPOLLWAKEUP;
        event.data.u32 = i;

        int err = epoll_ctl(epollfd, EPOLL_CTL_ADD, fds[i], &event);
        if (err < 0) {
            ALOGV("epoll_ctl(EPOLL_CTL_ADD) failed: %s", strerror(errno));
            delete ret;
            return 0;
        }
    }

    struct itimerspec spec;
    memset(&spec, 0, sizeof(spec));
    /* 0 = disarmed; the timerfd doesn't need to be armed to get
       RTC change notifications, just set up as cancelable */

    int err = timerfd_settime(fds[ANDROID_ALARM_TYPE_COUNT],
            TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET, &spec, NULL);
    if (err < 0) {
        ALOGV("timerfd_settime() failed: %s", strerror(errno));
        delete ret;
        return 0;
    }

    return reinterpret_cast(ret);
}
//android_alarm_to_clockid 数组的定义
android_alarm_to_clockid[N_ANDROID_TIMERFDS] = {
    CLOCK_REALTIME_ALARM,
    CLOCK_REALTIME,
    CLOCK_BOOTTIME_ALARM,
    CLOCK_BOOTTIME,
    CLOCK_MONOTONIC,
    CLOCK_REALTIME,
};

AlarmThread

private class AlarmThread extends Thread
    {
        public AlarmThread()
        {
            super("AlarmManager");
        }
        
        public void run()
        {
            ArrayList triggerList = new ArrayList();

            while (true) //无线循环
            {
                int result = waitForAlarm(mNativeData); //JNI 方法，使用EPOLL监听FD，等待驱动返回执行下面的分发执行；

                triggerList.clear();

                if ((result & TIME_CHANGED_MASK) != 0) {
                    if (DEBUG_BATCH) {
                        Slog.v(TAG, "Time changed notification from kernel; rebatching");
                    }
                    removeImpl(mTimeTickSender);
                    rebatchAllAlarms();
                    mClockReceiver.scheduleTimeTickEvent();
                    synchronized (mLock) {
                        mNumTimeChanged++;
                    }
                    Intent intent = new Intent(Intent.ACTION_TIME_CHANGED);
                    intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING
                            | Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT
                            | Intent.FLAG_RECEIVER_FOREGROUND);
                    getContext().sendBroadcastAsUser(intent, UserHandle.ALL);
                }
                
                synchronized (mLock) {
                    final long nowRTC = System.currentTimeMillis();
                    final long nowELAPSED = SystemClock.elapsedRealtime();
                    if (localLOGV) Slog.v(
                        TAG, "Checking for alarms... rtc=" + nowRTC
                        + ", elapsed=" + nowELAPSED);

                    if (WAKEUP_STATS) {
                        if ((result & IS_WAKEUP_MASK) != 0) {
                            long newEarliest = nowRTC - RECENT_WAKEUP_PERIOD;
                            int n = 0;
                            for (WakeupEvent event : mRecentWakeups) {
                                if (event.when > newEarliest) break;
                                n++; // number of now-stale entries at the list head
                            }
                            for (int i = 0; i < n; i++) {
                                mRecentWakeups.remove();
                            }

                            recordWakeupAlarms(mAlarmBatches, nowELAPSED, nowRTC);
                        }
                    }

                    boolean hasWakeup = triggerAlarmsLocked(triggerList, nowELAPSED, nowRTC);

                    if (SystemProperties.getInt("sys.quickboot.enable", 0) == 1) {
                        filtQuickBootAlarms(triggerList);
                    }

                    if (!hasWakeup && checkAllowNonWakeupDelayLocked(nowELAPSED)) {
                        // if there are no wakeup alarms and the screen is off, we can
                        // delay what we have so far until the future.
                        if (mPendingNonWakeupAlarms.size() == 0) {
                            mStartCurrentDelayTime = nowELAPSED;
                            mNextNonWakeupDeliveryTime = nowELAPSED
                                    + ((currentNonWakeupFuzzLocked(nowELAPSED)*3)/2);
                        }
                        mPendingNonWakeupAlarms.addAll(triggerList);
                        mNumDelayedAlarms += triggerList.size();
                        rescheduleKernelAlarmsLocked();
                        updateNextAlarmClockLocked();
                    } else {
                        // now deliver the alarm intents; if there are pending non-wakeup
                        // alarms, we need to merge them in to the list.  note we don't
                        // just deliver them first because we generally want non-wakeup
                        // alarms delivered after wakeup alarms.
                        rescheduleKernelAlarmsLocked();
                        updateNextAlarmClockLocked();
                        if (mPendingNonWakeupAlarms.size() > 0) {
                            calculateDeliveryPriorities(mPendingNonWakeupAlarms);
                            triggerList.addAll(mPendingNonWakeupAlarms);
                            Collections.sort(triggerList, mAlarmDispatchComparator);
                            final long thisDelayTime = nowELAPSED - mStartCurrentDelayTime;
                            mTotalDelayTime += thisDelayTime;
                            if (mMaxDelayTime < thisDelayTime) {
                                mMaxDelayTime = thisDelayTime;
                            }
                            mPendingNonWakeupAlarms.clear();
                        }
                        deliverAlarmsLocked(triggerList, nowELAPSED); //alarm 事件分发
                    }
                }
            }
        }
    }
waitForAlarm是一个native方法具体的实现在驱动中。如果整个系统中没有alarm的时间回调，
waitForAlarm则阻塞在这，直到有回调的时候才往后执行，这样会减少CPU的开销。

com_android_server_AlarmManagerService.cpp waitForAlarm()

int AlarmImplTimerFd::waitForAlarm()
{
    epoll_event events[N_ANDROID_TIMERFDS];

    int nevents = epoll_wait(epollfd, events, N_ANDROID_TIMERFDS, -1);//监听事件
    if (nevents < 0) {
        return nevents;
    }

    int result = 0;
    for (int i = 0; i < nevents; i++) {
        uint32_t alarm_idx = events[i].data.u32;
        uint64_t unused;
        ssize_t err = read(fds[alarm_idx], &unused, sizeof(unused));
        if (err < 0) {
            if (alarm_idx == ANDROID_ALARM_TYPE_COUNT && errno == ECANCELED) {
                result |= ANDROID_ALARM_TIME_CHANGE_MASK;
            } else {
                return err;
            }
        } else {
            result |= (1 << alarm_idx);
        }
    }

    return result;
}
deliverAlarmsLocked() —— AlarmThread事件中分发Alarm事件
void deliverAlarmsLocked(ArrayList triggerList, long nowELAPSED) {
        mLastAlarmDeliveryTime = nowELAPSED;
        for (int i=0; i 0) {
                        for (int wi=0; wi 0) {
                    // This IntentSender is no longer valid, but this
                    // is a repeating alarm, so toss the hoser.
                    removeImpl(alarm.operation);
                }
            } catch (RuntimeException e) {
                Slog.w(TAG, "Failure sending alarm.", e);
            }
        }
    }

PendingIntent.java

public void send(Context context, int code, @Nullable Intent intent,
        @Nullable OnFinished onFinished, @Nullable Handler handler,
        @Nullable String requiredPermission, @Nullable Bundle options)
        throws CanceledException {
    try {
        String resolvedType = intent != null ?
                intent.resolveTypeIfNeeded(context.getContentResolver())
                : null;
        int res = mTarget.send(code, intent, resolvedType, //////////mTarget 是PendingIntentRecord
                onFinished != null
                        ? new FinishedDispatcher(this, onFinished, handler)
                        : null,
                requiredPermission, options);
        ...
    } catch (RemoteException e) {
        throw new CanceledException(e);
    }
}

mTarget 是什么呢？？？
我们前面讲述AlarmManger使用时讲述会通过PendingIntent.getActivity或者getService吧；
PendingIntent 常用的几个静态方法：

PendingIntent.getActivity
PendingIntent.getService
PendingIntent.getBroadcast
PendingIntent.getBroadcastAsUser

mTarget就是在上述方法中创建PendingIntent时创建的。上述几个方法最终都会调用ActivityManagerService的getIntentSender方法

public static PendingIntent getService(Context context, int requestCode,
        Intent intent,  int flags) {
   String packageName = context.getPackageName();
   String resolvedType = intent != null ? intent.resolveTypeIfNeeded(
           context.getContentResolver()) : null;
   try {
       intent.prepareToLeaveProcess();
       IIntentSender target =
           ActivityManagerNative.getDefault().getIntentSender( // ActivityManagerNative.getDefault()获取的是
//AMS的代理ActivityMangerProxy，binder call 调用AMS的相关方法
               ActivityManager.INTENT_SENDER_SERVICE, packageName,
               null, null, requestCode, new Intent[] { intent },
               resolvedType != null ? new String[] { resolvedType } : null,
               flags, null, UserHandle.myUserId());
       return target != null ? new PendingIntent(target) : null;
   } catch (RemoteException e) {
   }
   return null;
}

ActivityMangerService.java的 getIntentSender()获取的是PendingIntentRecord对象, 而该对象继承于IIntentSender.Stub， 经过binder call回来, 所以此处target是指PendingIntentRecord对象的代理端, 即为PendingIntent.mTarget，所以上述最终会调用PendingIntentRecord的send方法；具体的唤起Activity,Service等具体业务就是在这个send 方法中完成；

下面完整看一下AlarmManager 的set接口操作过程；

AlarmManager.java

    public void set(int type, long triggerAtMillis, PendingIntent operation) {
        setImpl(type, triggerAtMillis, legacyExactLength(), 0, operation, null, null);
    }

    private void setImpl(int type, long triggerAtMillis, long windowMillis, long intervalMillis,
            PendingIntent operation, WorkSource workSource, AlarmClockInfo alarmClock) {
        if (triggerAtMillis < 0) {
            /* NOTYET
            if (mAlwaysExact) {
                // Fatal error for KLP+ apps to use negative trigger times
                throw new IllegalArgumentException("Invalid alarm trigger time "
                        + triggerAtMillis);
            }
            */
            triggerAtMillis = 0;
        }

        try {
            mService.set(type, triggerAtMillis, windowMillis, intervalMillis, operation,
                    workSource, alarmClock); //这里的mService就是前面的AlarmManagerService中的mService对象。
        } catch (RemoteException ex) {
        }
    }
    //AlarmManager 类的构造函数
    AlarmManager(IAlarmManager service, Context ctx) {
        mService = service;

        final int sdkVersion = ctx.getApplicationInfo().targetSdkVersion;
        mAlwaysExact = (sdkVersion < Build.VERSION_CODES.KITKAT);
    }

ContextImpl.java
AlarmManager对象的获取：(AlarmManager)context.getSystemService(Context.ALARM_SERVICE);

    @Override
    public Object getSystemService(String name) {
        ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name);
        return fetcher == null ? null : fetcher.getService(this);
    }   

 private static void registerService(String serviceName, ServiceFetcher fetcher) {
        if (!(fetcher instanceof StaticServiceFetcher)) {
            fetcher.mContextCacheIndex = sNextPerContextServiceCacheIndex++;
        }
        SYSTEM_SERVICE_MAP.put(serviceName, fetcher); //添加service到SYSTEM_SERVICE_MAP
    }

 registerService(ALARM_SERVICE, new ServiceFetcher() { //注册
                  public Object createService(ContextImpl ctx) {
                      IBinder b = ServiceManager.getService(ALARM_SERVICE);
                      IAlarmManager service = IAlarmManager.Stub.asInterface(b);
                      return new AlarmManager(service, ctx);
                }});   


    /*package*/ static class ServiceFetcher {
        int mContextCacheIndex = -1;

        /**
         * Main entrypoint; only override if you don't need caching.
         */
        public Object getService(ContextImpl ctx) {
            ArrayList cache = ctx.mServiceCache;
            Object service;
            synchronized (cache) {
                if (cache.size() == 0) {
                    // Initialize the cache vector on first access.
                    // At this point sNextPerContextServiceCacheIndex
                    // is the number of potential services that are
                    // cached per-Context.
                    for (int i = 0; i < sNextPerContextServiceCacheIndex; i++) {
                        cache.add(null);
                    }
                } else {
                    service = cache.get(mContextCacheIndex);
                    if (service != null) {
                        return service;
                    }
                }
                service = createService(ctx);
                cache.set(mContextCacheIndex, service);
                return service;
            }
        }

        /**
         * Override this to create a new per-Context instance of the
         * service.  getService() will handle locking and caching.
         */
        public Object createService(ContextImpl ctx) {
            throw new RuntimeException("Not implemented");
        }
    }
        
 
 
所以getSystemService中返回的就是AlarmManagerService 中mService 的代理；即AlarmManager中mService变量即是AlarmManagerService中mService的代理；AlarmManager中方法最终都是有AlarmManagerService的mService处理
 
 
关于上述AlarmManager中set方法的处理，调用
 
 
    mService.set(type, triggerAtMillis, windowMillis, intervalMillis, operation,
                    workSource, alarmClock); //这里的mService就是前面的AlarmManagerService中的mService对象。

 
 
Binder Call 到AlarmMangerService中
 本段代码是截取Android 5.1源码；
 
 
        @Override
        public void set(int type, long triggerAtTime, long windowLength, long interval,
                PendingIntent operation, WorkSource workSource,
                AlarmManager.AlarmClockInfo alarmClock) {
            if (workSource != null) {
                getContext().enforceCallingPermission(
                        android.Manifest.permission.UPDATE_DEVICE_STATS,
                        "AlarmManager.set");
            }

            setImpl(type, triggerAtTime, windowLength, interval, operation,
                    windowLength == AlarmManager.WINDOW_EXACT, workSource, alarmClock);
        }


void setImpl(int type, long triggerAtTime, long windowLength, long interval,
            PendingIntent operation, boolean isStandalone, WorkSource workSource,
            AlarmManager.AlarmClockInfo alarmClock) {
        if (operation == null) {
            Slog.w(TAG, "set/setRepeating ignored because there is no intent");
            return;
        }

        // Sanity check the window length.  This will catch people mistakenly
        // trying to pass an end-of-window timestamp rather than a duration.
        if (windowLength > AlarmManager.INTERVAL_HALF_DAY) {
            Slog.w(TAG, "Window length " + windowLength
                    + "ms suspiciously long; limiting to 1 hour");
            windowLength = AlarmManager.INTERVAL_HOUR;
        }

        // Sanity check the recurrence interval.  This will catch people who supply
        // seconds when the API expects milliseconds.
        if (interval > 0 && interval < MIN_INTERVAL) {
            Slog.w(TAG, "Suspiciously short interval " + interval
                    + " millis; expanding to " + (int)(MIN_INTERVAL/1000)
                    + " seconds");
            interval = MIN_INTERVAL;
        }

        if (type < RTC_WAKEUP || type > RTC_POWEROFF_WAKEUP) {
            throw new IllegalArgumentException("Invalid alarm type " + type);
        }

        if (triggerAtTime < 0) {
            final long who = Binder.getCallingUid();
            final long what = Binder.getCallingPid();
            Slog.w(TAG, "Invalid alarm trigger time! " + triggerAtTime + " from uid=" + who
                    + " pid=" + what);
            triggerAtTime = 0;
        }

        final long nowElapsed = SystemClock.elapsedRealtime();
        final long nominalTrigger = convertToElapsed(triggerAtTime, type);
        // Try to prevent spamming by making sure we aren't firing alarms in the immediate future
        final long minTrigger = nowElapsed + MIN_FUTURITY;
        final long triggerElapsed = (nominalTrigger > minTrigger) ? nominalTrigger : minTrigger;

        final long maxElapsed;
        if (windowLength == AlarmManager.WINDOW_EXACT) {
            maxElapsed = triggerElapsed;
        } else if (windowLength < 0) {
            maxElapsed = maxTriggerTime(nowElapsed, triggerElapsed, interval);
        } else {
            maxElapsed = triggerElapsed + windowLength;
        }

        final int userId = UserHandle.getCallingUserId();

        synchronized (mLock) {
            if (DEBUG_BATCH) {
                Slog.v(TAG, "set(" + operation + ") : type=" + type
                        + " triggerAtTime=" + triggerAtTime + " win=" + windowLength
                        + " tElapsed=" + triggerElapsed + " maxElapsed=" + maxElapsed
                        + " interval=" + interval + " standalone=" + isStandalone);
            }
            setImplLocked(type, triggerAtTime, triggerElapsed, windowLength, maxElapsed,
                    interval, operation, isStandalone, true, workSource, alarmClock, userId);
        }
    }

private void setImplLocked(int type, long when, long whenElapsed, long windowLength,
            long maxWhen, long interval, PendingIntent operation, boolean isStandalone,
            boolean doValidate, WorkSource workSource, AlarmManager.AlarmClockInfo alarmClock,
            int userId) {
        Alarm a = new Alarm(type, when, whenElapsed, windowLength, maxWhen, interval,
                operation, workSource, alarmClock, userId);
        removeLocked(operation);

        int whichBatch = (isStandalone) ? -1 : attemptCoalesceLocked(whenElapsed, maxWhen);
        if (whichBatch < 0) {
            Batch batch = new Batch(a);
            batch.standalone = isStandalone;
            addBatchLocked(mAlarmBatches, batch);
        } else {
            Batch batch = mAlarmBatches.get(whichBatch);
            if (batch.add(a)) {
                // The start time of this batch advanced, so batch ordering may
                // have just been broken.  Move it to where it now belongs.
                mAlarmBatches.remove(whichBatch);
                addBatchLocked(mAlarmBatches, batch);
            }
        }

        if (alarmClock != null) {
            mNextAlarmClockMayChange = true;
            updateNextAlarmClockLocked();
        }

        if (DEBUG_VALIDATE) {
            if (doValidate && !validateConsistencyLocked()) {
                Slog.v(TAG, "Tipping-point operation: type=" + type + " when=" + when
                        + " when(hex)=" + Long.toHexString(when)
                        + " whenElapsed=" + whenElapsed + " maxWhen=" + maxWhen
                        + " interval=" + interval + " op=" + operation
                        + " standalone=" + isStandalone);
                rebatchAllAlarmsLocked(false);
            }
        }

        rescheduleKernelAlarmsLocked();
    }

void rescheduleKernelAlarmsLocked() {
        // Schedule the next upcoming wakeup alarm.  If there is a deliverable batch
        // prior to that which contains no wakeups, we schedule that as well.
        long nextNonWakeup = 0;
        if (mAlarmBatches.size() > 0) {
            final Batch firstWakeup = findFirstWakeupBatchLocked();
            final Batch firstBatch = mAlarmBatches.get(0);
            final Batch firstRtcWakeup = findFirstRtcWakeupBatchLocked();

            // always update the kernel alarms, as a backstop against missed wakeups
            if (firstWakeup != null && mNextWakeup != firstWakeup.start) {
                mNextWakeup = firstWakeup.start;
                setLocked(ELAPSED_REALTIME_WAKEUP, firstWakeup.start);//调用方法
            }
            if (firstRtcWakeup != null && mNextRtcWakeup != firstRtcWakeup.start) {
                mNextRtcWakeup = firstRtcWakeup.start;
                long when = firstRtcWakeup.getWhenByElapsedTime(mNextRtcWakeup);

                if (when != 0) {
                    setLocked(RTC_POWEROFF_WAKEUP, when);
                }
            }
            if (firstBatch != firstWakeup) {
                nextNonWakeup = firstBatch.start;
            }
        }
        if (mPendingNonWakeupAlarms.size() > 0) {
            if (nextNonWakeup == 0 || mNextNonWakeupDeliveryTime < nextNonWakeup) {
                nextNonWakeup = mNextNonWakeupDeliveryTime;
            }
        }
        // always update the kernel alarm, as a backstop against missed wakeups
        if (nextNonWakeup != 0) {
            mNextNonWakeup = nextNonWakeup;
            setLocked(ELAPSED_REALTIME, nextNonWakeup); //
        }
    }

private void setLocked(int type, long when) {
        if (mNativeData != 0) {
            // The kernel never triggers alarms with negative wakeup times
            // so we ensure they are positive.
            long alarmSeconds, alarmNanoseconds;
            if (when < 0) {
                alarmSeconds = 0;
                alarmNanoseconds = 0;
            } else {
                alarmSeconds = when / 1000;
                alarmNanoseconds = (when % 1000) * 1000 * 1000;
            }
            
            set(mNativeData, type, alarmSeconds, alarmNanoseconds); //native  JNI call，调用JN native 方法
        } else {
            Message msg = Message.obtain();
            msg.what = ALARM_EVENT;
            
            mHandler.removeMessages(ALARM_EVENT);
            mHandler.sendMessageAtTime(msg, when);
        }
    }

 
 
 
  
com_android_server_AlarmManagerService.cpp
 
 
 
 
static void android_server_AlarmManagerService_set(JNIEnv*, jobject, jlong nativeData, jint type,
 jlong seconds, jlong nanoseconds)
{
    AlarmImpl *impl = reinterpret_cast(nativeData); //从java传递的nativeData，
    //AlarmMangerService中的nativeData 实际是该JNI init() 的返回值；此时返回的是AlarmImplAlarmDriver
    struct timespec ts;
    ts.tv_sec = seconds;
    ts.tv_nsec = nanoseconds;

    int result = impl->set(type, &ts);//AlarmImplAlarmDriver->set
    if (result < 0)
    {
        ALOGE("Unable to set alarm to %lld.%09lld: %s\n",
              static_cast(seconds),
              static_cast(nanoseconds), strerror(errno));
    }
}

static jlong android_server_AlarmManagerService_init(JNIEnv*, jobject)
{
    jlong ret = init_alarm_driver();//即操作Alarm device——"/dev/alarm"
    if (ret) {
        return ret; 
    }

    return init_timerfd();//如果没有Alarm device，继续执行
}

int AlarmImplAlarmDriver::set(int type, struct timespec *ts)
{
    return ioctl(fds[0], ANDROID_ALARM_SET(type), ts);// 最终ioctl操作硬件
}

 
 
 
  
最终通过ioctl的方式将时间设置给驱动，后续驱动不做详解，我也不清楚，
 目的就是把时间设置给驱动，等到硬件中断返回后，再回调到native层，native再回调到framework，
 如何回调到framework的呢？？
 我们上述说的AlarmThread，在run()方法中开启一个无限循环，循环中会调用
 
 
 
 
int result = waitForAlarm(mNativeData); //JNI 方法，使用EPOLL监听FD，阻塞等待驱动返回执行下面的分发执行；

 
 
waitForAlarm是一个native方法，具体的实现在驱动中。如果整个系统中没有alarm的时间回调，waitForAlarm则阻塞在这，直到有回调的时候才往后执行，才会继续执行上述的deliverAlarmsLocked()方法，才会去执行相应的send方法唤醒activity等。
 
 
 
  
一个完整的过程就是操作"/dev/alarm"设备的过程。自此一个完整的操作过程就结束了；
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(AlarmManager详解)

        

            

                
    
                    
  • Python中os.environ基本介绍及使用方法
                        鹤冲天Pro
#Pythonpython服务器开发语言
                        
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                    
  • [Python] 数据结构 详解及代码
                        AIAdvocate
算法python数据结构链表
                        
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
    
                    
    • 
                    
  • 详解：如何设计出健壮的秒杀系统？
                        夜空_2cd3

                        
    作者：Yrion博客园：cnblogs.com/wyq178/p/11261711.html前言：秒杀系统相信很多人见过，比如京东或者淘宝的秒杀，小米手机的秒杀。那么秒杀系统的后台是如何实现的呢？我们如何设计一个秒杀系统呢？对于秒杀系统应该考虑哪些问题？如何设计出健壮的秒杀系统？本期我们就来探讨一下这个问题：image目录一：****秒杀系统应该考虑的问题二：****秒杀系统的设计和技术方案三：*
    
                    
    • 
                    
  • MyBatis 详解
                        阿贾克斯的黎明
javamybatis
                        
    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
    
                    
    • 
                    
  • vue render 函数详解 (配参数详解)
                        你的眼睛會笑
vue2vue.jsjavascript前端
                        
    vuerender函数详解(配参数详解)在Vue3中，`render`函数被用来代替Vue2中的模板语法。它接收一个h函数（或者是`createElement`函数的别名），并且返回一个虚拟DOM。render函数的语法结构如下：render(h){returnh('div',{class:'container'},'Hello,World!')}在上面的示例中，我们使用h函数创建了一个div元素
    
                    
    • 
                    
  • Dockerfile命令详解之 FROM
                        清风怎不知意
容器化java前端javascript
                        
    许多同学不知道Dockerfile应该如何写，不清楚Dockerfile中的指令分别有什么意义，能达到什么样的目的，接下来我将在容器化专栏中详细的为大家解释每一个指令的含义以及用法。专栏订阅传送门https://blog.csdn.net/qq_38220908/category_11989778.html指令不区分大小写。但是，按照惯例，它们应该是大写的，以便更容易地将它们与参数区分开来。(引用
    
                    
    • 
                    
  • Dockerfile（1） - FROM 指令详解
                        小菠萝测试笔记
dockerpythonjavacmd大数据
                        
    FROM指明当前的镜像基于哪个镜像构建dockerfile必须以FROM开头，除了ARG命令可以在FROM前面FROM[--platform=][AS]FROM[--platform=][:][AS]FROM[--platform=][@][AS]小栗子FROMalpine:latest一个dockerfile可以有多个FROM可以有多个FROM来创建多个镜像，或区分构建阶段，将一个构建阶段作为另
    
                    
    • 
                    
  • 详解“c:/work/src/components/a/b.vue“‘ has no default export报错原因
                        hw_happy
开发语言前端vue.jsjavascript
                        
    前情提要在一个vue文件中需要引入定义的b.vue文件，但是提示b文件没有默认导出，对于vue2文件来说有exportdefault，在中，所有定义的变量、函数和组件都会自动被视为默认导出的组件内容。因此，不需要显式地使用exportdefault来导出组件。但是在我引用这个文件的时候还是提示了这个错误，原来是我的项目使用了ts和vite\webpack，因为TypeScript和Vue的默认导出
    
                    
    • 
                    
  • 【显示 后台运行 & 的命令】
                        晨春计
debuglinux服务器运维
                        
    目录背景步骤详解示例背景当你在Linuxshell中使用&符号将一个命令放到后台运行时，你可以使用jobs命令来查看这些后台进程的状态。但是，jobs命令并不会直接显示进程的PID（进程ID）。它会显示一个作业列表，其中包括每个作业的状态和一个作业标识符（通常是百分号%后面跟着一个数字），但不会直接显示PID。获取后台进程的PID步骤：1、使用jobs命令查看后台作业。2、使用ps命令配合grep
    
                    
    • 
                    
  • k8s中Service暴露的种类以及用法
                        听说唐僧不吃肉
K8Skubernetes容器云原生
                        
    一、说明在Kubernetes中，有几种不同的方式可以将服务（Service）暴露给外部流量。这些方式通过定义服务的spec.type字段来确定。二、详解1.ClusterIP定义：默认类型，服务只能在集群内部访问。作用：通过集群内部IP地址暴露服务。示例：spec:type:ClusterIPports:-port:80targetPo
    
                    
    • 
                    
  • 详解mybatis的一二级缓存以及缓存失效原因
                        仰望天花板
缓存数据库mybatisjavamysql
                        
    数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
    
                    
    • 
                    
  • pythonpandas函数详解_Python pandas常用函数详解
                        Senvn

                        
    本文研究的主要是pandas常用函数，具体介绍如下。1import语句importpandasaspdimportnumpyasnpimportmatplotlib.pyplotaspltimportdatetimeimportre2文件读取df=pd.read_csv(path='file.csv')参数：header=None用默认列名，0，1，2，3...names=['A','B','C'
    
                    
    • 
                    
  • HTTP 响应状态码详解
                        云博客-资源宝
笔记httpHTTP响应状态码详解
                        
    HTTP状态码详解：HTTP状态码,是用以表示WEB服务器HTTP响应状态的3位数字代码小技巧：Ctrl+F快速查找Http状态码状态码含义100客户端应当继续发送请求。这个临时响应是用来通知客户端它的部分请求已经被服务器接收，且仍未被拒绝。客户端应当继续发送请求的剩余部分，或者如果请求已经完成，忽略这个响应。服务器必须在请求完成后向客户端发送一个最终响应。101服务器已经理解了客户端的请求，并将
    
                    
    • 
                    
  • Linux中GCC与GDB 常用命令详解
                        Dijkstra's Monk-ey
Linux与安全linuxgdbshell安全c语言
                        
    GCC和GDB常用命令详解GCC常用的选项GDBLINUX下编程，少不了和GCC,GDB打交道，现在总结下常用命令，掌握这些足够用了。GCC常用的选项选项语义-o指定生成的输出文件-E仅执行编译预处理gcc的-E选项，可以让编译器在预处理后停止，并输出预处理结果。-S将C代码转换为汇编代码gcc的-S选项，表示在程序编译期间，在生成汇编代码后停止-wall显示警告信息-c生成目标文件（.o），仅执
    
                    
    • 
                    
  • 腾讯发表多模态综述，一文详解多模态大模型
                        存内计算开发者社区
多模态大模型人工智能chatgptAIGC量子计算AI-nativegptagi
                        
    多模态大语言模型（MLLM）是近年来兴起的一个新的研究热点，它利用强大的大语言模型作为大脑来执行多模态任务。MLLM令人惊讶的新兴能力，如基于图像写故事和无OCR的数学推理，在传统方法中是罕见的，这表明了一条通往人工通用智能的潜在道路。在本文中，追踪多模态大模型最新热点，讨论多模态关键技术以及现有在情绪识别上的应用。腾讯AILab发表了一篇关于多模态大模型的最新综述《MM-LLMs:RecentA
    
                    
    • 
                    
  • OSPF LSA5、LSA7 中 FA 工作原理详解
                        斐夷所非
network网络
                        
    FA(ForwardingAddress)仅出现在LSA5或LSA7中，它是数据包访问外部网络时，在数据报文离开OSPF路由域时必须经过的设备地址。LSA5作用LSA5区别于LSA3/LSA4，LSA5仅负责通告OSPF路由域外其他协议的路由，如RIP、BGP等。当外部路由引入到OSPF后，靠LSA5将其泛洪到OSPF路由域。LSA5具有其他LSA所没有的泛洪范围，除了特殊类型区域(Stub及NS
    
                    
    • 
                    
  • ⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表
                        英雄哪里出来
《LeetCode算法全集》算法数据结构链表c++归并排序
                        
    饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述  将两个不降序链表合并为一个新的不降
    
                    
    • 
                    
  • 上传文件到钉盘流程详解
                        jspyth
开发场景案例分析开发语言java后端
                        
    文章目录前言准备工作实现过程Maven依赖封装一个工具类获取文件上传信息unionId获取钉盘目录spaceId创建上传到钉盘前言  本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。准备工作1、在钉钉开发者后台创建一个钉钉企业内部应用；2、创建并保存好应用的appKey和appSecret，后面用于获取调用API的请求token；3、应用中配置好所需权限：企业存储文件上传
    
                    
    • 
                    
  • Linux中open函数详解
                        460833359
LinuxClinuxopen函数
                        
    初级文件I/O函数（即不用缓存的I/O函数）：open（打开文件）相关函数read，write，fcntl，create，lseek，close，link，stat，umask，unlink，fopen头文件#include#include#include定义函数intopen(constchar*pathname,intflags);intopen(constchar*pathname,intf
    
                    
    • 
                    
  • linux open详解,Linux系统open函数详解
                        墨剑心
linuxopen详解
                        
    Linux系统中open函数主要作用就是打开和创建文件，可以根据参数来定制我们需要的文件的属性和用户权限等各种参数，下面良许教程网为大家分享一下Linux系统open函数具体使用方法。一、open函数用来干什么open函数在Linux下一般用来打开或者创建一个文件，我们可以根据参数来定制我们需要的文件的属性和用户权限等各种参数。二、open函数的定义和参数我们首先来看下open函数在Linux下的
    
                    
    • 
                    
  • Linux下read函数详解
                        威桑
Linuxlinux服务器运维
                        
    在Linux中，read函数是最常用的系统调用之一，用于从文件或其他输入设备读取数据。它是低级别的I/O操作的核心，直接与操作系统的内核交互，提供了高效的数据读取方式。一、read函数简介read函数的声明如下：#includessize_tread(intfd,void*buf,size_tcount);其中：fd是文件描述符，代表了需要读取的文件或设备。文件描述符可以通过调用open或其他文件
    
                    
    • 
                    
  • Python round函数详解
                        寒秋丶
Python自动化测试性能测试python开发语言测试开发软件开发软件测试自动化测试性能测试
                        
    大家好，在Python编程中，经常需要对数字进行舍入操作。无论是在金融领域的货币计算，还是科学计算中的数据处理，都可能需要使用到四舍五入功能。为了满足这一需求，Python提供了一个内置函数round()，它能够方便地对数字进行舍入操作。在本文中，将深入探讨Python中round()函数的用法和特性。将从基本语法开始，逐步深入，讨论该函数在不同情况下的行为，以及如何在实际编程中灵活运用。无论您是
    
                    
    • 
                    
  • Linux下open函数详解
                        威桑
Linuxlinux
                        
    在Linux中，open函数是文件操作的核心系统调用之一，它用于打开文件并返回一个文件描述符，用于后续的文件操作如读取、写入、关闭等。open函数的原型#include#include#include#includeintopen(constchar*pathname,intflags);intopen(constchar*pathname,intflags,mode_tmode);open函数有
    
                    
    • 
                    
  • 打开C语言常用内存函数的大门(一) —— memcpy()函数 （内含讲解用法和模拟实现）
                        埋头编程~
C语言c语言开发语言visualstudio算法
                        
    文章目录1.前言2.memcpy函数2.1memcpy函数的原型2.2memcpy函数的形参和返回值详解3.memcpy函数的演示4.memcpy函数的模拟实现5.总结1.前言在之前写的文章中，我介绍了几个比较常用的字符串函数strlen、strcmp、strcpy。它们作用的对象只能是形如字符串类型的数据。那这难免会引起我们心中一泡浓厚的求知欲——C语言有没有给我们提供一些类似于字符串函数的功能
    
                    
    • 
                    
  • 详解C语言中的循环语句
                        埋头编程~
C语言c语言开发语言
                        
    文章目录1.前言2.while循环2.1if和whlie的对比2.2while语句的工作机制2.3while循环的实践3.for循环3.1for循环语法3.2for循环的工作机制3.3for循环实践4dowhile循环4.1dowhlie循环语法4.2dowhile循环的工作机理4.3dowhile循环实践5.break和continue语句5.1break举例5.2continue举例6.got
    
                    
    • 
                    
  • 4×4矩阵键盘详解（STM32）
                        辰哥单片机设计
STM32传感器教学矩阵计算机外设stm32嵌入式硬件单片机传感器
                        
    目录一、介绍二、传感器原理1.原理图2.工作原理介绍三、程序设计main.c文件button4_4.h文件button4_4.c文件四、实验效果五、资料获取项目分享一、介绍矩阵键盘，又称为行列式键盘，是用4条I/O线作为行线，4条I/O线作为列线组成的键盘。在行线和列线的每一个交叉点上设置一个按键，因此键盘中按键的个数是4×4个。这种行列式键盘结构能够有效地提高单片机系统中I/O口的利用率，节约单
    
                    
    • 
                    
  • STM32的寄存器深度解析
                        千千道
STM32stm32单片机物联网
                        
    目录一、STM32寄存器概述二、寄存器的定义与作用三、寄存器分类1.内核寄存器2.外设寄存器四、重要寄存器详解1.GPIO相关寄存器2.定时器相关寄存器3.中断相关寄存器4.RCC相关寄存器五、寄存器操作方法1.直接操作寄存器2.使用库函数操作寄存器六、总结在嵌入式系统开发中，STM32微控制器以其强大的性能和丰富的功能而备受青睐。而理解和掌握STM32的寄存器是深入学习和开发STM32的关键。本
    
                    
    • 
                    
  • STM32 的 RTC（实时时钟）详解
                        千千道
STM32stm32物联网单片机
                        
    目录一、引言二、RTC概述三、RTC的工作原理1.时钟源2.计数器3.闹钟功能4.备份寄存器四、RTC寄存器1.RTC_TR（TimeRegister，时间寄存器）2.RTC_DR（DateRegister，日期寄存器）3.RTC_SSR（SubsecondRegister，亚秒寄存器）4.RTC_PRER（PrescalerRegister，预分频器寄存器）5.RTC_CR（ControlReg
    
                    
    • 
                                
  • 算法 单链的创建与删除
                                    换个号韩国红果果
c算法
                                    
    
先创建结构体
struct student {
	int data;
	//int tag;//标记这是第几个
	struct student *next;
};
//  addone 用于将一个数插入已从小到大排好序的链中
struct student *addone(struct student *h,int x){
		if(h==NULL)  //??????
			
    
                                
    • 
                                
  • 《大型网站系统与Java中间件实践》第2章读后感
                                    白糖_
java中间件
                                    
           断断续续花了两天时间试读了《大型网站系统与Java中间件实践》的第2章，这章总述了从一个小型单机构建的网站发展到大型网站的演化过程---整个过程会遇到很多困难，但每一个屏障都会有解决方案，最终就是依靠这些个解决方案汇聚到一起组成了一个健壮稳定高效的大型系统。 
  
       看完整章内容，
    
                                
    • 
                                
  • zeus持久层spring事务单元测试
                                    deng520159
javaDAOspringjdbc
                                    
    今天把zeus事务单元测试放出来,让大家指出他的毛病, 
1.ZeusTransactionTest.java 单元测试 
  
package com.dengliang.zeus.webdemo.test;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;
import 
    
                                
    • 
                                
  • Rss 订阅 开发
                                    周凡杨
htmlxml订阅rss规范
                                    
      
              RSS是 Really Simple Syndication的缩写（对rss2.0而言，是这三个词的缩写，对rss1.0而言则是RDF Site Summary的缩写，1.0与2.0走的是两个体系）。 
  
RSS
    
                                
    • 
                                
  • 分页查询实现
                                    g21121
分页查询
                                    
    在查询列表时我们常常会用到分页，分页的好处就是减少数据交换，每次查询一定数量减少数据库压力等等。 
按实现形式分前台分页和服务器分页： 
前台分页就是一次查询出所有记录，在页面中用js进行虚拟分页，这种形式在数据量较小时优势比较明显，一次加载就不必再访问服务器了，但当数据量较大时会对页面造成压力，传输速度也会大幅下降。 
服务器分页就是每次请求相同数量记录，按一定规则排序，每次取一定序号直接的数据
    
                                
    • 
                                
  • spring jms异步消息处理
                                    510888780
jms
                                    
    spring JMS对于异步消息处理基本上只需配置下就能进行高效的处理。其核心就是消息侦听器容器，常用的类就是DefaultMessageListenerContainer。该容器可配置侦听器的并发数量，以及配合MessageListenerAdapter使用消息驱动POJO进行消息处理。且消息驱动POJO是放入TaskExecutor中进行处理，进一步提高性能，减少侦听器的阻塞。具体配置如下： 
    
                                
    • 
                                
  • highCharts柱状图
                                    布衣凌宇
hightCharts柱图
                                    
    第一步：导入 exporting.js,grid.js,highcharts.js;第二步：写controller 
  
@Controller@RequestMapping(value="${adminPath}/statistick")public class StatistickController {  private UserServi
    
                                
    • 
                                
  • 我的spring学习笔记2-IoC（反向控制 依赖注入）
                                    aijuans
springmvcSpring 教程spring3 教程Spring 入门
                                    
    IoC（反向控制 依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 
IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明： 
如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
    
                                
    • 
                                
  • TLS java简单实现
                                    antlove
javasslkeystoretlssecure
                                    
      
1. SSLServer.java 
package ssl;

import java.io.FileInputStream;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.KeyStore;
import 
    
                                
    • 
                                
  • Zip解压压缩文件
                                    百合不是茶
Zip格式解压Zip流的使用文件解压
                                    
      
 ZIP文件的解压缩实质上就是从输入流中读取数据。Java.util.zip包提供了类ZipInputStream来读取ZIP文件,下面的代码段创建了一个输入流来读取ZIP格式的文件; 
ZipInputStream in = new ZipInputStream(new FileInputStream(zipFileName)); 
  
  
&n
    
                                
    • 
                                
  • underscore.js 学习（一）
                                    bijian1013
JavaScriptunderscore
                                    
            工作中需要用到underscore.js，发现这是一个包括了很多基本功能函数的js库，里面有很多实用的函数。而且它没有扩展 javascript的原生对象。主要涉及对Collection、Object、Array、Function的操作。       学
    
                                
    • 
                                
  • java jvm常用命令工具——jstatd命令(Java Statistics Monitoring Daemon)
                                    bijian1013
javajvmjstatd
                                    
    1.介绍 
        jstatd是一个基于RMI（Remove Method Invocation）的服务程序，它用于监控基于HotSpot的JVM中资源的创建及销毁，并且提供了一个远程接口允许远程的监控工具连接到本地的JVM执行命令。 
        jstatd是基于RMI的，所以在运行jstatd的服务
    
                                
    • 
                                
  • 【Spring框架三】Spring常用注解之Transactional
                                    bit1129
transactional
                                    
    Spring可以通过注解@Transactional来为业务逻辑层的方法(调用DAO完成持久化动作)添加事务能力，如下是@Transactional注解的定义： 
  
/*
 * Copyright 2002-2010 the original author or authors.
 *
 * Licensed under the Apache License, Version 
    
                                
    • 
                                
  • 我(程序员)的前进方向
                                    bitray
程序员
                                    
    作为一个普通的程序员,我一直游走在java语言中,java也确实让我有了很多的体会.不过随着学习的深入,java语言的新技术产生的越来越多,从最初期的javase,我逐渐开始转变到ssh,ssi,这种主流的码农,.过了几天为了解决新问题,webservice的大旗也被我祭出来了,又过了些日子jms架构的activemq也开始必须学习了.再后来开始了一系列技术学习,osgi,restful.....
    
                                
    • 
                                
  • nginx lua开发经验总结
                                    ronin47

                                    
    使用nginx lua已经两三个月了，项目接开发完毕了，这几天准备上线并且跟高德地图对接。回顾下来lua在项目中占得必中还是比较大的，跟PHP的占比差不多持平了，因此在开发中遇到一些问题备忘一下  1：content_by_lua中代码容量有限制，一般不要写太多代码，正常编写代码一般在100行左右（具体容量没有细心测哈哈，在4kb左右），如果超出了则重启nginx的时候会报 too long pa
    
                                
    • 
                                
  • java-66-用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。颠倒之后的栈为{5,4,3,2,1}，5处在栈顶
                                    bylijinnan
java
                                    
    
import java.util.Stack;

public class ReverseStackRecursive {

	/**
	 * Q 66.颠倒栈。
	 * 题目：用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。
	 * 颠倒之后的栈为{5,4,3,2,1}，5处在栈顶。
	 *1. Pop the top element
	 *2. Revers
    
                                
    • 
                                
  • 正确理解Linux内存占用过高的问题
                                    cfyme
linux
                                    
    Linux开机后，使用top命令查看，4G物理内存发现已使用的多大3.2G，占用率高达80%以上： 
Mem:   3889836k total,  3341868k used,   547968k free,   286044k buffers 
Swap:  6127608k total,&nb
    
                                
    • 
                                
  • [JWFD开源工作流]当前流程引擎设计的一个急需解决的问题
                                    comsci
工作流
                                    
     
 
     当我们的流程引擎进入IRC阶段的时候，当循环反馈模型出现之后，每次循环都会导致一大堆节点内存数据残留在系统内存中，循环的次数越多，这些残留数据将导致系统内存溢出，并使得引擎崩溃。。。。。。 
 
      而解决办法就是利用汇编语言或者其它系统编程语言，在引擎运行时，把这些残留数据清除掉。
    
                                
    • 
                                
  • 自定义类的equals函数
                                    dai_lm
equals
                                    
    仅作笔记使用 
 

public class VectorQueue {

	private final Vector<VectorItem> queue;

	private class VectorItem {
		private final Object item;
		private final int quantity;

		public VectorI
    
                                
    • 
                                
  • Linux下安装R语言
                                    datageek
R语言 linux
                                    
    命令如下：sudo gedit  /etc/apt/sources.list1、deb http://mirrors.ustc.edu.cn/CRAN/bin/linux/ubuntu/ precise/ 2、deb http://dk.archive.ubuntu.com/ubuntu hardy universesudo apt-key adv --keyserver ke
    
                                
    • 
                                
  • 如何修改mysql 并发数(连接数)最大值
                                    dcj3sjt126com
mysql
                                    
    MySQL的连接数最大值跟MySQL没关系，主要看系统和业务逻辑了 
  
方法一：进入MYSQL安装目录 打开MYSQL配置文件 my.ini 或 my.cnf查找 max_connections=100 修改为 max_connections=1000 服务里重起MYSQL即可 
　　方法二：MySQL的最大连接数默认是100客户端登录：mysql -uusername -ppass
    
                                
    • 
                                
  • 单一功能原则
                                    dcj3sjt126com
面向对象的程序设计软件设计编程原则
                                    
    单一功能原则[
编辑]            
SOLID    原则    
 
 单一功能原则 
 开闭原则 
 Liskov代换原则 
 接口隔离原则 
 依赖反转原则 
      
 
 查   
 论   
 编 
      
在面向对象编程领域中，单一功能原则（Single responsibility principle）规定每个类都应该有
    
                                
    • 
                                
  • POJO、VO和JavaBean区别和联系
                                    fanmingxing
VOPOJOjavabean
                                    
    POJO和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Plain Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比POJO复杂很多，JavaBean是一种组件技术，就好像你做了一个扳子，而这个扳子会在很多地方被
    
                                
    • 
                                
  • SpringSecurity3.X--LDAP：AD配置
                                    hanqunfeng
SpringSecurity
                                    
    前面介绍过基于本地数据库验证的方式，参考http://hanqunfeng.iteye.com/blog/1155226，这里说一下如何修改为使用AD进行身份验证【只对用户名和密码进行验证，权限依旧存储在本地数据库中】。 
  
将配置文件中的如下部分删除： 
  <!-- 认证管理器，使用自定义的UserDetailsService，并对密码采用md5加密-->  
  
    
                                
    • 
                                
  • mac mysql 修改密码
                                    IXHONG
mysql
                                    
    $ sudo /usr/local/mysql/bin/mysqld_safe –user=root & //启动MySQL(也可以通过偏好设置面板来启动)$ sudo /usr/local/mysql/bin/mysqladmin -uroot password yourpassword //设置MySQL密码（注意，这是第一次MySQL密码为空的时候的设置命令，如果是修改密码，还需在-
    
                                
    • 
                                
  • 设计模式--抽象工厂模式
                                    kerryg
设计模式
                                    
    抽象工厂模式： 
 
    工厂模式有一个问题就是，类的创建依赖于工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则。我们采用抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。 
 
    总结：这个模式的好处就是，如果想增加一个功能，就需要做一个实现类，
    
                                
    • 
                                
  • 评"高中女生军训期跳楼”
                                    nannan408

                                    
       首先，先抛出我的观点，各位看官少点砖头。那就是，中国的差异化教育必须做起来。 
   孔圣人有云：有教无类。不同类型的人，都应该有对应的教育方法。目前中国的一体化教育，不知道已经扼杀了多少创造性人才。我们出不了爱迪生，出不了爱因斯坦，很大原因，是我们的培养思路错了，我们是第一要“顺从”。如果不顺从，我们的学校，就会用各种方法，罚站，罚写作业，各种罚。军
    
                                
    • 
                                
  • scala如何读取和写入文件内容？
                                    qindongliang1922
javajvmscala
                                    
    直接看如下代码： 
 
package file

import java.io.RandomAccessFile
import java.nio.charset.Charset

import scala.io.Source
import scala.reflect.io.{File, Path}

/**
 * Created by qindongliang on 2015/
    
                                
    • 
                                
  • C语言算法之百元买百鸡
                                    qiufeihu
c算法
                                    
    中国古代数学家张丘建在他的《算经》中提出了一个著名的“百钱买百鸡问题”，鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问翁，母，雏各几何？ 
代码如下： 
#include <stdio.h>
int main()
{
	int cock,hen,chick;                               /*定义变量为基本整型*/
	for(coc
    
                                
    • 
                                
  • Hadoop集群安全性：Hadoop中Namenode单点故障的解决方案及详细介绍AvatarNode
                                    wyz2009107220
NameNode
                                    
    正如大家所知，NameNode在Hadoop系统中存在单点故障问题，这个对于标榜高可用性的Hadoop来说一直是个软肋。本文讨论一下为了解决这个问题而存在的几个solution。 
1. Secondary NameNode 
原理：Secondary NN会定期的从NN中读取editlog，与自己存储的Image进行合并形成新的metadata image 
优点：Hadoop较早的版本都自带，
    
                                
    •