我今天分享的主题是 Android 上低功耗蓝牙的实践。这个主题比较小众。我在过去的一年多的时间里,主要是在做低功耗蓝牙相关的开发。接触过程中发现,BLE 的开发和通常的 Android APP 的开发有点不一样,这里需要访问硬件资源,而且涉及到一些协议相关的内容,而且这方面的资料也比较少。今天我从 Android 开发者的角度,来分享一下低功耗蓝牙开发实践。Slide 02今天分享的内容,主要包            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-28 23:42:08
                            
                                135阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            背景介绍我们在Android开发过程中,几乎都离不开线程。但是你对线程的了解有多少呢?它完美运行的背后,究竟隐藏了多少不为人知的秘密呢?线程间互通暗语,传递信息究竟是如何做到的呢?Looper、Handler、MessageQueue究竟在这背后进行了怎样的运作。本期,让我们一起从Thread开始,逐步探寻这个完美的线程链背后的秘密。注意,大部分分析在代码中,所以请仔细关注代码哦!从Tread的创            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-07-01 20:37:54
                            
                                143阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            服务是在后台运行,负责更新内容提供器、发出意图、触发通知,它们是执行持续或定时处理的方式。多线程一般捆绑服务执行任务,因为在activity中开辟多线程执行任务的话,子线程的生命周期得不到保障,可能在应用进入后台时(进入后台后子线程仍会继续执行),activity被释放时同时被释放,而service在进入后台后仍有优先级存在,所以让子线程捆绑它执行,来保障子线程能执行完全。而在servcie的on            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-07-24 23:21:23
                            
                                50阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            多线程一直是初学者最抵触的东西,如果你想进阶的话,那必须闯过这道难关,特别是多线程中Thread、Runnable、Callable、Future、FutureTask这几个类往往是初学者容易搞混的。这里先总结这几个类特点和区别,让大家带着模糊印象来学习这篇文章1. Thread、Runnable、Callable:都是线程
2. Thread特点:提供了线程等待、线程睡眠、线程礼让等操作
3.            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-10-25 23:59:21
                            
                                11阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            一、多线程1.1      Thread类该如何创建线程呢?通过API中搜索,查到Thread类。通过阅读Thread类中的描述。Thread是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。  构造方法常用方法 继续阅读,发现创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-02-20 12:02:52
                            
                                570阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            Android 多线程之实现 runnable 接口            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-05-27 15:20:12
                            
                                153阅读
                            
                                                        
                                点赞
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            # 学习如何获取 Android 中的 Runnable 线程信息
在 Android 开发中,以多线程的方式完成一些任务是常见的需求。而 `Runnable` 接口是实现线程的一个简单方法。本文将指导你如何在 Android 中获取 `Runnable` 线程的信息,包括创建线程、运行它,并获取其状态信息。
## 整体流程
以下是我们需要完成的任务的步骤概述:
| 步骤     | 描述            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2024-08-05 07:47:58
                            
                                62阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            一:启动线程1.1:继承Thread类新建一个类继承自Thread,然后重写父类的 run() 方法:public class CustomThread extends Thread{
    @Override
    public void run() {
        // 耗时逻辑
    }
}启动线程:new CustomThread ().start();1.2:实现 Runnab            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-07-25 23:48:08
                            
                                89阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            一、Thread VS Runnable  在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口;Thread类和Runnable接口都是在java.lang包中定义的。接下来本文给大家介绍下Java中Runnable和Thread的区别,当然啦,也算做是我整理的学习笔记吧,一起看看吧 实现Runnable接口方式可以避免继承Thread方式由于Java单继            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-07-17 12:30:55
                            
                                112阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            1 线程池的优势总体来说,线程池有如下的优势:(1)降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。(2)提高响应速度。当任务到达时,任务可以不需要等到线程创建就能立即执行。(3)提高线程的可管理性。线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。2 线程池的使用线程池的真正实现类是 ThreadPoolEx            
                
         
            
            
            
            Service既不是进程也不是线程,它们之间的关系如下:       可能有的朋友会问了,既然是长耗时的操作,那么Thread也可以完成啊。没错,在程序里面很多耗时工作我们也可以通过Thread来完成,那么还需要Service干嘛呢。接下来就为大家解释以下Service和Thread的区别。      首先要            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-07-18 13:19:57
                            
                                29阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            ## Kotlin Android Runnable 实现多线程
在 Android 开发中,我们经常需要使用多线程来执行一些耗时的操作,以保证 UI 界面的流畅性和响应性。而在 Kotlin 中,可以通过 `Runnable` 接口来创建并执行多线程任务。
### 什么是多线程?
多线程是指在一个进程中同时执行多个线程,每个线程都在独立的执行路径上执行。相比于单线程,多线程能够更高效地利用            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-12-03 11:19:57
                            
                                446阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Android中子线程和UI线程之间通信的详细解释 1.在多线程编程这块,我们经常要使用Handler,Thread和Runnable这三个类,那么他们之间的关系你是否弄清楚了呢?下面详解一下。 2.首先在开发Android应用时必须遵守单线程模型的原则: Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。 3.Handler: (1).概念:  Handler是沟通Act            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-16 13:35:09
                            
                                81阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Android 中线程可分为主线程和子线程两类,其中主线程也就是UI线程,它的主要这作用就是运行四大组件、处理界面交互。子线程则主要是处理耗时任务,也是我们要重点分析的。首先 Java 中的各种线程在 Android 里是通用的,Android 特有的线程形态也是基于 Java 的实现的,所以有必要先简单的了解下 Java 中的线程,本文主要包括以下内容:Thread、RunnableCallab            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-30 19:45:05
                            
                                74阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            public class Test {public static void main(String[] args) {Thread t3 = new Thread(new TestRunnable(),“t-1”); //参数二设置线程名称t3.start();System.out.println("-----------------1----------------------");System.out.println("-----------------2-------------------            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2021-06-10 22:45:20
                            
                                395阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            【需求】当主线程需要用到子线程的执行结果,即主线程需要等子线程执行完毕之后继续运行,这时候应该如何处理?【解决方法】1. Sleep,轮询机制or Notify子线程启动后,主线程进入wait状态,等待notify;或主线程轮询查询有多少子线程在运行,若为零,则结束轮询,继续运行。public void run() {  
        System.out.println("---------            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-16 16:55:58
                            
                                165阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            public class Test {public static void main(String[] args) {Thread t3 = new Thread(new TestRunnable(),“t-1”); //参数二设置线程名称t3.start();System.out.println("-----------------1----------------------");System.out.println("-----------------2-------------------            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2021-06-10 22:46:40
                            
                                130阅读
                            
                                                                             
                 
                
                             
         
            
            
            
               最近又鼓捣jvm,然后结合着VisualVM监控、jvm的书,对jvm又有一些理解体会,今天主要聊聊jvm的线程模型,内存模型,以及跟开发比较相关的GC。    线程模型,jvm的线程就对应os的线程,据说linux的kernel3.x之后,也出现了OS内核线程支持,之前实现是轻量级进程,比如你线程搞多了,或者kernel内存留少了,unable            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-09-08 07:39:39
                            
                                32阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
             1.使用全局变量(窗体不适用)     实现线程间通信的方法有很多,常用的主要是通过全局变量、自定义消息和事件对象等来实现的。其中又以对全局变量的使用最为简洁。该方法将全局变量作为线程监视的对象,并通过在主线程对此变量值的改变而实现对子线程的控制。     由于这里的全局变量需要在使用它的线程之外对其值进行            
                
         
            
            
            
                    当Android程序涉及到网络使用时,往往会出现延迟,即如登录,下载的时候,程序员一般会在这时设计进度条,以免用户以为程序死机,那么这时网络数据处理和进度条需要同时执行,属于多线程,同时,网络数据的情况又要反馈给进度条使用,这就需要线程之间的通信。        简单的说,我们创建一个新线程去联网,将得            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-28 15:56:37
                            
                                259阅读
                            
                                                                             
                 
                
                                
                    