Intent intent =new Intent();
intent.setAction("com.example.broadcast.MY_BROADCAST1");
sendBroadcast(intent);

Intent intent =new Intent();
intent.setAction("com.example.broadcast.MY_BROADCAST1");
sendOrderedBroadcast(intent,null);

public class MainActivity extends AppCompatActivity {

    private IntentFilter intentFilter;
    private MyReceiver myReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
		//......

        //定义过滤器，想要监听什么广播，就添加相应的Action
        intentFilter = new IntentFilter();
        intentFilter.addAction("com.example.broadcast.MY_BROADCAST");
        intentFilter.setPriority(10);

        //定义广播处理类
        myReceiver = new MyReceiver();
        //注册本地广播监听器
        registerReceiver(myReceiver, intentFilter);
    }
	//......
}

sendBroadcast(intent,null);
或
sendOrderedBroadcast(intent,null);

public class MyReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        Toast.makeText(context,"收到广播", Toast.LENGTH_SHORT).show();
        Log.d("BroadcastReceiver","The Broadcast received");
        abortBroadcast();
    }
}

// How long we allow a receiver to run before giving up on it.
static final int BROADCAST_FG_TIMEOUT = 10*1000;
static final int BROADCAST_BG_TIMEOUT = 60*1000;

public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
    //...
    // Broadcast policy parameters
    final BroadcastConstants foreConstants = new BroadcastConstants(
            Settings.Global.BROADCAST_FG_CONSTANTS);
    foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;

    final BroadcastConstants backConstants = new BroadcastConstants(
            Settings.Global.BROADCAST_BG_CONSTANTS);
    backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;

    final BroadcastConstants offloadConstants = new BroadcastConstants(
            Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);
    offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
    // by default, no "slow" policy in this queue
    offloadConstants.SLOW_TIME = Integer.MAX_VALUE;

    mEnableOffloadQueue = SystemProperties.getBoolean(
            "persist.device_config.activity_manager_native_boot.offload_queue_enabled", false);

    mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
            "foreground", foreConstants, false);
    mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
            "background", backConstants, true);
    mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
            "offload", offloadConstants, true);
    //...
}

Intent intent = new Intent();
intent.setAction("com.example.broadcast.ACTION1");
sendBroadcast(intent);		//无序广播
sendOrderedBroadcast(intent, null);	//有序广播

Intent intent = new Intent();
intent.setAction("com.example.broadcast.ACTION1");
intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
sendBroadcast(intent);

// Broadcast policy parameters
final BroadcastConstants foreConstants = new BroadcastConstants(
        Settings.Global.BROADCAST_FG_CONSTANTS);
foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;  // 10s

final BroadcastConstants backConstants = new BroadcastConstants(
        Settings.Global.BROADCAST_BG_CONSTANTS);
backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;  // 60s

Intent intent =new Intent();
intent.setAction("com.example.broadcast.ACTION1");
intent.setComponent(new ComponentName("com.demoapp.broadcastreceiver",
        "com.demoapp.broadcastreceiver.MyReceiver"));
sendBroadcast(intent);

Intent intent =new Intent();
intent.setAction("com.example.broadcast.ACTION1");
sendBroadcast(intent);

Intent intent =new Intent();
intent.setAction("com.example.broadcast.MY_BROADCAST");
intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
sendBroadcast(intent);

<receiver
    android:name=".MyReceiver"
    android:enabled="true"
    android:exported="true">

    <intent-filter
        android:priority="10">
        <action android:name="com.example.broadcast.MY_BROADCAST"/>
    </intent-filter>

//定义过滤器，想要监听什么广播，就添加相应的Action
intentFilter = new IntentFilter();
intentFilter.addAction("com.example.broadcast.MY_BROADCAST");
//设置优先级
intentFilter.setPriority(10);
//定义广播处理类
myReceiver = new MyReceiver();
//注册广播监听器
registerReceiver(myReceiver, intentFilter);

private IntentFilter intentFilter;
private MyReceiver myReceiver;

//定义广播处理类
myReceiver = new MyReceiver();
//定义过滤器，想要监听什么广播，就添加相应的Action
intentFilter = new IntentFilter();
intentFilter.addAction("com.example.broadcast.MY_BROADCAST");
intentFilter.addAction("com.example.broadcast.MY_BROADCAST2");
//注册广播监听器
registerReceiver(myReceiver, intentFilter);

intentFilter = new IntentFilter();
intentFilter.addAction("com.example.broadcast.MY_BROADCAST");
registerReceiver(myReceiver, intentFilter);

intentFilter2 = new IntentFilter();
intentFilter2.addAction("com.example.broadcast.MY_BROADCAST2");
registerReceiver(myReceiver, intentFilter2);

public class MyReceiver extends BroadcastReceiver {
    String myAction1="com.example.broadcast.MY_BROADCAST";
    String myAction2="com.example.broadcast.MY_BROADCAST2";
    @Override
    public void onReceive(Context context, Intent intent) {
        String action=intent.getAction();

        if(myAction1.equals(action)){
            Toast.makeText(context,"收到广播1", Toast.LENGTH_SHORT).show();
            Log.d("BroadcastReceiver","The Broadcast received");
        }else if(myAction2.equals(action)){
            Toast.makeText(context,"收到广播2", Toast.LENGTH_SHORT).show();
        }
    }
}

final class BroadcastRecord extends Binder {
    final Intent intent;    // the original intent that generated us
    final ComponentName targetComp; // original component name set on the intent
    final ProcessRecord callerApp; // process that sent this
    final String callerPackage; // who sent this
    final @Nullable String callerFeatureId; // which feature in the package sent this
    final int callingPid;   // the pid of who sent this
    final int callingUid;   // the uid of who sent this
    final boolean callerInstantApp; // caller is an Instant App?
    final boolean ordered;  // serialize the send to receivers?
    final boolean sticky;   // originated from existing sticky data?
    final boolean initialSticky; // initial broadcast from register to sticky?
    final int userId;       // user id this broadcast was for
    final String resolvedType; // the resolved data type
    final String[] requiredPermissions; // permissions the caller has required
    final int appOp;        // an app op that is associated with this broadcast
    final BroadcastOptions options; // BroadcastOptions supplied by caller
    final List receivers;   // contains BroadcastFilter and ResolveInfo
    final int[] delivery;   // delivery state of each receiver
    final long[] duration;   // duration a receiver took to process broadcast
    IIntentReceiver resultTo; // who receives final result if non-null
    boolean deferred;
    int splitCount;         // refcount for result callback, when split
    int splitToken;         // identifier for cross-BroadcastRecord refcount
    long enqueueClockTime;  // the clock time the broadcast was enqueued
    long dispatchTime;      // when dispatch started on this set of receivers
    long dispatchClockTime; // the clock time the dispatch started
    long receiverTime;      // when current receiver started for timeouts.
    long finishTime;        // when we finished the broadcast.
    boolean timeoutExempt;  // true if this broadcast is not subject to receiver timeouts
    int resultCode;         // current result code value.
    String resultData;      // current result data value.
    Bundle resultExtras;    // current result extra data values.
    boolean resultAbort;    // current result abortBroadcast value.
    int nextReceiver;       // next receiver to be executed.
    IBinder receiver;       // who is currently running, null if none.
    int state;
    int anrCount;           // has this broadcast record hit any ANRs?
    int manifestCount;      // number of manifest receivers dispatched.
    int manifestSkipCount;  // number of manifest receivers skipped.
    BroadcastQueue queue;   // the outbound queue handling this broadcast

    // if set to true, app's process will be temporarily whitelisted to start activities
    // from background for the duration of the broadcast dispatch
    final boolean allowBackgroundActivityStarts;

    static final int IDLE = 0;
    static final int APP_RECEIVE = 1;
    static final int CALL_IN_RECEIVE = 2;
    static final int CALL_DONE_RECEIVE = 3;
    static final int WAITING_SERVICES = 4;

    static final int DELIVERY_PENDING = 0;
    static final int DELIVERY_DELIVERED = 1;
    static final int DELIVERY_SKIPPED = 2;
    static final int DELIVERY_TIMEOUT = 3;

    // The following are set when we are calling a receiver (one that
    // was found in our list of registered receivers).
    BroadcastFilter curFilter;

    // The following are set only when we are launching a receiver (one
    // that was found by querying the package manager).
    ProcessRecord curApp;       // hosting application of current receiver.
    ComponentName curComponent; // the receiver class that is currently running.
    ActivityInfo curReceiver;   // info about the receiver that is currently running.

    // Private refcount-management bookkeeping; start > 0
    static AtomicInteger sNextToken = new AtomicInteger(1);
    //......
}

registerReceiver(receiver, intentFilter);

BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage, callerFeatureId,
         permission, callingUid, userId, instantApp, visibleToInstantApps);

final class BroadcastFilter extends IntentFilter {
    // Back-pointer to the list this filter is in.
    final ReceiverList receiverList;
    final String packageName;
    final String featureId;
    final String requiredPermission;
    final int owningUid;
    final int owningUserId;
    final boolean instantApp;
    final boolean visibleToInstantApp;

    BroadcastFilter(IntentFilter _filter, ReceiverList _receiverList,
            String _packageName, String _featureId, String _requiredPermission, int _owningUid, int _userId,
            boolean _instantApp, boolean _visibleToInstantApp) {
        super(_filter);
        receiverList = _receiverList;
        packageName = _packageName;
        featureId = _featureId;
        requiredPermission = _requiredPermission;
        owningUid = _owningUid;
        owningUserId = _userId;
        instantApp = _instantApp;
        visibleToInstantApp = _visibleToInstantApp;
    }
    public void dumpDebug(ProtoOutputStream proto, long fieldId) {......}
    public void dump(PrintWriter pw, String prefix) {......}
    public void dumpBrief(PrintWriter pw, String prefix) {......}
    public void dumpInReceiverList(PrintWriter pw, Printer pr, String prefix) {......}
    void dumpBroadcastFilterState(PrintWriter pw, String prefix) {......}
    public String toString() {......}
}

public class IntentFilter implements Parcelable {......}

public Intent registerReceiverWithFeature(IApplicationThread caller, String callerPackage,
        String callerFeatureId, IIntentReceiver receiver, IntentFilter filter,
        String permission, int userId, int flags) {
  //...
    BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage, callerFeatureId,
            permission, callingUid, userId, instantApp, visibleToInstantApps);
}

public String toString() {
    if (stringName != null) {
        return stringName;
    }
    StringBuilder sb = new StringBuilder(128);
    sb.append("ReceiverList{");
    sb.append(Integer.toHexString(System.identityHashCode(this)));
    sb.append(' ');
    sb.append(pid);
    sb.append(' ');
    sb.append((app != null ? app.processName : "(unknown name)"));
    sb.append('/');
    sb.append(uid);
    sb.append("/u");
    sb.append(userId);
    sb.append((receiver.asBinder() instanceof Binder) ? " local:" : " remote:");
    sb.append(Integer.toHexString(System.identityHashCode(receiver.asBinder())));
    sb.append('}');
    return stringName = sb.toString();
}

public class ResolveInfo implements Parcelable {
    //......
    public void dump(Printer pw, String prefix) {...}
    public void dump(Printer pw, String prefix, int dumpFlags) {...}
    public ResolveInfo() {
        targetUserId = UserHandle.USER_CURRENT;
    }

    public ResolveInfo(ResolveInfo orig) {
        activityInfo = orig.activityInfo;
        serviceInfo = orig.serviceInfo;
        providerInfo = orig.providerInfo;
        filter = orig.filter;
        priority = orig.priority;
        preferredOrder = orig.preferredOrder;
        match = orig.match;
        specificIndex = orig.specificIndex;
        labelRes = orig.labelRes;
        nonLocalizedLabel = orig.nonLocalizedLabel;
        icon = orig.icon;
        resolvePackageName = orig.resolvePackageName;
        noResourceId = orig.noResourceId;
        iconResourceId = orig.iconResourceId;
        system = orig.system;
        targetUserId = orig.targetUserId;
        handleAllWebDataURI = orig.handleAllWebDataURI;
        isInstantAppAvailable = orig.isInstantAppAvailable;
    }
    public String toString() {...}
    public void writeToParcel(Parcel dest, int parcelableFlags) {...}
    private ResolveInfo(Parcel source) {...}
    public static class DisplayNameComparator implements Comparator<ResolveInfo> {...}
}

rd = new LoadedApk.ReceiverDispatcher(
           receiver, context, scheduler, null, true).getIIntentReceiver()

/**
 * A receiver object that has registered for one or more broadcasts.
 * The ArrayList holds BroadcastFilter objects.
 */
final class ReceiverList extends ArrayList<BroadcastFilter>
        implements IBinder.DeathRecipient {
    final ActivityManagerService owner;
    public final IIntentReceiver receiver;
    public final ProcessRecord app;
    public final int pid;
    public final int uid;
    public final int userId;
    BroadcastRecord curBroadcast = null;
    boolean linkedToDeath = false;

    String stringName;

    ReceiverList(ActivityManagerService _owner, ProcessRecord _app,
            int _pid, int _uid, int _userId, IIntentReceiver _receiver) {
        owner = _owner;
        receiver = _receiver;
        app = _app;
        pid = _pid;
        uid = _uid;
        userId = _userId;
    }

    public boolean equals(Object o) {...}
    public int hashCode() {...}
    public void binderDied() {...}
    public boolean containsFilter(IntentFilter filter) {...}
    void dumpDebug(ProtoOutputStream proto, long fieldId) {...}
    void dumpLocal(PrintWriter pw, String prefix) {...}
    void dump(PrintWriter pw, String prefix) {...}
    public String toString() {...}
}

//定义广播处理类
MyReceiver myReceiver1 = new MyReceiver();

intentFilter1 = new IntentFilter();  //定义过滤器，想要监听什么广播，就添加相应的Action
intentFilter1.addAction("com.example.broadcast.MY_BROADCAST1");
registerReceiver(myReceiver1, intentFilter1);  //注册广播监听器

intentFilter2 = new IntentFilter();
intentFilter2.addAction("com.example.broadcast.MY_BROADCAST2");
registerReceiver(myReceiver1, intentFilter1);