禅-师
禅-师

android 休眠唤醒机制分析(一)

Android的休眠唤醒主要基于wake_lock机制，只要系统中存在任一有效的wake_lock，系统就不能进入深度休眠，但可以进行设备的浅度休眠操作。wake_lock一般在关闭lcd、tp但系统仍然需要正常运行的情况下使用，比如听歌、传输很大的文件等。本文主要分析driver层wake_lock的实现。

一、wake_lock 定义和接口

[cpp]  view plain copy
  1. enum {  
  2.     WAKE_LOCK_SUSPEND, // 阻止进入深度休眠模式  
  3.     WAKE_LOCK_IDLE,    // 阻止进入空闲模式  
  4.     WAKE_LOCK_TYPE_COUNT  
  5. };  
  6.   
  7. struct wake_lock {  
  8. #ifdef CONFIG_HAS_WAKELOCK  
  9.     struct list_head    link;     // 链表节点  
  10.     int                 flags;    // 标志  
  11.     const char         *name;     // 名称  
  12.     unsigned long       expires;  // 超时时间  
  13. #ifdef CONFIG_WAKELOCK_STAT  
  14.     struct {  
  15.         int             count;         // 使用计数  
  16.         int             expire_count;  // 超时计数  
  17.         int             wakeup_count;  // 唤醒计数  
  18.         ktime_t         total_time;    // 锁使用时间  
  19.         ktime_t         prevent_suspend_time;  // 锁阻止休眠的时间  
  20.         ktime_t         max_time;      // 锁使用时间最长的一次  
  21.         ktime_t         last_time;     // 锁上次操作时间  
  22.     } stat;  
  23. #endif  
  24. #endif  
  25. };  

可以看到wake_lock按功能分为休眠锁和空闲锁两种类型，用于阻止系统进入深度休眠模式或者空闲模式。wake_lock的主要部件有锁名称、链表节点、标志位、超时时间，另外还有一个内嵌的结构用于统计锁的使用信息。接下来我们看看wake_lock对外提供的操作接口：

1、内核空间接口

[cpp]  view plain copy
  1. void wake_lock_init(struct wake_lock *lock, int type, const char *name);  
  2. void wake_lock_destroy(struct wake_lock *lock);  
  3. void wake_lock(struct wake_lock *lock);  
  4. void wake_lock_timeout(struct wake_lock *lock, long timeout);  
  5. void wake_unlock(struct wake_lock *lock);  
其中wake_lock_init()用于初始化一个新锁，type参数指定了锁的类型；wake_lock_destroy()则注销一个锁；wake_lock()和wake_lock_timeout()用于将初始化完成的锁激活，使之成为有效的永久锁或者超时锁；wake_unlock()用于解锁使之成为无效锁。另外还有两个接口：

[cpp]  view plain copy
  1. int wake_lock_active(struct wake_lock *lock);  
  2. long has_wake_lock(int type);  

其中wake_lock_active()用于判断锁当前是否有效，如果有效则返回非0值；has_wake_lock()用于判断系统中是否还存在有效的type型锁，如果存在超时锁则返回最长的一个锁的超时时间，如果存在永久锁则返回-1，如果系统中不存在有效锁则返回0。

2、用户空间接口

wake_lock向用户空间提供了两个文件节点用于申请锁和解锁：

[cpp]  view plain copy
  1. // wack_lock文件的读函数,显示用户空间定义的有效锁  
  2. ssize_t wake_lock_show(  
  3.     struct kobject *kobj, struct kobj_attribute *attr, char *buf)  
  4. {  
  5.     char *s = buf;  
  6.     char *end = buf + PAGE_SIZE;  
  7.     struct rb_node *n;  
  8.     struct user_wake_lock *l;  
  9.   
  10.     mutex_lock(&tree_lock);  
  11.   
  12.     for (n = rb_first(&user_wake_locks); n != NULL; n = rb_next(n)) {  
  13.         l = rb_entry(n, struct user_wake_lock, node);  
  14.         if (wake_lock_active(&l->wake_lock))  
  15.             s += scnprintf(s, end - s, "%s ", l->name);  
  16.     }  
  17.     s += scnprintf(s, end - s, "\n");  
  18.   
  19.     mutex_unlock(&tree_lock);  
  20.     return (s - buf);  
  21. }  
  22.   
  23. // wack_lock文件的写函数,初始化并激活用户空间定义的锁  
  24. ssize_t wake_lock_store(  
  25.     struct kobject *kobj, struct kobj_attribute *attr,  
  26.     const char *buf, size_t n)  
  27. {  
  28.     long timeout;  
  29.     struct user_wake_lock *l;  
  30.   
  31.     mutex_lock(&tree_lock);  
  32.     l = lookup_wake_lock_name(buf, 1, &timeout);  
  33.     if (IS_ERR(l)) {  
  34.         n = PTR_ERR(l);  
  35.         goto bad_name;  
  36.     }  
  37.   
  38.     if (debug_mask & DEBUG_ACCESS)  
  39.         pr_info("wake_lock_store: %s, timeout %ld\n", l->name, timeout);  
  40.   
  41.     if (timeout)  
  42.         wake_lock_timeout(&l->wake_lock, timeout);  
  43.     else  
  44.         wake_lock(&l->wake_lock);  
  45. bad_name:  
  46.     mutex_unlock(&tree_lock);  
  47.     return n;  
  48. }  
  49.   
  50. // wack_unlock文件的读函数,显示用户空间的无效锁  
  51. ssize_t wake_unlock_show(  
  52.     struct kobject *kobj, struct kobj_attribute *attr, char *buf)  
  53. {  
  54.     char *s = buf;  
  55.     char *end = buf + PAGE_SIZE;  
  56.     struct rb_node *n;  
  57.     struct user_wake_lock *l;  
  58.   
  59.     mutex_lock(&tree_lock);  
  60.   
  61.     for (n = rb_first(&user_wake_locks); n != NULL; n = rb_next(n)) {  
  62.         l = rb_entry(n, struct user_wake_lock, node);  
  63.         if (!wake_lock_active(&l->wake_lock))  
  64.             s += scnprintf(s, end - s, "%s ", l->name);  
  65.     }  
  66.     s += scnprintf(s, end - s, "\n");  
  67.   
  68.     mutex_unlock(&tree_lock);  
  69.     return (s - buf);  
  70. }  
  71.   
  72. // wack_unlock文件的写函数,用于用户空间解锁  
  73. ssize_t wake_unlock_store(  
  74.     struct kobject *kobj, struct kobj_attribute *attr,  
  75.     const char *buf, size_t n)  
  76. {  
  77.     struct user_wake_lock *l;  
  78.   
  79.     mutex_lock(&tree_lock);  
  80.     l = lookup_wake_lock_name(buf, 0, NULL);  
  81.     if (IS_ERR(l)) {  
  82.         n = PTR_ERR(l);  
  83.         goto not_found;  
  84.     }  
  85.   
  86.     if (debug_mask & DEBUG_ACCESS)  
  87.         pr_info("wake_unlock_store: %s\n", l->name);  
  88.   
  89.     wake_unlock(&l->wake_lock);  
  90. not_found:  
  91.     mutex_unlock(&tree_lock);  
  92.     return n;  
  93. }  
  94.   
  95. power_attr(wake_lock);  
  96. power_attr(wake_unlock);  
这两个文件节点分别为"/sys/power/wake_lock"和"/sys/power/wake_unlock"，应用程序可以根据HAL层的接口读写这两个节点。
二、wake_lock 实现
在linux/kernel/power/wakelock.c中我们可以看到wake_lock的实现代码，首先看看其定义的一些初始化信息：

[cpp]  view plain copy
  1. #define WAKE_LOCK_TYPE_MASK              (0x0f)     // 锁类型标志掩码  
  2. #define WAKE_LOCK_INITIALIZED            (1U << 8)  // 锁已经初始化标志  
  3. #define WAKE_LOCK_ACTIVE                 (1U << 9)  // 锁有效标志  
  4. #define WAKE_LOCK_AUTO_EXPIRE            (1U << 10) // 超时锁标志  
  5. #define WAKE_LOCK_PREVENTING_SUSPEND     (1U << 11) // 正在阻止休眠标志  
  6.   
  7. static DEFINE_SPINLOCK(list_lock);  // 读写锁链表的自旋锁  
  8. static LIST_HEAD(inactive_locks);   // 内核维护的无效锁链表  
  9. static struct list_head active_wake_locks[WAKE_LOCK_TYPE_COUNT];  // 有效锁链表  
  10. static int current_event_num;       // 休眠锁使用计数器  
  11. struct workqueue_struct *suspend_work_queue;  // 执行系统休眠的工作队列  
  12. struct workqueue_struct *sys_sync_work_queue; // 执行系统同步的工作队列  
  13. struct wake_lock main_wake_lock;              // 内核休眠锁  
  14. struct wake_lock sys_sync_wake_lock;          // 缓存同步锁  
  15. suspend_state_t requested_suspend_state = PM_SUSPEND_MEM;  // 系统休眠状态  
  16. static struct wake_lock unknown_wakeup;       // 未知锁  

在后面的分析中我们会看到这些变量的具体用途。

1、wake_lock系统初始化

[cpp]  view plain copy
  1. static int __init wakelocks_init(void)  
  2. {  
  3.     int ret;  
  4.     int i;  
  5.     // 初始化有效锁链表,内核维护了2个有效锁链表  
  6.     // WAKE_LOCK_SUSPEND 用于阻止进入深度休眠模式  
  7.     // WAKE_LOCK_IDLE    用于阻止进入空闲模式  
  8.     for (i = 0; i < ARRAY_SIZE(active_wake_locks); i++)  
  9.         INIT_LIST_HEAD(&active_wake_locks[i]);  
  10.   
  11. #ifdef CONFIG_WAKELOCK_STAT  
  12.     // 初始化deleted_wake_locks  
  13.     wake_lock_init(&deleted_wake_locks, WAKE_LOCK_SUSPEND,  
  14.             "deleted_wake_locks");  
  15. #endif  
  16.     // 初始化内核休眠锁  
  17.     wake_lock_init(&main_wake_lock, WAKE_LOCK_SUSPEND, "main");  
  18.     // 初始化同步锁  
  19.     wake_lock_init(&sys_sync_wake_lock, WAKE_LOCK_SUSPEND, "sys_sync");  
  20.     // 激活内核休眠锁  
  21.     wake_lock(&main_wake_lock);  
  22.     // 初始化未知锁  
  23.     wake_lock_init(&unknown_wakeup, WAKE_LOCK_SUSPEND, "unknown_wakeups");  
  24.   
  25.     // 注册power_device,power_driver  
  26.     ret = platform_device_register(&power_device);  
  27.     if (ret) {  
  28.         pr_err("wakelocks_init: platform_device_register failed\n");  
  29.         goto err_platform_device_register;  
  30.     }  
  31.     ret = platform_driver_register(&power_driver);  
  32.     if (ret) {  
  33.         pr_err("wakelocks_init: platform_driver_register failed\n");  
  34.         goto err_platform_driver_register;  
  35.     }  
  36.     // 创建fs_sync内核进程  
  37.     sys_sync_work_queue = create_singlethread_workqueue("fs_sync");  
  38.     if (sys_sync_work_queue == NULL) {  
  39.         pr_err ("fs_sync workqueue create failed.\n");  
  40.     }  
  41.     // 创建suspend内核进程  
  42.     suspend_work_queue = create_singlethread_workqueue("suspend");  
  43.     if (suspend_work_queue == NULL) {  
  44.         ret = -ENOMEM;  
  45.         goto err_suspend_work_queue;  
  46.     }  
  47.   
  48. #ifdef CONFIG_WAKELOCK_STAT  
  49.     // 在proc下创建wakelocks文件  
  50.     proc_create("wakelocks", S_IRUGO, NULL, &wakelock_stats_fops);  
  51. #endif  
  52.   
  53.     return 0;  
  54.   
  55. err_suspend_work_queue:  
  56.     platform_driver_unregister(&power_driver);  
  57. err_platform_driver_register:  
  58.     platform_device_unregister(&power_device);  
  59. err_platform_device_register:  
  60.     wake_lock_destroy(&unknown_wakeup);  
  61.     wake_lock_destroy(&main_wake_lock);  
  62. #ifdef CONFIG_WAKELOCK_STAT  
  63.     wake_lock_destroy(&deleted_wake_locks);  
  64. #endif  
  65.     return ret;  
  66. }  
  67. core_initcall(wakelocks_init);  

可以看到内核通过core_initcall调用了wake_lock系统的初始化函数，函数首先初始化了两个有效锁的链表，用于管理系统中的有效锁；接下来初始化了deleted_wake_locks用于处理统计信息，main_wake_lock用于锁定内核（系统启动时会激活这个锁，深度休眠时需要释放这个锁），sys_sync_wake_lock用于浅度休眠阶段同步缓存时阻止内核进入深度休眠，unknown_wakeup用于唤醒时延迟0.5s进入下一次可能的深度休眠；还注册了一个platform_device用于深度休眠阶段检测是否存在有效锁；后面创建了内核进程fs_sync用于浅度休眠阶段同步缓存，内核进程suspend用于进行浅度休眠和深度休眠；还在/proc下面创建了wakelocks节点用于显示wake_lock的统计信息。

2、wake_lock初始化

[cpp]  view plain copy
  1. void wake_lock_init(struct wake_lock *lock, int type, const char *name)  
  2. {  
  3.     unsigned long irqflags = 0;  
  4.     // 初始化名称  
  5.     if (name)  
  6.         lock->name = name;  
  7.     BUG_ON(!lock->name);  
  8.   
  9.     if (debug_mask & DEBUG_WAKE_LOCK)  
  10.         pr_info("wake_lock_init name=%s\n", lock->name);  
  11. #ifdef CONFIG_WAKELOCK_STAT  
  12.     lock->stat.count = 0;  
  13.     lock->stat.expire_count = 0;  
  14.     lock->stat.wakeup_count = 0;  
  15.     lock->stat.total_time = ktime_set(0, 0);  
  16.     lock->stat.prevent_suspend_time = ktime_set(0, 0);  
  17.     lock->stat.max_time = ktime_set(0, 0);  
  18.     lock->stat.last_time = ktime_set(0, 0);  
  19. #endif  
  20.     // 初始化flag  
  21.     lock->flags = (type & WAKE_LOCK_TYPE_MASK) | WAKE_LOCK_INITIALIZED;  
  22.     // 初始化链表节点  
  23.     INIT_LIST_HEAD(&lock->link);  
  24.     spin_lock_irqsave(&list_lock, irqflags);  
  25.     // 将锁加入无效锁链表  
  26.     list_add(&lock->link, &inactive_locks);  
  27.     spin_unlock_irqrestore(&list_lock, irqflags);  
  28. }  
  29. EXPORT_SYMBOL(wake_lock_init);  
其中参数lock为被初始化对象，type代表锁的类型，name表示锁的名称， 函数主要初始化锁的名称并设置 WAKE_LOCK_INITIALIZED 标志位，并将锁加入无效锁链表inactive_locks，当需要使用锁的时候通过wake_lock()或者wake_lock_timeout()激活该锁：

[cpp]  view plain copy
  1. // 根据参数激活锁  
  2. static void wake_lock_internal(  
  3.     struct wake_lock *lock, long timeout, int has_timeout)  
  4. {  
  5.     int type;  
  6.     unsigned long irqflags;  
  7.     long expire_in;  
  8.   
  9.     spin_lock_irqsave(&list_lock, irqflags);  
  10.     // 获取锁的类型  
  11.     type = lock->flags & WAKE_LOCK_TYPE_MASK;  
  12.     BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);  
  13.     BUG_ON(!(lock->flags & WAKE_LOCK_INITIALIZED));  
  14. #ifdef CONFIG_WAKELOCK_STAT  
  15.     if (type == WAKE_LOCK_SUSPEND && wait_for_wakeup) {  
  16.         if (debug_mask & DEBUG_WAKEUP)  
  17.             pr_info("wakeup wake lock: %s\n", lock->name);  
  18.         wait_for_wakeup = 0;  
  19.         lock->stat.wakeup_count++;  
  20.     }  
  21.     if ((lock->flags & WAKE_LOCK_AUTO_EXPIRE) &&  
  22.         (long)(lock->expires - jiffies) <= 0) {  
  23.         wake_unlock_stat_locked(lock, 0);  
  24.         lock->stat.last_time = ktime_get();  
  25.     }  
  26. #endif  
  27.     // 设置锁有效的标志位  
  28.     if (!(lock->flags & WAKE_LOCK_ACTIVE)) {  
  29.         lock->flags |= WAKE_LOCK_ACTIVE;  
  30. #ifdef CONFIG_WAKELOCK_STAT  
  31.         lock->stat.last_time = ktime_get();  
  32. #endif  
  33.     }  
  34.     // 将锁从无效锁链表中删除  
  35.     list_del(&lock->link);  
  36.     // 如果是超时锁  
  37.     if (has_timeout) {  
  38.         if (debug_mask & DEBUG_WAKE_LOCK)  
  39.             pr_info("wake_lock: %s, type %d, timeout %ld.%03lu\n",  
  40.                 lock->name, type, timeout / HZ,  
  41.                 (timeout % HZ) * MSEC_PER_SEC / HZ);  
  42.         // 设置锁超时时间,以当前jiffies为基准  
  43.         lock->expires = jiffies + timeout;  
  44.         // 设置锁的超时锁标志  
  45.         lock->flags |= WAKE_LOCK_AUTO_EXPIRE;  
  46.         // 将锁加入有效锁链表  
  47.         list_add_tail(&lock->link, &active_wake_locks[type]);  
  48.     } else {  // 如果是永久锁  
  49.         if (debug_mask & DEBUG_WAKE_LOCK)  
  50.             pr_info("wake_lock: %s, type %d\n", lock->name, type);  
  51.         // 设置超时时间为极限  
  52.         lock->expires = LONG_MAX;  
  53.         // 清除超时锁标志  
  54.         lock->flags &= ~WAKE_LOCK_AUTO_EXPIRE;  
  55.         // 将锁加入有效锁链表  
  56.         list_add(&lock->link, &active_wake_locks[type]);  
  57.     }  
  58.     // 如果是休眠锁  
  59.     if (type == WAKE_LOCK_SUSPEND) {  
  60.         current_event_num++;  // 休眠锁使用计数器加1  
  61. #ifdef CONFIG_WAKELOCK_STAT  
  62.         // 如果是内核休眠锁  
  63.         if (lock == &main_wake_lock)  
  64.             update_sleep_wait_stats_locked(1);  
  65.         // 如果内核休眠锁无效  
  66.         else if (!wake_lock_active(&main_wake_lock))  
  67.             update_sleep_wait_stats_locked(0);  
  68. #endif  
  69.         // 如果是超时锁  
  70.         if (has_timeout)  
  71.             expire_in = has_wake_lock_locked(type);  
  72.         else  
  73.             expire_in = -1;  
  74.         // 当前存在有效超时锁,并且最长的一个到期时间间隔为expire_in  
  75.         if (expire_in > 0) {  
  76.             if (debug_mask & DEBUG_EXPIRE)  
  77.                 pr_info("wake_lock: %s, start expire timer, "  
  78.                     "%ld\n", lock->name, expire_in);  
  79.             mod_timer(&expire_timer, jiffies + expire_in);  
  80.         } else {  // 如果有永久锁或者无有效锁  
  81.             if (del_timer(&expire_timer))  
  82.                 if (debug_mask & DEBUG_EXPIRE)  
  83.                     pr_info("wake_lock: %s, stop expire timer\n",  
  84.                         lock->name);  
  85.             if (expire_in == 0)  // 无有效锁  
  86.                 queue_work(suspend_work_queue, &suspend_work);  
  87.         }  
  88.     }  
  89.     spin_unlock_irqrestore(&list_lock, irqflags);  
  90. }  
  91.   
  92. // 激活永久锁  
  93. void wake_lock(struct wake_lock *lock)  
  94. {  
  95.     wake_lock_internal(lock, 0, 0);  
  96. }  
  97. EXPORT_SYMBOL(wake_lock);  
  98.   
  99. // 激活超时锁  
  100. void wake_lock_timeout(struct wake_lock *lock, long timeout)  
  101. {  
  102.     wake_lock_internal(lock, timeout, 1);  
  103. }  
  104. EXPORT_SYMBOL(wake_lock_timeout);  
可以看到激活过程都是通过调用wake_lock_internal()完成的，该函数首先完成一些统计信息的初始化，设置 WAKE_LOCK_ACTIVE 标志位并将锁从无效锁链表中移除；然后根据是否是超时锁设置 WAKE_LOCK_AUTO_EXPIRE 标志位，并设置超时锁的超时时间，再将锁加入有效锁链表；最后再根据锁的类型判断是否为休眠锁，如果是休眠锁且为超时锁则通过has_wake_lock_locked()获取系统中存在的超时锁中时间最长的到期时间值，并以此值设置expire_timer，has_wake_lock_locked()返回0则表示系统中不存在有效锁则启动suspend进程开始进入深度休眠状态。

3、expire_timer

[cpp]  view plain copy
  1. static void expire_wake_locks(unsigned long data)  
  2. {  
  3.     long has_lock;  
  4.     unsigned long irqflags;  
  5.     if (debug_mask & DEBUG_EXPIRE)  
  6.         pr_info("expire_wake_locks: start\n");  
  7.     spin_lock_irqsave(&list_lock, irqflags);  
  8.     // 打印当前的有效锁  
  9.     if (debug_mask & DEBUG_SUSPEND)  
  10.         print_active_locks(WAKE_LOCK_SUSPEND);  
  11.     // 检测系统是否持有休眠锁  
  12.     has_lock = has_wake_lock_locked(WAKE_LOCK_SUSPEND);  
  13.     if (debug_mask & DEBUG_EXPIRE)  
  14.         pr_info("expire_wake_locks: done, has_lock %ld\n", has_lock);  
  15.     // 如果系统当前没有持有有效地休眠锁  
  16.     if (has_lock == 0)  
  17.         // 则启动深度休眠工作队列  
  18.         queue_work(suspend_work_queue, &suspend_work);  
  19.     spin_unlock_irqrestore(&list_lock, irqflags);  
  20. }  
  21. // 定义timer,运行函数为expire_wake_locks  
  22. static DEFINE_TIMER(expire_timer, expire_wake_locks, 0, 0);  
该timer会在多个地方用到，在激活锁的函数中注册用于超时锁到期后检测系统的有效锁状态，如果系统不存在有效锁了则启动suspend进程。
4、suspend_work
[cpp]  view plain copy
  1. static void suspend(struct work_struct *work)  
  2. {  
  3.     int ret;  
  4.     int entry_event_num;  
  5.   
  6.     // 判断系统是否还持有有效锁,如果有则直接返回  
  7.     if (has_wake_lock(WAKE_LOCK_SUSPEND)) {  
  8.         if (debug_mask & DEBUG_SUSPEND)  
  9.             pr_info("suspend: abort suspend\n");  
  10.         return;  
  11.     }  
  12.   
  13.     // 记录函数进入时休眠锁的使用次数  
  14.     entry_event_num = current_event_num;  
  15.     sys_sync();  // 将缓存中的数据写入磁盘  
  16.     if (debug_mask & DEBUG_SUSPEND)  
  17.         pr_info("suspend: enter suspend\n");  
  18.     // 开始深度休眠  
  19.     ret = pm_suspend(requested_suspend_state);  
  20.     // 退出深度休眠,打印信息  
  21.     if (debug_mask & DEBUG_EXIT_SUSPEND) {  
  22.         struct timespec ts;  
  23.         struct rtc_time tm;  
  24.         getnstimeofday(&ts);  
  25.         rtc_time_to_tm(ts.tv_sec, &tm);  
  26.         pr_info("suspend: exit suspend, ret = %d "  
  27.             "(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n", ret,  
  28.             tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,  
  29.             tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);  
  30.     }  
  31.     // 如果深度休眠前和深度休眠后锁的使用次数一致，即唤醒过程中没有激活新的锁  
  32.     if (current_event_num == entry_event_num) {  
  33.         if (debug_mask & DEBUG_SUSPEND)  
  34.             pr_info("suspend: pm_suspend returned with no event\n");  
  35.         // 激活unknown_wakeup,0.5s超时  
  36.         wake_lock_timeout(&unknown_wakeup, HZ / 2);  
  37.     }  
  38. }  
  39. // 声明工作队列,运行函数为suspend  
  40. static DECLARE_WORK(suspend_work, suspend);  
声明工作队列用于内核深度休眠，可以看到一个正常的休眠流程会三次调用sys_sync()用于同步缓存（之前一次在浅度休眠，之后一次在深度休眠），然后调用pm_suspend()开始执行深度休眠流程。
5、has_wake_lock

[cpp]  view plain copy
  1. // 移除过期超时锁  
  2. static void expire_wake_lock(struct wake_lock *lock)  
  3. {  
  4. #ifdef CONFIG_WAKELOCK_STAT  
  5.     wake_unlock_stat_locked(lock, 1);  
  6. #endif  
  7.     // 清除锁有效和超时锁标志  
  8.     lock->flags &= ~(WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE);  
  9.     // 从当前链表中删除  
  10.     list_del(&lock->link);  
  11.     // 加入无效锁链表  
  12.     list_add(&lock->link, &inactive_locks);  
  13.     if (debug_mask & (DEBUG_WAKE_LOCK | DEBUG_EXPIRE))  
  14.         pr_info("expired wake lock %s\n", lock->name);  
  15. }  
  16.   
  17. // 打印有效锁信息,调用者需持有list_lock  
  18. static void print_active_locks(int type)  
  19. {  
  20.     struct wake_lock *lock;  
  21.     bool print_expired = true;  
  22.   
  23.     BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);  
  24.     // 遍历有效锁链表  
  25.     list_for_each_entry(lock, &active_wake_locks[type], link) {  
  26.         // 如果是超时锁  
  27.         if (lock->flags & WAKE_LOCK_AUTO_EXPIRE) {  
  28.             // 计算超时剩余时间  
  29.             long timeout = lock->expires - jiffies;  
  30.             if (timeout > 0)  
  31.                 pr_info("active wake lock %s, time left %ld\n",  
  32.                     lock->name, timeout);  
  33.             else if (print_expired)  
  34.                 pr_info("wake lock %s, expired\n", lock->name);  
  35.         } else {  // 如果不是超时锁  
  36.             pr_info("active wake lock %s\n", lock->name);  
  37.             if (!debug_mask & DEBUG_EXPIRE)  
  38.                 print_expired = false;  
  39.         }  
  40.     }  
  41. }  
  42.   
  43. static long has_wake_lock_locked(int type)  
  44. {  
  45.     struct wake_lock *lock, *n;  
  46.     long max_timeout = 0;  
  47.   
  48.     BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);  
  49.     // 遍历有效锁链表  
  50.     list_for_each_entry_safe(lock, n, &active_wake_locks[type], link) {  
  51.         // 如果是超时锁  
  52.         if (lock->flags & WAKE_LOCK_AUTO_EXPIRE) {  
  53.             // 计算超时剩余时间  
  54.             long timeout = lock->expires - jiffies;  
  55.             // 如果锁已经过期  
  56.             if (timeout <= 0)  
  57.                 // 移除过期锁  
  58.                 expire_wake_lock(lock);  
  59.             else if (timeout > max_timeout)  // 如果锁没有过期  
  60.                 // 得到最长的一个超时时间  
  61.                 max_timeout = timeout;  
  62.         } else // 如果不是超时锁则返回-1  
  63.             return -1;  
  64.     }  
  65.     return max_timeout;  
  66. }  
  67.   
  68. // 判断系统是否还持有有效锁  
  69. long has_wake_lock(int type)  
  70. {  
  71.     long ret;  
  72.     unsigned long irqflags;  
  73.     spin_lock_irqsave(&list_lock, irqflags);  
  74.     // 开始判断流程  
  75.     ret = has_wake_lock_locked(type);  
  76.     // 如果还有休眠锁有效则打印状态信息  
  77.     if (ret && (debug_mask & DEBUG_SUSPEND) && type == WAKE_LOCK_SUSPEND)  
  78.         print_active_locks(type);  
  79.     spin_unlock_irqrestore(&list_lock, irqflags);  
  80.     return ret;  
  81. }  
has_wake_lock()为系统判断当前是否存在指定类型有效锁的接口，在has_wake_lock_locked()中遍历有效锁链表，返回前面我们已经说明的值；并且打印所有有效锁的状态信息。
6、wake_unlock

[cpp]  view plain copy
  1. void wake_unlock(struct wake_lock *lock)  
  2. {  
  3.     int type;  
  4.     unsigned long irqflags;  
  5.     spin_lock_irqsave(&list_lock, irqflags);  
  6.     type = lock->flags & WAKE_LOCK_TYPE_MASK;  
  7. #ifdef CONFIG_WAKELOCK_STAT  
  8.     // 更新锁的状态  
  9.     wake_unlock_stat_locked(lock, 0);  
  10. #endif  
  11.     if (debug_mask & DEBUG_WAKE_LOCK)  
  12.         pr_info("wake_unlock: %s\n", lock->name);  
  13.     // 清楚有效锁和超时锁标志  
  14.     lock->flags &= ~(WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE);  
  15.     // 将锁从有效锁链表中移除加入无效锁链表  
  16.     list_del(&lock->link);  
  17.     list_add(&lock->link, &inactive_locks);  
  18.     // 如果是休眠锁  
  19.     if (type == WAKE_LOCK_SUSPEND) {  
  20.         // 判断系统当前是否还持有锁  
  21.         long has_lock = has_wake_lock_locked(type);  
  22.         // 如果还持有锁,设置timer到超时时间点触发  
  23.         if (has_lock > 0) {  
  24.             if (debug_mask & DEBUG_EXPIRE)  
  25.                 pr_info("wake_unlock: %s, start expire timer, "  
  26.                     "%ld\n", lock->name, has_lock);  
  27.             mod_timer(&expire_timer, jiffies + has_lock);  
  28.         } else {  
  29.             if (del_timer(&expire_timer))  // 删除timer  
  30.                 if (debug_mask & DEBUG_EXPIRE)  
  31.                     pr_info("wake_unlock: %s, stop expire "  
  32.                         "timer\n", lock->name);  
  33.             if (has_lock == 0)  // 启动深度休眠工作队列  
  34.                 queue_work(suspend_work_queue, &suspend_work);  
  35.         }  
  36.         // 如果是内核锁  
  37.         if (lock == &main_wake_lock) {  
  38.             if (debug_mask & DEBUG_SUSPEND)  
  39.                 // 打印当前有效锁信息  
  40.                 print_active_locks(WAKE_LOCK_SUSPEND);  
  41. #ifdef CONFIG_WAKELOCK_STAT  
  42.             update_sleep_wait_stats_locked(0);  
  43. #endif  
  44.         }  
  45.     }  
  46.     spin_unlock_irqrestore(&list_lock, irqflags);  
  47. }  
  48. EXPORT_SYMBOL(wake_unlock);  
该函数用于释放一个锁，首先将锁从有效锁链表中移除并加入无效锁链表，并判断系统是否还持有有效锁，如果没有则进入深度休眠流程。

7、wake_lock_active

[cpp]  view plain copy
  1. // 判断锁是否有效  
  2. int wake_lock_active(struct wake_lock *lock)  
  3. {  
  4.     return !!(lock->flags & WAKE_LOCK_ACTIVE);  
  5. }  
  6. EXPORT_SYMBOL(wake_lock_active);  
8、wake_lock_destroy

[cpp]  view plain copy
  1. void wake_lock_destroy(struct wake_lock *lock)  
  2. {  
  3.     unsigned long irqflags;  
  4.     if (debug_mask & DEBUG_WAKE_LOCK)  
  5.         pr_info("wake_lock_destroy name=%s\n", lock->name);  
  6.     spin_lock_irqsave(&list_lock, irqflags);  
  7.     // 清除已经初始化的标志  
  8.     lock->flags &= ~WAKE_LOCK_INITIALIZED;  
  9. #ifdef CONFIG_WAKELOCK_STAT  
  10.     if (lock->stat.count) {  
  11.         deleted_wake_locks.stat.count += lock->stat.count;  
  12.         deleted_wake_locks.stat.expire_count += lock->stat.expire_count;  
  13.         deleted_wake_locks.stat.total_time =  
  14.             ktime_add(deleted_wake_locks.stat.total_time,  
  15.                   lock->stat.total_time);  
  16.         deleted_wake_locks.stat.prevent_suspend_time =  
  17.             ktime_add(deleted_wake_locks.stat.prevent_suspend_time,  
  18.                   lock->stat.prevent_suspend_time);  
  19.         deleted_wake_locks.stat.max_time =  
  20.             ktime_add(deleted_wake_locks.stat.max_time,  
  21.                   lock->stat.max_time);  
  22.     }  
  23. #endif  
  24.     // 从当前链表中删除  
  25.     list_del(&lock->link);  
  26.     spin_unlock_irqrestore(&list_lock, irqflags);  
  27. }  
  28. EXPORT_SYMBOL(wake_lock_destroy);  
该函数用于注销wake_lock，首先清除 WAKE_LOCK_INITIALIZED 标志位，然后更新统计信息，最后将锁从链表中删除。

9、proc节点

[cpp]  view plain copy
  1. // 获取锁的剩余超时时间,通过*expire_time传递  
  2. int get_expired_time(struct wake_lock *lock, ktime_t *expire_time)  
  3. {  
  4.     struct timespec ts;  
  5.     struct timespec kt;  
  6.     struct timespec tomono;  
  7.     struct timespec delta;  
  8.     unsigned long seq;  
  9.     long timeout;  
  10.   
  11.     // 如果不是超时锁则直接返回  
  12.     if (!(lock->flags & WAKE_LOCK_AUTO_EXPIRE))  
  13.         return 0;  
  14.   
  15.     do {  
  16.         seq = read_seqbegin(&xtime_lock);  
  17.         // 计算超时时间点与当前时间的差值  
  18.         timeout = lock->expires - jiffies;  
  19.         // 如果时间没有到期,返回0  
  20.         if (timeout > 0)  
  21.             return 0;  
  22.         // 获取当前时间  
  23.         kt = current_kernel_time();  
  24.         tomono = wall_to_monotonic;  
  25.     } while (read_seqretry(&xtime_lock, seq));  
  26.     // 时间格式转换  
  27.     jiffies_to_timespec(-timeout, &delta);  
  28.     // 设置timespec的成员  
  29.     set_normalized_timespec(&ts, kt.tv_sec + tomono.tv_sec - delta.tv_sec,  
  30.                 kt.tv_nsec + tomono.tv_nsec - delta.tv_nsec);  
  31.     // 返回ts值  
  32.     *expire_time = timespec_to_ktime(ts);  
  33.     return 1;  
  34. }  
  35.   
  36. // 打印出锁的状态信息  
  37. static int print_lock_stat(struct seq_file *m, struct wake_lock *lock)  
  38. {  
  39.     int lock_count = lock->stat.count;  
  40.     int expire_count = lock->stat.expire_count;  
  41.     ktime_t active_time = ktime_set(0, 0);  
  42.     ktime_t total_time = lock->stat.total_time;  
  43.     ktime_t max_time = lock->stat.max_time;  
  44.   
  45.     ktime_t prevent_suspend_time = lock->stat.prevent_suspend_time;  
  46.     // 如果锁有效  
  47.     if (lock->flags & WAKE_LOCK_ACTIVE) {  
  48.         ktime_t now, add_time;  
  49.         // 获取超时剩余时间  
  50.         int expired = get_expired_time(lock, &now);  
  51.         if (!expired)  
  52.             now = ktime_get();  
  53.         // 计算当前时间和上次操作时间的差值  
  54.         add_time = ktime_sub(now, lock->stat.last_time);  
  55.         lock_count++;  // 使用计数加1  
  56.         if (!expired)  // 如果没有到期  
  57.             active_time = add_time;  
  58.         else  // 锁已经到期  
  59.             expire_count++;  // 超时计数加1  
  60.         total_time = ktime_add(total_time, add_time);  // 锁使用时间增加  
  61.         if (lock->flags & WAKE_LOCK_PREVENTING_SUSPEND)  
  62.             prevent_suspend_time = ktime_add(prevent_suspend_time,  
  63.                     ktime_sub(now, last_sleep_time_update));  
  64.         if (add_time.tv64 > max_time.tv64)  
  65.             max_time = add_time;  
  66.     }  
  67.   
  68.     return seq_printf(m,  
  69.              "\"%s\"\t%d\t%d\t%d\t%lld\t%lld\t%lld\t%lld\t%lld\n",  
  70.              lock->name, lock_count, expire_count,  
  71.              lock->stat.wakeup_count, ktime_to_ns(active_time),  
  72.              ktime_to_ns(total_time),  
  73.              ktime_to_ns(prevent_suspend_time), ktime_to_ns(max_time),  
  74.              ktime_to_ns(lock->stat.last_time));  
  75. }  
  76.   
  77. // 打印锁状态  
  78. static int wakelock_stats_show(struct seq_file *m, void *unused)  
  79. {  
  80.     unsigned long irqflags;  
  81.     struct wake_lock *lock;  
  82.     int ret;  
  83.     int type;  
  84.   
  85.     spin_lock_irqsave(&list_lock, irqflags);  
  86.     // 输出菜单  
  87.     ret = seq_puts(m, "name\tcount\texpire_count\twake_count\tactive_since"  
  88.             "\ttotal_time\tsleep_time\tmax_time\tlast_change\n");  
  89.     // 遍历无效锁链表并打印锁的状态信息  
  90.     list_for_each_entry(lock, &inactive_locks, link)  
  91.         ret = print_lock_stat(m, lock);  
  92.     // 遍历有效锁链表并打印锁的状态信息  
  93.     for (type = 0; type < WAKE_LOCK_TYPE_COUNT; type++) {  
  94.         list_for_each_entry(lock, &active_wake_locks[type], link)  
  95.             ret = print_lock_stat(m, lock);  
  96.     }  
  97.     spin_unlock_irqrestore(&list_lock, irqflags);  
  98.     return 0;  
  99. }  
  100.   
  101. // proc文件打开函数,调用show函数显示当前所有的锁信息  
  102. static int wakelock_stats_open(struct inode *inode, struct file *file)  
  103. {  
  104.     return single_open(file, wakelock_stats_show, NULL);  
  105. }  
  106.   
  107. // proc文件系统操作函数  
  108. static const struct file_operations wakelock_stats_fops = {  
  109.     .owner = THIS_MODULE,  
  110.     .open = wakelock_stats_open,  
  111.     .read = seq_read,  
  112.     .llseek = seq_lseek,  
  113.     .release = single_release,  
  114. };  

以上是proc节点的操作接口，在wakelocks_init中注册。


总结：通过以上分析我们可以看到启动深度休眠流程有四个可能的地方，分别为expire_timer、wake_lock、wake_lock_timeout、wake_unlock，其中expire_timer和wake_unlock最常见

你可能感兴趣的:(android)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • android ndk 开发jni调用对象方法，数组参数 wulongkou 开发问题安卓的事ndkandroidstudiojni
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
  • Android jni中数组参数的传递方式 lokeyme Andriodandroid开发JNINDKjavac语言
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
  • 1-1.Jetpack 之 Navigation 简单编码模板 我命由我12345 Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用 erhtre 程序员androidjetpack架构sqlite
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
  • Android干净架构MVI模板使用指南 井美婵Toby
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件 惊鸿醉 Unityunityandroidxml
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
  • 《Android进阶之光》读书笔记 soleil雪寂 读书笔记#Android进阶之光
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • 《android进阶之光》——多线程编程（上） TAING要一直努力 读书笔记
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
  • android进阶之光！Android面试必备的集合源码详解，系列篇 程序员Sunbu 程序员Android
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1) egrhef 程序员androidjava开发语言
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
  • Visual Studio中的Android模拟器使用详解 wurui8 androidandroidstudioandroidandroid应用
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示 仙魁XAN Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • （小白入门）Windows环境下搭建React Native Android开发环境 码农老黑 前端ReactNative移动开发Androidstudio
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
  • Android Dialog圆角设置无效的问题 ly969434341 android
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活 技术无疆 Androidandroiduiandroidstudioandroid-studiojavaandroidx
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
  • Android界面特效全汇总 小飞鹤 Android开发详解android
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
  • 矩阵求逆（JAVA）初等行变换 qiuwanchi 矩阵求逆（JAVA）
    package gaodai.matrix; import gaodai.determinant.DeterminantCalculation; import java.util.ArrayList; import java.util.List; import java.util.Scanner; /** * 矩阵求逆(初等行变换) * @author 邱万迟 *
  • JDK timer antlove javajdkschedulecodetimer
    1.java.util.Timer.schedule(TimerTask task, long delay)：多长时间（毫秒）后执行任务 2.java.util.Timer.schedule(TimerTask task, Date time)：设定某个时间执行任务 3.java.util.Timer.schedule(TimerTask task, long delay,longperiod
  • JVM调优总结 -Xms -Xmx -Xmn -Xss coder_xpf jvm应用服务器
    堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。 典型设置： java -Xmx
  • JDBC连接数据库 Array_06 jdbc
    package Util; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class JDBCUtil { //完
  • Unsupported major.minor version 51.0（jdk版本错误） oloz java
    java.lang.UnsupportedClassVersionError: cn/support/cache/CacheType : Unsupported major.minor version 51.0 (unable to load class cn.support.cache.CacheType) at org.apache.catalina.loader.WebappClassL
  • 用多个线程处理1个List集合 362217990 多线程threadlist集合
      昨天发了一个提问，启动5个线程将一个List中的内容，然后将5个线程的内容拼接起来，由于时间比较急迫，自己就写了一个Demo，希望对菜鸟有参考意义。。 import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; public c
  • JSP简单访问数据库 香水浓 sqlmysqljsp
    学习使用javaBean，代码很烂，仅为留个脚印 public class DBHelper { private String driverName; private String url; private String user; private String password; private Connection connection; privat
  • Flex4中使用组件添加柱状图、饼状图等图表 AdyZhang Flex
    1.添加一个最简单的柱状图 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 <?xml version= "1.0"&n
  • Android 5.0 - ProgressBar 进度条无法展示到按钮的前面 aijuans android
    在低于SDK < 21 的版本中，ProgressBar 可以展示到按钮前面，并且为之在按钮的中间，但是切换到android 5.0后进度条ProgressBar 展示顺序变化了，按钮再前面，ProgressBar 在后面了我的xml配置文件如下：   [html]  view plain copy   <RelativeLa
  • 查询汇总的sql baalwolf sql
    select   list.listname, list.createtime,listcount from dream_list as list ,   (select listid,count(listid) as listcount  from dream_list_user  group by listid  order by count(
  • Linux du命令和df命令区别 BigBird2012 linux
            1，两者区别             du，disk usage,是通过搜索文件来计算每个文件的大小然后累加，du能看到的文件只是一些当前存在的，没有被删除的。他计算的大小就是当前他认为存在的所有文件大小的累加和。        
  • AngularJS中的$apply，用还是不用？ bijian1013 JavaScriptAngularJS$apply
            在AngularJS开发中，何时应该调用$scope.$apply()，何时不应该调用。下面我们透彻地解释这个问题。         但是首先，让我们把$apply转换成一种简化的形式。         scope.$apply就像一个懒惰的工人。它需要按照命
  • [Zookeeper学习笔记十]Zookeeper源代码分析之ClientCnxn数据序列化和反序列化 bit1129 zookeeper
    ClientCnxn是Zookeeper客户端和Zookeeper服务器端进行通信和事件通知处理的主要类，它内部包含两个类，1. SendThread 2. EventThread， SendThread负责客户端和服务器端的数据通信，也包括事件信息的传输，EventThread主要在客户端回调注册的Watchers进行通知处理   ClientCnxn构造方法   &
  • 【Java命令一】jmap bit1129 Java命令
    jmap命令的用法：   [hadoop@hadoop sbin]$ jmap Usage: jmap [option] <pid> (to connect to running process) jmap [option] <executable <core> (to connect to a
  • Apache 服务器安全防护及实战 ronin47
    此文转自IBM. Apache 服务简介 Web 服务器也称为 WWW 服务器或 HTTP 服务器 (HTTP Server)，它是 Internet 上最常见也是使用最频繁的服务器之一，Web 服务器能够为用户提供网页浏览、论坛访问等等服务。 由于用户在通过 Web 浏览器访问信息资源的过程中，无须再关心一些技术性的细节，而且界面非常友好，因而 Web 在 Internet 上一推出就得到
  • unity 3d实例化位置出现布置？ brotherlamp unity教程unityunity资料unity视频unity自学
    问：unity 3d实例化位置出现布置？ 答：实例化的同时就可以指定被实例化的物体的位置,即 position  Instantiate (original : Object, position : Vector3, rotation : Quaternion) : Object 这样你不需要再用Transform.Position了,   如果你省略了第二个参数(
  • 《重构，改善现有代码的设计》第八章 Duplicate Observed Data bylijinnan java重构
    import java.awt.Color; import java.awt.Container; import java.awt.FlowLayout; import java.awt.Label; import java.awt.TextField; import java.awt.event.FocusAdapter; import java.awt.event.FocusE
  • struts2更改struts.xml配置目录 chiangfai struts.xml
    struts2默认是读取classes目录下的配置文件，要更改配置文件目录，比如放在WEB-INF下，路径应该写成../struts.xml(非/WEB-INF/struts.xml) web.xml文件修改如下：   <filter> <filter-name>struts2</filter-name> <filter-class&g
  • redis做缓存时的一点优化 chenchao051 redishadooppipeline
            最近集群上有个job，其中需要短时间内频繁访问缓存，大概7亿多次。我这边的缓存是使用redis来做的，问题就来了。       首先，redis中存的是普通kv，没有考虑使用hash等解结构，那么以为着这个job需要访问7亿多次redis，导致效率低，且出现很多redi
  • mysql导出数据不输出标题行 daizj mysql数据导出去掉第一行去掉标题
    当想使用数据库中的某些数据，想将其导入到文件中，而想去掉第一行的标题是可以加上-N参数 如通过下面命令导出数据： mysql -uuserName -ppasswd -hhost -Pport -Ddatabase -e " select * from tableName"  > exportResult.txt 结果为： studentid
  • phpexcel导出excel表简单入门示例 dcj3sjt126com PHPExcelphpexcel
    先下载PHPEXCEL类文件，放在class目录下面，然后新建一个index.php文件，内容如下 <?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE);   if (PHP_SAPI == 'cli') die('
  • 爱情格言 dcj3sjt126com 格言
     1) I love you not because of who you are, but because of who I am when I am with you. 　　 我爱你，不是因为你是一个怎样的人，而是因为我喜欢与你在一起时的感觉。 　　2) No man or woman is worth your tears, and the one who is, won‘t
  • 转 Activity 详解——Activity文档翻译 e200702084 androidUIsqlite配置管理网络应用
    activity 展现在用户面前的经常是全屏窗口，你也可以将 activity 作为浮动窗口来使用（使用设置了 windowIsFloating 的主题），或者嵌入到其他的 activity （使用 ActivityGroup ）中。 当用户离开 activity 时你可以在 onPause() 进行相应的操作 。更重要的是，用户做的任何改变都应该在该点上提交 ( 经常提交到 ContentPro
  • win7安装MongoDB服务 geeksun mongodb
    1.  下载MongoDB的windows版本：mongodb-win32-x86_64-2008plus-ssl-3.0.4.zip，Linux版本也在这里下载，下载地址： http://www.mongodb.org/downloads   2.  解压MongoDB在D:\server\mongodb, 在D:\server\mongodb下创建d
  • Javascript魔法方法:__defineGetter__,__defineSetter__ hongtoushizi js
    转载自： http://www.blackglory.me/javascript-magic-method-definegetter-definesetter/ 在javascript的类中,可以用defineGetter和defineSetter_控制成员变量的Get和Set行为 例如,在一个图书类中,我们自动为Book加上书名符号: function Book(name){
  • 错误的日期格式可能导致走nginx proxy cache时不能进行304响应 jinnianshilongnian cache
    昨天在整合某些系统的nginx配置时，出现了当使用nginx cache时无法返回304响应的情况，出问题的响应头： Content-Type:text/html; charset=gb2312 Date:Mon, 05 Jan 2015 01:58:05 GMT Expires:Mon , 05 Jan 15 02:03:00 GMT Last-Modified:Mon, 05
  • 数据源架构模式之行数据入口 home198979 PHP架构行数据入口
    注：看不懂的请勿踩，此文章非针对java，java爱好者可直接略过。   一、概念 行数据入口（Row Data Gateway）：充当数据源中单条记录入口的对象，每行一个实例。   二、简单实现行数据入口 为了方便理解，还是先简单实现： <?php /** * 行数据入口类 */ class OrderGateway { /*定义元数
  • Linux各个目录的作用及内容 pda158 linux脚本
    1）根目录“/” 　　根目录位于目录结构的最顶层，用斜线（/）表示，类似于 Windows 操作系统的“C:\“，包含Fedora操作系统中所有的目录和文件。 　　2）/bin 　　/bin 　　目录又称为二进制目录，包含了那些供系统管理员和普通用户使用的重要 linux命令的二进制映像。该目录存放的内容包括各种可执行文件，还有某些可执行文件的符号连接。常用的命令有：cp、d
  • ubuntu12.04上编译openjdk7 ol_beta HotSpotjvmjdkOpenJDK
    获取源码 从openjdk代码仓库获取(比较慢) 安装mercurial Mercurial是一个版本管理工具。 sudo apt-get install mercurial 将以下内容添加到$HOME/.hgrc文件中，如果没有则自己创建一个： [extensions] forest=/home/lichengwu/hgforest-crew/forest.py fe
  • 将数据库字段转换成设计文档所需的字段 vipbooks 设计模式工作正则表达式
            哈哈，出差这么久终于回来了，回家的感觉真好！         PowerDesigner的物理数据库一出来，设计文档中要改的字段就多得不计其数，如果要把PowerDesigner中的字段一个个Copy到设计文档中，那将会是一件非常痛苦的事情。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他