Broadcast使用分析

最新推荐文章于 2024-07-01 14:31:00 发布
转载 最新推荐文章于 2024-07-01 14:31:00 发布 · 597 阅读 · 0

本文深入探讨了Android系统中的广播机制，包括如何接收系统及自定义广播，以及不同注册方式（代码与XML）的优缺点。重点介绍了如何在发送广播时利用正常广播与粘性广播的区别，确保关键业务逻辑在应用启动前能够接收到广播通知。通过实例代码展示了如何在Activity和Service中注册并处理广播，以及如何在特定场景下有效利用粘性广播的特点。此外，文章还对比了代码注册与XML注册广播的方法，提供了在实际应用中选择注册方式的指导。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Broadcast（广播）是Android系统四大组件之一，Broadcast的主要作用是接收系统或者自定义的广播，并进行相关的处理工作。在广播中的操作时间不能太长，超过5s将被系统回收，造成ANR；如果需要在onReceive方法中做复杂的业务处理，最好的方法是开启一个线程来处理。

用法一：接收系统广播并进行相应的处理

接收广播的方式有两种：一是通过代码注册接收广播；二是通过xml配置的方式接收广播。

两种注册广播功能的区别：

代码注册的方式必须是该应用的进程已经启动，并且注册该广播的Activity或者Service等已经被实例化，才能接收该注册的广播；

xml配置注册广播则不需要以上的各种限制，只要系统发送了广播，就能接收到注册的广播。

在实际应用中，如果想要监听系统发出的广播，在接收到广播后做出相应的逻辑操作。如果选择代码方式注册广播，就会导致一系列问题，因为可能在系统发出广播的时候，该应用的进程并没有启动，导致应用接收不到广播，逻辑操作不能执行的问题。因此建议选择xml的方式注册广播。同时，如果大量使用XML注册广播，会降低系统性能，所以在选择广播注册方式时，应该根据具体业务需求，选择最适合的注册方式。

一、代码方式注册广播

（1）设置广播过滤器——需要接收的广播

[java] view plain copy print ?
  1. //系统发出Intent.ACTION_MEDIA_MOUNTED的时候注册了scheme 
  2. //因此在注册监听广播的时候IntentFilter必须添加相应的Scheme才能接收相应的广播  
  3. // 接收SDCard mount（安装）广播 
  4. IntentFilter mMountFilter= new IntentFilter(Intent.ACTION_MEDIA_MOUNTED); 
  5. //需要添加Scheme 
  6. mMountFilter.addDataScheme("file");  
//系统发出Intent.ACTION_MEDIA_MOUNTED的时候注册了scheme
//因此在注册监听广播的时候IntentFilter必须添加相应的Scheme才能接收相应的广播 
// 接收SDCard mount（安装）广播
IntentFilter mMountFilter= new IntentFilter(Intent.ACTION_MEDIA_MOUNTED);
//需要添加Scheme
mMountFilter.addDataScheme("file");

（2）声明广播接收器——注册广播信息

[java] view plain copy print ?
  1. // 注册广播监听 
  2. registerReceiver(mReceiver, mMountFilter);  
// 注册广播监听
registerReceiver(mReceiver, mMountFilter);

监听SDcard安装（Mounted）广播的具体代码如下（MainActivity.java）：

[java] view plain copy print ?
  1. package com.jony.broadcast; 
  2.  
  3. import android.os.Bundle; 
  4. import android.app.Activity; 
  5. import android.content.BroadcastReceiver; 
  6. import android.content.Context; 
  7. import android.content.Intent; 
  8. import android.content.IntentFilter; 
  9. import android.view.Menu; 
  10. import android.widget.Toast; 
  11.  
  12. public class MainActivity extends Activity { 
  13.     private IntentFilter mMountFilter = new IntentFilter(Intent.ACTION_MEDIA_MOUNTED); 
  14.      
  15.     private BroadcastReceiver mReceiver = new BroadcastReceiver() { 
  16.         @Override 
  17.         public void onReceive(Context context, Intent intent) { 
  18.             // do your logic 
  19.             System.out.println("SDcard is mounted"); 
  20.             Toast.makeText(MainActivity.this, "SDcard have mounted", Toast.LENGTH_LONG).show(); 
  21.         } 
  22.     }; 
  23.  
  24.     protected void onStart() { 
  25.         super.onStart(); 
  26.         //系统发出Intent.ACTION_MEDIA_MOUNTED的时候注册了scheme 
  27.         //因此在注册监听广播的时候IntentFilter必须添加相应的Scheme才能接收相应的广播  
  28.         mMountFilter.addDataScheme("file"); 
  29.         registerReceiver(mReceiver, mMountFilter);//注册广播监听 
  30.     }; 
  31.     @Override 
  32.     public void onCreate(Bundle savedInstanceState) { 
  33.         super.onCreate(savedInstanceState); 
  34.         setContentView(R.layout.activity_main); 
  35.     } 
  36.  
  37.     @Override 
  38.     protected void onResume() { 
  39.         super.onResume(); 
  40.     } 
  41.     @Override 
  42.     public boolean onCreateOptionsMenu(Menu menu) { 
  43.         getMenuInflater().inflate(R.menu.activity_main, menu); 
  44.         return true; 
  45.     } 
  46.  
  47.     @Override 
  48.     protected void onStop() { 
  49.         super.onStop(); 
  50.         unregisterReceiver(mReceiver);// 取消广播监听 
  51.     } 
  52. }  
package com.jony.broadcast;

import android.os.Bundle;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.view.Menu;
import android.widget.Toast;

public class MainActivity extends Activity {
    private IntentFilter mMountFilter = new IntentFilter(Intent.ACTION_MEDIA_MOUNTED);
    
    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            // do your logic
            System.out.println("SDcard is mounted");
            Toast.makeText(MainActivity.this, "SDcard have mounted", Toast.LENGTH_LONG).show();
        }
    };

    protected void onStart() {
        super.onStart();
        //系统发出Intent.ACTION_MEDIA_MOUNTED的时候注册了scheme
        //因此在注册监听广播的时候IntentFilter必须添加相应的Scheme才能接收相应的广播 
        mMountFilter.addDataScheme("file");
        registerReceiver(mReceiver, mMountFilter);//注册广播监听
    };
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    protected void onResume() {
        super.onResume();
    }
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }

    @Override
    protected void onStop() {
        super.onStop();
        unregisterReceiver(mReceiver);// 取消广播监听
    }
}

Manifest.xml文件比较简单，在此不再给出源码

二、XML方式注册广播

继承BroadcastReceiver类，实现onReceive方法——该方法中实现相应的业务逻辑即可

MyBroadcasrReceiver代码如下（MyBroadcasrReceiver.java）

[java] view plain copy print ?
  1. package com.jony.broadcast.broadcast_sticky_test; 
  2.  
  3. import android.content.BroadcastReceiver; 
  4. import android.content.Context; 
  5. import android.content.Intent; 
  6. import android.widget.Toast; 
  7.  
  8. public class MyBroadcasrReceiver extends BroadcastReceiver{ 
  9.  
  10.     @Override 
  11.     public void onReceive(Context context, Intent intent) { 
  12.         // do your logic 
  13.         System.out.println("BroadcasrReceiver is starting"); 
  14.         Toast.makeText(context, "BroadcasrReceiver is starting", Toast.LENGTH_LONG).show(); 
  15.     } 
  16.  
  17. }  
package com.jony.broadcast.broadcast_sticky_test;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;

public class MyBroadcasrReceiver extends BroadcastReceiver{

    @Override
    public void onReceive(Context context, Intent intent) {
        // do your logic
        System.out.println("BroadcasrReceiver is starting");
        Toast.makeText(context, "BroadcasrReceiver is starting", Toast.LENGTH_LONG).show();
    }

}

在XML中配置自定义BroadcastReceiver的action以及相应的data，在Mainfest中进行如下定义：

[java] view plain copy print ?
  1. <receiver android:name=".MyBroadcasrReceiver" android:label="@string/receiver"> 
  2.             <intent-filter> 
  3.                 <action android:name="com.jony.normalbroadcast"/> 
  4.                 <data android:scheme="file"/> 
  5.             </intent-filter> 
  6.             <intent-filter> 
  7.                 <action android:name="com.jony.stickybroadcast"/> 
  8.             </intent-filter> 
  9. </receiver>  
<receiver android:name=".MyBroadcasrReceiver" android:label="@string/receiver">
            <intent-filter>
                <action android:name="com.jony.normalbroadcast"/>
                <data android:scheme="file"/>
            </intent-filter>
            <intent-filter>
                <action android:name="com.jony.stickybroadcast"/>
            </intent-filter>
</receiver>

小节：以上两种接收广播的方式各有优点，具体选择哪种方式监听广播，需要更具业务需求，做出相应的选择。

用法二：接收自定义广播

首先通过继承BroadcastReceiver类，实现onReceive方法——该方法中实现相应的业务逻辑即可

MyBroadcasrReceiver代码如下（MyBroadcasrReceiver.java）

[java] view plain copy print ?
  1. package com.jony.broadcast.broadcast_sticky_test; 
  2.  
  3. import android.content.BroadcastReceiver; 
  4. import android.content.Context; 
  5. import android.content.Intent; 
  6. import android.widget.Toast; 
  7.  
  8.  
  9. public class MyBroadcasrReceiver extends BroadcastReceiver{ 
  10.  
  11.     @Override 
  12.     public void onReceive(Context context, Intent intent) { 
  13.         // do your logic 
  14.         System.out.println("BroadcasrReceiver is starting"); 
  15.         Toast.makeText(context, "BroadcasrReceiver is starting", Toast.LENGTH_LONG).show(); 
  16.     } 
  17.  
  18. }  
package com.jony.broadcast.broadcast_sticky_test;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;


public class MyBroadcasrReceiver extends BroadcastReceiver{

    @Override
    public void onReceive(Context context, Intent intent) {
        // do your logic
        System.out.println("BroadcasrReceiver is starting");
        Toast.makeText(context, "BroadcasrReceiver is starting", Toast.LENGTH_LONG).show();
    }

}

在XML中配置自定义BroadcastReceiver的action以及相应的data，在Mainfest中进行如下定义：

[java] view plain copy print ?
  1. <receiver android:name=".MyBroadcasrReceiver" android:label="@string/receiver"> 
  2.             <intent-filter> 
  3.                 <action android:name="com.jony.normalbroadcast"/> 
  4.                 <data android:scheme="file"/> 
  5.             </intent-filter> 
  6.             <intent-filter> 
  7.                 <action android:name="com.jony.stickybroadcast"/> 
  8.             </intent-filter> 
  9. </receiver>  
<receiver android:name=".MyBroadcasrReceiver" android:label="@string/receiver">
            <intent-filter>
                <action android:name="com.jony.normalbroadcast"/>
                <data android:scheme="file"/>
            </intent-filter>
            <intent-filter>
                <action android:name="com.jony.stickybroadcast"/>
            </intent-filter>
</receiver>

实现BroadcasrReceiver的子类并在Mainfest中进行了以上配置之后，接下来就是见证奇迹的时候了，看看我们怎样启动我们自定义的Broadcast吧……

启动广播的步骤大致可以分为两步：

第一步注册我们自定义的广播；

第二部发送相应的Action——即我们在Mainfest中配置<receiver>时设置的相应action

代码如下所示（MainActivity.java）：

[java] view plain copy print ?
  1. package com.jony.broadcast.broadcast_sticky_test; 
  2.  
  3. import android.os.Bundle; 
  4. import android.app.Activity; 
  5. import android.content.Intent; 
  6. import android.content.IntentFilter; 
  7. import android.view.Menu; 
  8.  
  9. public class MainActivity extends Activity { 
  10.     private IntentFilter mFilter; 
  11.     private MyBroadcasrReceiver mReceiver = new MyBroadcasrReceiver(); 
  12.  
  13.     @Override 
  14.     public void onCreate(Bundle savedInstanceState) { 
  15.         super.onCreate(savedInstanceState); 
  16.         setContentView(R.layout.activity_main); 
  17.         mFilter = new IntentFilter(); 
  18.         mFilter.addAction("com.jony.normalbroadcast"); 
  19.         // 注册广播 
  20.          registerReceiver(mReceiver, mFilter);// 在XML中进行广播注册 
  21.         Intent intent = new Intent("com.jony.stickybroadcast"); 
  22.         sendBroadcast(intent);// 发送广播 
  23.     } 
  24.  
  25.     @Override 
  26.     public boolean onCreateOptionsMenu(Menu menu) { 
  27.         getMenuInflater().inflate(R.menu.activity_main, menu); 
  28.         return true; 
  29.     } 
  30.  
  31.     @Override 
  32.     protected void onPause() { 
  33.         super.onPause(); 
  34.         unregisterReceiver(mReceiver); 
  35.     } 
  36. }  
package com.jony.broadcast.broadcast_sticky_test;

import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;
import android.content.IntentFilter;
import android.view.Menu;

public class MainActivity extends Activity {
    private IntentFilter mFilter;
    private MyBroadcasrReceiver mReceiver = new MyBroadcasrReceiver();

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mFilter = new IntentFilter();
        mFilter.addAction("com.jony.normalbroadcast");
        // 注册广播
         registerReceiver(mReceiver, mFilter);// 在XML中进行广播注册
        Intent intent = new Intent("com.jony.stickybroadcast");
        sendBroadcast(intent);// 发送广播
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }

    @Override
    protected void onPause() {
        super.onPause();
        unregisterReceiver(mReceiver);
    }
}
用法三：Normal Broadcast和Sticky Broadcast的区别用法

StickyBroadcast一般很少用到，但是千万不要忘记小人物也有大用处，所以请尊重身边的每一个人。闲话少说，直接切入正题，在使用代码注册广播（广播被嵌入到Activity中或者是Service中）时，当发送一个广播时，被嵌入的Activity或者Service还没有被启动时，发送的normal广播是接收不到的，这时只有发送sticky广播，在应用程序启动被嵌入广播的Activity或者Service时，会接收到stick广播，因此在这样的业务中stick广播就派上了用处。

举例说明：

在使用sticky广播时，需要在AndroidManifest.xml中赋予发送sticky广播的权限

[html] view plain copy print ?
  1. <uses-permission android:name="android.permission.BROADCAST_STICKY"/>  
<uses-permission android:name="android.permission.BROADCAST_STICKY"/>

首先在被嵌入的Activity中注册广播，具体代码如下（SecondActivity.java）：

[java] view plain copy print ?
  1. package com.jony.broadcast.broadcast_sticky_test; 
  2.  
  3. import android.app.Activity; 
  4. import android.content.BroadcastReceiver; 
  5. import android.content.Context; 
  6. import android.content.Intent; 
  7. import android.content.IntentFilter; 
  8. import android.os.Bundle; 
  9. import android.widget.Toast; 
  10.  
  11. public class SecondActivity extends Activity{ 
  12.     private IntentFilter filter; 
  13.     private BroadcastReceiver mReceiver = new BroadcastReceiver() { 
  14.         @Override 
  15.         public void onReceive(Context context, Intent intent) { 
  16.             Toast.makeText(context, intent.getAction(), Toast.LENGTH_LONG).show(); 
  17.         } 
  18.     }; 
  19.     protected void onResume() { 
  20.         super.onResume(); 
  21.     }; 
  22.     @Override 
  23.     protected void onCreate(Bundle savedInstanceState) { 
  24.         super.onCreate(savedInstanceState); 
  25.         setContentView(R.layout.second); 
  26.         filter = new IntentFilter(); 
  27.         filter.addAction("com.jony.normalbroadcast"); 
  28.         filter.addAction("com.jony.stickybroadcast"); 
  29.         registerReceiver(mReceiver, filter); 
  30.     } 
  31.     @Override 
  32.     protected void onPause() { 
  33.         super.onPause(); 
  34.         unregisterReceiver(mReceiver); 
  35.     } 
  36. }  
package com.jony.broadcast.broadcast_sticky_test;

import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.widget.Toast;

public class SecondActivity extends Activity{
    private IntentFilter filter;
    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Toast.makeText(context, intent.getAction(), Toast.LENGTH_LONG).show();
        }
    };
    protected void onResume() {
        super.onResume();
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.second);
        filter = new IntentFilter();
        filter.addAction("com.jony.normalbroadcast");
        filter.addAction("com.jony.stickybroadcast");
        registerReceiver(mReceiver, filter);
    }
    @Override
    protected void onPause() {
        super.onPause();
        unregisterReceiver(mReceiver);
    }
}

在MainActivity中发送广播，代码如下所示（MainActivity.java）：

[java] view plain copy print ?
  1. package com.jony.broadcast.broadcast_sticky_test; 
  2.  
  3. import android.os.Bundle; 
  4. import android.app.Activity; 
  5. import android.content.Intent; 
  6. import android.view.Menu; 
  7. import android.view.View; 
  8. import android.widget.Button; 
  9.  
  10. public class MainActivity extends Activity { 
  11.     private Button normal_button,sticky_button,launch_button; 
  12.     @Override 
  13.     public void onCreate(Bundle savedInstanceState) { 
  14.         super.onCreate(savedInstanceState); 
  15.         setContentView(R.layout.activity_main); 
  16.         init_data(); 
  17.         } 
  18.  
  19.     private void init_data() { 
  20.         normal_button = (Button) findViewById(R.id.send_normal_broadcast); 
  21.         sticky_button = (Button) findViewById(R.id.send_sticky_broadcast); 
  22.         launch_button = (Button) findViewById(R.id.receive_broadcast); 
  23.  
  24.         normal_button.setOnClickListener(new Button.OnClickListener() { 
  25.             @Override 
  26.             public void onClick(View v) { 
  27.                 Intent intent = new Intent("com.jony.normalbroadcast"); 
  28.                 sendBroadcast(intent); 
  29.             } 
  30.         }); 
  31.         sticky_button.setOnClickListener(new Button.OnClickListener() { 
  32.             @Override 
  33.             public void onClick(View v) { 
  34.                 Intent intent = new Intent(); 
  35.                 intent.setAction("com.jony.stickybroadcast"); 
  36.                 sendStickyBroadcast(intent); 
  37.             } 
  38.         }); 
  39.         launch_button.setOnClickListener(new Button.OnClickListener() { 
  40.             @Override 
  41.             public void onClick(View v) { 
  42.                 Intent intent = new Intent(getApplicationContext(), SecondActivity.class); 
  43.                 startActivity(intent); 
  44.             } 
  45.         }); 
  46.     } 
  47.  
  48.     @Override 
  49.     public boolean onCreateOptionsMenu(Menu menu) { 
  50.         getMenuInflater().inflate(R.menu.activity_main, menu); 
  51.         return true; 
  52.     } 
  53.  
  54.     @Override 
  55.     protected void onPause() { 
  56.         super.onPause(); 
  57.     } 
  58. }  
package com.jony.broadcast.broadcast_sticky_test;

import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;
import android.view.Menu;
import android.view.View;
import android.widget.Button;

public class MainActivity extends Activity {
    private Button normal_button,sticky_button,launch_button;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init_data();
        }

    private void init_data() {
        normal_button = (Button) findViewById(R.id.send_normal_broadcast);
        sticky_button = (Button) findViewById(R.id.send_sticky_broadcast);
        launch_button = (Button) findViewById(R.id.receive_broadcast);

        normal_button.setOnClickListener(new Button.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent("com.jony.normalbroadcast");
                sendBroadcast(intent);
            }
        });
        sticky_button.setOnClickListener(new Button.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent();
                intent.setAction("com.jony.stickybroadcast");
                sendStickyBroadcast(intent);
            }
        });
        launch_button.setOnClickListener(new Button.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(getApplicationContext(), SecondActivity.class);
                startActivity(intent);
            }
        });
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }

    @Override
    protected void onPause() {
        super.onPause();
    }
}

布局文件和Manifest配置文件都比较简单，在此不再给出。
最后，见证奇迹的时刻就交给大家了……

Android 10.0 Broadcast发送广播造成anr的原理分析
安卓兼职framework和app工程师的博客
12-02 727
在10.0的系统rom开发中，在关于framework中对Broadcast发送的相关anr流程分析，然后来 解决相关的功能性问题，首选根据流程分析Broadcast发送过程，然后看下埋雷排雷的 过程分析
collocate join，bucket join，broadcast join，shuffle join对比分析
最新发布
JustinMars的博客
09-12 481
在实际应用中，根据数据规模、Join 类型和系统的性能需求，选择合适的 Join 策略非常关键。一般情况下，优先使用 Broadcast Join 进行小表与大表的 Join，如果数据已被分桶则选择 Bucket Join，Collocate Join 适用于提前计划好分区策略的场景，Shuffle Join 则作为通用方案用于无法优化的情况。
Numpy中的广播Broadcast用法
fendyu的博客
04-16 2730
广播仅仅是一组用于在不同大小的数组上应用二元ufuncs(加法、减法、乘法等)的规则。对于相同大小的数组，二元操作按元素逐元素执行。In[1]: import numpy as np In[2]: a = np.array([0, 1, 2]) b = np.array([5, 5, 5]) a + b Out[2]: array([5, 6, 7])广播允许在不同大小的数组上执行这些类型的二元操...
Broadcast 分析 --- 之二
Jack的博客
08-21 559
3,发送广播 对应不同的广播,发送方法如下: public void sendBroadcast(Intent intent, String receiverPermission) public void sendOrderedBroadcast(Intent intent, String receiverPermission) public void sendStickyBroadcas
Broadcast 分析 --- 之一
Jack的博客
10-21 1546
1, 基本概念 广播(Broadcast):顾名思义,就是一处发生事情,多处得到通知后分别进行处理。和观察者模式有相似之处。一般Activity发送广播。   1.1  receiver receiver接收广播,还分为动态和静态两种。动态receiver是在运行期通过调用registerReceiver()注册的，而静态receiver则是在AndroidManifest.xml中声明的
Broadcast的用法
Raleigh
07-15 1005
在Android 中使用Activity, Service, Broadcast, BroadcastReceiver 活动(Activity)- 用于表现功能 服务(Service)- 相当于后台运行的Activity 广播(Broadcast)- 用于发送广播 广播接收器(BroadcastReceiver)- 用于接收广播 Intent - 用于连接以上各个组件，并在其间传递消息
Android源码 --- BroadCast源码分析
u014720866的博客
02-25 2740
Android源码 BroadCas源码分析
Android如何分析处理dumpsys_broadcast文件
07-01 612
是 Android 系统提供的一个命令行工具，用于获取系统服务的信息。当与广播（Broadcast）相关的服务被查询时，你可能会得到一个包含大量信息的输出，这通常被称为。文件（尽管实际上它可能只是一个命令行的输出，而不是一个文件）。
spark源码分析之Broadcast
进击的数据小白
09-27 1162
Broadcast简介&使用 在Spark程序中，经常会遇到算子函数中使用较大的外部变量的场景。由于在算子函数中使用到外部变量时，默认情况下，Spark会将该变量复制多个副本，通过网络传输到task中，此时每个task都有一个变量副本。如果变量本身比较大的话[比如100M，甚至1G]，那么大量的变量副本在网络中传输的性能开销，以及在各个节点的Executor中占用过多内存导致的频繁GC，都会极大地影响性能。因此对于上述情况，如果使用的外部变量比较大，Spark提供的广播功能，对该变量进行广播，会提升
BroadCast 研究分析
幻想世界
12-23 790
最近有些人对android的Broadcast机制颇有兴趣,因此小弟就把自己看到的背后原理跟各位分享.Android的发送广播跟接收机制其实就是一种Publish/subscribepattern, Publish(发布者)只会将不同类型的讯息传送出去,并不会在意subscribe(订阅者),而subscribe(订阅者)只在意想接收的讯息,并不会在意谁是Publish(发布者). 所以Andro
【Android】广播机制 Broadcast
Ops
06-03 375
安卓广播分为标准广播和有序广播 标准广播：是一种完全异步执行的广播 广播发出后 所有的广播接收器都会统一时刻接收到这条广播消息 没有任何先后顺序可言 这种传播的效率比较高 同时无法截断 有序广播：是一种同步执行的广播 同一时刻只会有一个广播接收器接收到这条广播消息按照优先级传递 可以截断 广播注册有两种方式 一种是动态注册（在代码中注册） 一种是静态注册（在AndroidManife
Broadcast的简单使用
黄大大的博客
04-21 912
Android 中的广播Broadcast和生活中的广播一样，有发广播和接收广播的，通过静态注册和动态注册两种方式可以对广播接收器进行注册，然后才能接收广播，一人发送广播，多人接收广播，也存在有序广播和无序广播 对于广播发送者来说，广播发送不需要考虑接收者的状态，只负责把广播发送出去即可，而对于哪个应用或者哪个进程接收广播不做关心，可以为广播接收者设置接收的优先级。 对于广播接收者来说，会受到各式...
Android 四大组件之三 Broadcast
程序员Android
09-15 284
Broadcast 是 Android 四大组件之一，是一种广泛运用在应用程序之间异步传输信息的机制。Broadcast 本质上是一个Intent 对象，差别在于 Bro...
广播的使用
小周郎的博客
08-22 196
public BroadcastReceiver payStateReceiver1 = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { Log.e("ClassFragment", "onReceive:"+"广播广播刷新");...
浅谈BroadcastReceiver的用法
Smile_Qian的博客
08-15 257
转自：http://www.cnblogs.com/shang53880/archive/2011/02/14/1954420.html 记录一下，以备后用。 最近看了下关于广播方面的东西，加深了理解，也纠正了自己以前的不正确的看法。 关于广播有2中注册方式，一种是在代码中注册，也叫动态注册，另一种是在AndroidManifest里面注册，也叫静态注册。 不管在哪个里面注册，都需要发送广...
BroadCast简单使用
lingyuntang的博客
08-01 585
???????BroadcastReceiver public class MyBroadCast extends BroadcastReceiver { public void onReceive(Context context, Intent intent) { String str = intent.getStringExtra("name");
Spark Broadcast
止鱼
09-05 1748
顾名思义，broadcast 就是将数据从一个节点发送到其他各个节点上去。这样的场景很多，比如 driver 上有一张表，其他节点上运行的 task 需要 lookup 这张表，那么 driver 可以先把这张表 copy 到这些节点，这样 task 就可以在本地查表了。如何实现一个可靠高效的 broadcast 机制是一个有挑战性的问题。先看看 Spark 官网上的一段话： Broadc...
Android的广播功能Broadcast的应用
Sugar_tea的专栏
09-17 833
当我们在接收短信和电话时
Android broadcast机制源码分析
资源摘要信息:"Android...通过学习和分析这些源代码，开发者可以更好地掌握如何在实际应用中设计和实现广播接收器，以及如何处理各种广播消息。这些知识对于开发高效、响应迅速且具有良好交互性的Android应用至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值