精华内容
下载资源
问答
  • 异步消息机制

    2016-10-18 12:16:46
    4)android中两个子线程相互交互同样可以通过Handler的异步消息机制实现,可以在线程a中定义Handler对象,而在线程b中获取handler的引用并调用sendMessage方法。 5)activity内部默认存在一个handler的成员变量...

    1.  一个线程里面只有一个Looper。

    2. 子线程也可创建handler。

    前后需分别加上Looper.prepare();和Looper.loop();

    标准写法:

    Looper.prepare();

    Handler mHandler = new Handler() {

    @Override

    publicvoidhandleMessage(Message msg) {

    if (msg.what == 10000) {

    Log.i(TAG,"在子线程中定义Handler,并接收到消息。。。");

    }

    }};

    Looper.loop();

    prepare 中创建looper。

    3. 主线程对应的方法在ActivityThread的main方法中。

    4. Looper的构造方法中初始化了一个MessageQueue对象

    privateLooper(boolean quitAllowed) {

    mQueue = new MessageQueue(quitAllowed);

    mThread = Thread.currentThread();

    }

    总:Looper.prepare()方法初始话了一个Looper对象并关联在一个MessageQueue对象,并且一个线程中只有一个Looper对象,只有一个MessageQueue对象。而Handler的构造方法则在Handler内部维护了当前线程的Looper对象

    5. handler.sendMessage(msg) 会调用queue.enqueueMessage(msg, uptimeMillis);,会发现 MessageQueue并没有使用列表将所有的Message保存起来,而是使用Message.next保存下一个Message,从而按照时间将所有的Message排序;

    6. Looper.loop()

    可以看到Looper.loop()方法里起了一个死循环,不断的判断MessageQueue中的消息是否为空,如果为空则直接return掉,然后执行queue.next()方法

    可以看到其大概的实现逻辑就是Message的出栈操作,里面可能对线程,并发控制做了一些限制等。获取到栈顶的Message对象之后开始执行:

    msg.target.dispatchMessage(msg);

    Handle的dispatchMessage()

    /**  

    * Handle system messages here. */

    publicvoiddispatchMessage(Message msg) {

    if (msg.callback != null) {

    handleCallback(msg);

    }else {

    if (mCallback != null) {

    if (mCallback.handleMessage(msg)) {

    return;

    }

     }

    handleMessage(msg);

    }

    }

    可以看到,如果我们设置了callback(Runnable对象)的话,则会直接调用handleCallback方法:

    privatestaticvoidhandleCallback(Message message) {

    message.callback.run();

    }

    msg.callback为空的话,会直接调用我们的mCallback.handleMessage(msg),即handler的handlerMessage方法。由于Handler对象是在主线程中创建的,所以handler的handlerMessage方法的执行也会在主线程中


    原作者的总结:

    1)主线程中定义Handler,直接执行:

    Handler mHandler =new Handler() {

    @Override

    publicvoidhandleMessage(Message msg) {

    super.handleMessage(msg);

    }};

    而如果想要在子线程中定义Handler,则标准的写法为:

    // 初始化该线程Looper,MessageQueue,执行且只能执行一次

    Looper.prepare();

    // 初始化Handler对象,内部关联Looper对象

    Handler mHandler =new Handler() {

    @Override

    publicvoidhandleMessage(Message msg) {

    super.handleMessage(msg);

    }

    };

    // 启动消息队列出栈死循环

    Looper.loop();

    2)一个线程中只存在一个Looper对象,只存在一个MessageQueue对象,可以存在N个Handler对象,Handler对象内部关联了本线程中唯一的Looper对象,Looper对象内部关联着唯一的一个MessageQueue对象。

    3)MessageQueue消息队列不是通过列表保存消息(Message)列表的,而是通过Message对象的next属性关联下一个Message从而实现列表的功能,同时所有的消息都是按时间排序的。

    4)android中两个子线程相互交互同样可以通过Handler的异步消息机制实现,可以在线程a中定义Handler对象,而在线程b中获取handler的引用并调用sendMessage方法。

    5)activity内部默认存在一个handler的成员变量,android中一些其他的异步消息机制的实现方法: 
    Handler的post方法:

    mHandler.post(new Runnable() {

    @Override

    publicvoidrun() {

    }

    });

    查看其内部实现:

    publicfinalbooleanpost(Runnable r) {

    return sendMessageDelayed(getPostMessage(r), 0);

    }

    可以发现其内部调用就是sendMessage系列方法。。。

    view的post方法:

    publicbooleanpost(Runnable action) {

    final AttachInfo attachInfo = mAttachInfo;

    if (attachInfo != null) {

    return attachInfo.mHandler.post(action);

    }

    // Assume that post will succeed later

    ViewRootImpl.getRunQueue().post(action);

    returntrue;

    }

    可以发现其调用的就是activity中默认保存的handler对象的post方法。

    activity的runOnUiThread方法:

    publicfinalvoidrunOnUiThread(Runnable action) {

    if (Thread.currentThread() != mUiThread) {

    mHandler.post(action);

    }else {

    action.run();

    }

    }

    判断当前线程是否是UI线程,如果不是,则调用handler的post方法,否则直接执行run方法。

    http://blog.csdn.net/qq_23547831/article/details/50751687


    展开全文
  • 主要为大家详细介绍了Android异步消息机制的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Android 异步消息机制

    2016-08-11 12:00:18
    Android 异步消息机制

    Android 异步消息机制

    参考:http://blog.csdn.net/lmj623565791/article/details/38377229
    1、首先Looper.prepare()在本线程中保存一个Looper实例,然后该实例中保存一个MessageQueue对象;因为Looper.prepare()在一个线程中只能调用一次,所以MessageQueue在一个线程中只会存在一个。
    2、Looper.loop()会让当前线程进入一个无限循环,不断从MessageQueue的实例中读取消息,然后回调msg.target.dispatchMessage(msg)方法。
    3、Handler的构造方法,会首先得到当前线程中保存的Looper实例,进而与Looper实例中的MessageQueue想关联。
    4、Handler的sendMessage方法,会给msg的target赋值为handler自身,然后加入MessageQueue中。
    5、在构造Handler实例时,我们会重写handleMessage方法,也就是msg.target.dispatchMessage(msg)最终调用的方法。
    好了,总结完成,大家可能还会问,那么在Activity中,我们并没有显示的调用Looper.prepare()和Looper.loop()方法,为啥Handler可以成功创建呢,这是因为在Activity的启动代码中,已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。

    1、 Looper
    Looper.prepare():只能调用一次。会进行判空操作,有则抛出异常,没有则创建并保存到ThreadLocal中。
    new Looper():创建MessageQueue消息队列,保存在Looper对象中。
    Looper.loop():无限循环读取消息(messageQueue.next()方法),没有消息则阻塞,获取到则执行msg.target.dispatchMessage(msg);其中msg.target就是Handler对象。

    class Thread{
        ThreadLocal threadLocal;        
    }
    class ThreadLocal{
        Looper looper;
    }
    class Looper{
        MessageQueue messageQueue;
    }
    

    2、 Handler
    new Handler():保存Thread中的looper、messageQueue到对象中。
    sendMessage():最终调用sendMessageAtTime(),将msg.target赋值为this,再执行queue.enqueueMessage将消息插入队列。
    dispatchMessage :若msg.callback不为空(其实就是postRunnable方式),则执行handCallback,否则执行handMessage方法。

    class Handler{
        Looper looper;
        MessageQueue messageQueue;
        new Handler(){
            this.looper = threadLocal.looper;
            this.messageQueue = looper.messageQueue;
        }
    }
    

    Handler与哪个looper关联,则最终消息处理在哪执行。(默认与主线程关联,如果传入looper对象,如handlerThread,则会在子线程处理消息)。
    looper循环不卡死:执行message.next,会执行nativePollOnce方法,设计Linux pipe/epoll机制,类似生产者消费者模式。
    HandlerThread:其实就是在run中执行了Looper.prepare()和Looper.loop(),而使用的时候是通过Handler handler = new Handler(handlerThread.getLooper()),之后handler的消息都会在子线程中执行。

    展开全文
  • J2EE的异步消息机制(上下版),JAVA教程,附件为doc版本,下载后可用word2003及以上版本打开。 在分布式企业级应用程序中,异步消息机制用于有效地协调各个部分的工作。 J2EE为我们提供了JMS和消息驱动豆(Message-...
  • 主要为大家详细介绍了android异步消息机制,源码层面彻底解析,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要为大家详细介绍了android异步消息机制,从源码层面解析,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 谷歌在Android native层实现的一个异步消息机制,在这个机制中几乎不存在同步锁,所有的处理都是异步的,将变量封装到一个消息AMessage结构体中,然后放到队列中去,后台专门有一个线程会从这个队列中取出消息然后...

    谷歌在Android native层实现的一个异步消息机制,在这个机制中几乎不存在同步锁,所有的处理都是异步的,将变量封装到一个消息AMessage结构体中,然后放到队列中去,后台专门有一个线程会从这个队列中取出消息然后执行,执行函数就是onMessageReceived

    AMessage类

    struct AMessage : public RefBase {
        //构造函数,包括两个参数,第一个参数指明这是个什么消息,用于在onMessageReceived处理分支中进行匹配,第二个参数target用于后台线程在处理这个消息的时候知道发给哪个类处理
        AMessage(uint32_t what = 0, ALooper::handler_id target = 0);
        void setWhat(uint32_t what);
        uint32_t what() const;
        void setTarget(ALooper::handler_id target);
        ALooper::handler_id target() const;
    
        void clear();
        //这个消息类中定义了一堆set和find方法,用于在在传递消息过程中携带各种信息
        void setObject(const char *name, const sp &obj);
        void setBuffer(const char *name, const sp &buffer);
        void setMessage(const char *name, const sp &obj);
        bool findBuffer(const char *name, sp *buffer) const;
        bool findMessage(const char *name, sp *obj) const;
        void post(int64_t delayUs = 0);
    protected:
        virtual ~AMessage();  析构函数
    private:
        uint32_t mWhat;
        ALooper::handler_id mTarget;
        两个重要的私有成员变量
    };
    

    使用方法
    正如开头部分看的那样,构造一个消息的过程如下:

    void NuPlayer::start() {
        (new AMessage(kWhatStart, id()))->post();
    }
    void AMessage::post(int64_t delayUs) {
        gLooperRoster.postMessage(this, delayUs);
    }
    

    AHandler类分析----消息处理类的父类

    struct AHandler : public RefBase {
        AHandler()
            : mID(0) {  // mID的初始值为0
        }
        ALooper::handler_id id() const {
            return mID;   //id()这个函数用于返回内部变量mID的值,其初始值为0,但是会通过setID函数设置
        }
        sp<ALooper> looper();
    protected:
        virtual void onMessageReceived(const sp &msg) = 0;
    private:
        friend struct ALooperRoster;
        ALooper::handler_id mID;
        //下面这个函数正式在其友元类ALooperRoster的registerHandler中调用的
        void setID(ALooper::handler_id id) {
            mID = id;
        }
    };
    
    ALooper::handler_id ALooperRoster::registerHandler(
            const sp looper, const sp &handler) {
        Mutex::Autolock autoLock(mLock);
    
        if (handler->id() != 0) {
            CHECK(!"A handler must only be registered once.");
            return INVALID_OPERATION;
        }
        HandlerInfo info;
        info.mLooper = looper;
        info.mHandler = handler;
        ALooper::handler_id handlerID = mNextHandlerID++;
        mHandlers.add(handlerID, info);
        handler->setID(handlerID);
        //针对每个handler调用registerHandler的时候都会设置一个独一无二的handler_id,最后发送消息进行处理的时候就是通过这个独一无二的handler_id这个变量找到处理handler类的。
        return handlerID;
    }    
    

    在这个函数中针对这个looper和handler会构造一个HandlerInfo结构体,然后放到pair容器中。一个looper可以有多个handler,但是一一个handler只能跟一个looper。

    ALooper类

    struct ALooper : public RefBase {
        typedef int32_t event_id;
        typedef int32_t handler_id;
        ALooper();
        // Takes effect in a subsequent call to start().
        void setName(const char *name);
        handler_id registerHandler(const sp &handler);
        void unregisterHandler(handler_id handlerID);
        status_t start(
                bool runOnCallingThread = false,
                bool canCallJava = false,
                int32_t priority = PRIORITY_DEFAULT
                );
    private:
        friend struct ALooperRoster; 
        struct Event {
            int64_t mWhenUs;
            sp mMessage;
        };
       //后台存放事件的链表
        List<Event> mEventQueue;
        struct LooperThread;
        //后台处理线程
        sp<LooperThread> mThread;
        void post(const sp &msg, int64_t delayUs);
        bool loop();
    };
    
    

    ALooper 里面用Condition 做消息通知, List存储消息

    能作为handler进行注册的类都必须是继承自AHandler这个类,注册的过程也是交给
    gLooperRoster处理。

    AMessage类:

    消息类,用于构造消息,并通过post方法投递出去由ALooperRoster 类中转给ALooper

    ALooperRoster类:中转类

    将消息中转给ALooper 或者 AHandleReflector

    ALooper

    负责存储和转发AHandle的消息

    LooperThread:

    此线程循环调用ALooper的loop方法来转发消息

    AHandleReflector类

    消息处理类

    使用方法
    1.开始会创建一个ALooper对象, mLooper->start(…)

    2.然后会实现一个AHandler的子类,
    mLooper->registerhandler(objectXX)

    子类实现一个onMessageReceived(XXXX),做收到消息的处理。

    3.最后创建消息进行投递进入Message Queue。
    创建AMessage里面,需要指定handleid,才能知道目标是发给谁。

    mLooper(new ALooper)
    mLooper->setName(name);  
    
    mLooper->start(  
             false, // runOnCallingThread  
             false, // canCallJava  
             ANDROID_PRIORITY_FOREGROUND); 
    
    mPlayer = new NUPlayer;
    mLooper->registerHandler(mPlayer);  
    //mPlayer是一个AHandler
    
    mReflector =new AhandlerReflector<RTSPSource.(this);
    mLooper->registerHandler(mReflector); 
    
    (new AMessage(kWhatStart,id()))->post()
    

    在这里插入图片描述

    展开全文
  • 源码分析Handler异步消息机制

    前言

    作为Android开发的我们都知道,Android的主线程即UI线程是不安全的,如果我们在子线程里去更新UI则有可能造成程序崩溃。解决办法我们都非常的熟悉了,就是创建message,然后使用handler去发送这个message,之后在handlerMessage里去刷新UI。我们称之为异步消息处理线程,但是其中的原理是怎样的,你真的知道吗?


    源码分析

    基本使用方法这里就不再说明了,我们或许知道’在子线程里直接创建handler会报错’,至于为什么会报错,我们来看看Handler的构造函数:

    public Handler(Callback callback, boolean async) {
            if (FIND_POTENTIAL_LEAKS) {
                final Class<? extends Handler> klass = getClass();
                if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                        (klass.getModifiers() & Modifier.STATIC) == 0) {
                    Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                        klass.getCanonicalName());
                }
            }
    
            mLooper = Looper.myLooper();
            if (mLooper == null) {
                throw new RuntimeException(
                    "Can't create handler inside thread that has not called Looper.prepare()");
            }
            mQueue = mLooper.mQueue;
            mCallback = callback;
            mAsynchronous = async;
        }

    代码12行,这里做了判断,如果mLooper为null那么就抛出一个异常,这里就能解释我们在线程里直接创建handler会报错了,所以我们在子线程中创建handler之前应该先创建Looper:

    Looper.prepare();

    我们来看下是如何创建Looper的,进入prepare方法

    private static void prepare(boolean quitAllowed) {
            if (sThreadLocal.get() != null) {
                throw new RuntimeException("Only one Looper may be created per thread");
            }
            sThreadLocal.set(new Looper(quitAllowed));
        }

    首先会判断当前线程是否已经有Looper,如果有,则抛出异常’一个线程只能有一个Looper’,反之则创建Looper对象,我们进入Looper的构造函数:

     private Looper(boolean quitAllowed) {
            mQueue = new MessageQueue(quitAllowed);
            mThread = Thread.currentThread();
        }

    我们发现,在Looper的构造函数里创建了MessagerQueue,由此,我们可以得出结论MessageQueue是一一对应的,且一个线程里只能有1个Looper和1个MessageQueue。

    那为什么主线程可以直接创建Handler呢?现在我们应该都知道答案了,因为主线程默认创建了Looper.进入ActivityThread的main方法:

    public static void main(String[] args) {
        SamplingProfilerIntegration.start();
        CloseGuard.setEnabled(false);
        Environment.initForCurrentUser();
        EventLogger.setReporter(new EventLoggingReporter());
        Process.setArgV0("<pre-initialized>");
        Looper.prepareMainLooper();
        ActivityThread thread = new ActivityThread();
        thread.attach(false);
        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
        AsyncTask.init();
        if (false) {
            Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));
        }
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

    可以看到,在第7行调用了Looper.prepareMainLooper()方法,而这个方法又会再去调用Looper.prepare()方法,代码如下:

    public static final void prepareMainLooper() {
        prepare();
        setMainLooper(myLooper());
        if (Process.supportsProcesses()) {
            myLooper().mQueue.mQuitAllowed = false;
        }
    }

    现在,从我们最熟悉的代码继续:

    mHandler.sendMessage(msg);

    进入sendMessage方法:

    public final boolean sendMessage(Message msg)
        {
            return sendMessageDelayed(msg, 0);
        }
    
    public final boolean sendMessageDelayed(Message msg, long delayMillis)
        {
            if (delayMillis < 0) {
                delayMillis = 0;
            }
            return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
        }
    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
            MessageQueue queue = mQueue;
            if (queue == null) {
                RuntimeException e = new RuntimeException(
                        this + " sendMessageAtTime() called with no mQueue");
                Log.w("Looper", e.getMessage(), e);
                return false;
            }
            return enqueueMessage(queue, msg, uptimeMillis);
        }

    这里的mQueue,我们上面已经看到,创建Looper的时候创建,这里是加了个判断,进入enqueueMessage方法:

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
            msg.target = this;
            if (mAsynchronous) {
                msg.setAsynchronous(true);
            }
            return queue.enqueueMessage(msg, uptimeMillis);
        }

    我们看到,最终这个消息是交给了MessageQueue去处理,进入MessageQueue的enqueueMessage方法:

     boolean enqueueMessage(Message msg, long when) {
            if (msg.isInUse()) {
                throw new AndroidRuntimeException(msg + " This message is already in use.");
            }
            if (msg.target == null) {
                throw new AndroidRuntimeException("Message must have a target.");
            }
    
            synchronized (this) {
                if (mQuitting) {
                    RuntimeException e = new RuntimeException(
                            msg.target + " sending message to a Handler on a dead thread");
                    Log.w("MessageQueue", e.getMessage(), e);
                    return false;
                }
    
                msg.when = when;
                Message p = mMessages;
                boolean needWake;
                if (p == null || when == 0 || when < p.when) {
                    // New head, wake up the event queue if blocked.
                    msg.next = p;
                    mMessages = msg;
                    needWake = mBlocked;
                } else {
                    // Inserted within the middle of the queue.  Usually we don't have to wake
                    // up the event queue unless there is a barrier at the head of the queue
                    // and the message is the earliest asynchronous message in the queue.
                    needWake = mBlocked && p.target == null && msg.isAsynchronous();
                    Message prev;
                    for (;;) {
                        prev = p;
                        p = p.next;
                        if (p == null || when < p.when) {
                            break;
                        }
                        if (needWake && p.isAsynchronous()) {
                            needWake = false;
                        }
                    }
                    msg.next = p; // invariant: p == prev.next
                    prev.next = msg;
                }
    
                // We can assume mPtr != 0 because mQuitting is false.
                if (needWake) {
                    nativeWake(mPtr);
                }
            }
            return true;
        }

    MessageQueue是一个消息处理队列,毫无疑问enqueueMessage方法就是入队,这里我们要明白的是,MessageQueue并不像集合以一样把所有消息存在一起,而是使用mMessages代表待处理的消息,然后观察上面的代码的16~43行我们就可以看出,这里的入队,实质就是将所有消息根据时间来排序,根据就是我们传入的uptimeMillis参数,根据时间的顺序调用msg.next,从而为每一个消息指定它的下一个消息是什么。

    那Looper对MessageQueue做了怎样的操作呢?进入Looper.loop()方法:

    public static void loop() {
            final Looper me = myLooper();
            if (me == null) {
                throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
            }
            final MessageQueue queue = me.mQueue;
    
            // Make sure the identity of this thread is that of the local process,
            // and keep track of what that identity token actually is.
            Binder.clearCallingIdentity();
            final long ident = Binder.clearCallingIdentity();
    
            for (;;) {
                Message msg = queue.next(); // might block
                if (msg == null) {
                    // No message indicates that the message queue is quitting.
                    return;
                }
    
                // This must be in a local variable, in case a UI event sets the logger
                Printer logging = me.mLogging;
                if (logging != null) {
                    logging.println(">>>>> Dispatching to " + msg.target + " " +
                            msg.callback + ": " + msg.what);
                }
    
                msg.target.dispatchMessage(msg);
    
                if (logging != null) {
                    logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
                }
    
                // Make sure that during the course of dispatching the
                // identity of the thread wasn't corrupted.
                final long newIdent = Binder.clearCallingIdentity();
                if (ident != newIdent) {
                    Log.wtf(TAG, "Thread identity changed from 0x"
                            + Long.toHexString(ident) + " to 0x"
                            + Long.toHexString(newIdent) + " while dispatching to "
                            + msg.target.getClass().getName() + " "
                            + msg.callback + " what=" + msg.what);
                }
    
                msg.recycle();
            }
        }

    我们可以看到,从代码的13行开始进入死循环,不断的调用MessageQueue的next方法,对的,next就是出队方法。逻辑就是:如果当前MessageQueue中存在mMessages,就将这个消息出队,然后让下一条消息成为mMessages,否则就进入一个阻塞状态,一直等到有新的消息入队。我们继续看代码的27行,msg.target.dispatchMessage(msg);target是什么?进入Message源码我们会发现,实质就是我们的Handler。进入dispatchMessage方法:

    public void dispatchMessage(Message msg) {
            if (msg.callback != null) {
                handleCallback(msg);
            } else {
                if (mCallback != null) {
                    if (mCallback.handleMessage(msg)) {
                        return;
                    }
                }
                handleMessage(msg);
            }
        }

    这里会判断mCallback是否为空,如果不为空,handleCallback(进入Callback源码发现调用mCallback的handleMessage()方法)将消息传出去,如果为空,就使用handler的handleMessage方法将消息传出去。这个handlerMessage我们是不是很熟悉,这下我们就明白为什么在handlerMessage方法里能收到消息了。

    在google官方copy了一段标准的创建异步消息的代码,相信大家会很清楚的理解:

    class LooperThread extends Thread {
          public Handler mHandler;
    
          public void run() {
              Looper.prepare();
    
              mHandler = new Handler() {
                  public void handleMessage(Message msg) {
                      // process incoming messages here
                  }
              };
    
              Looper.loop();
          }
      }

    在文章的开头我们提到在多线程中直接更新UI会报错,我们也知道用什么方法去解决。以下三个方法,可以直接在其他线程中更新UI:

    1. Handler的post()方法
    2. View的post()方法
    3. Activity的runOnUiThread()方法

    他们的实质就是异步消息机制。这里就不一一说明了。

    展开全文
  • 1.前言Handler Message是android中比较常用的异步消息机制,通常我们对UI更新,对异步操作运算,很多时候都采用Handler来实现,现在我们探讨一下Handler,Message以及Looper的消息机制。2.一般使用方法通常我们使用...
  • JMS异步消息机制

    千次阅读 2010-11-15 17:15:00
    在分布式企业级应用程序中,异步消息机制用于有效地协调各个部分的工作。  J2EE为我们提供了JMS和消息驱动Bean(Message-Driven Bean),用来实现应用程序各个部件之间的异步消息传递。  一....
  • Android Handler 异步消息机制

    千次阅读 2012-02-29 22:40:37
    Android Handler 异步消息机制  Handler基本概念:  Handler主要用于异步消息的处理:当发出一个消息之后,首先进入一个消息队列,发送消息的函数即刻返回,而另外一个部分逐个的在消息队列中将消息取出,然后...
  • jms异步消息机制

    2008-08-29 17:00:32
    在分布式企业级应用程序中,异步消息机制用于有效地协调各个部分的工作。 J2EE为我们提供了JMS和消息驱动Bean(Message-Driven Bean),用来实现应用程序各个部件之间的异步消息传递。 一.什么是消息系统? 通常一...
  • 参考文章:Handler详解系列(一)Handler异步消息机制一、Android异步消息机制中主要涉及到: Thread Handler Looper MessageQueue 它们的相互关系如下: 1 Looper.prepare(); 1.1 为当前线程生成对应的Looper....
  • 相信做安卓的很多人都遇到过这方面的问题,什么是异步消息机制,什么又是Handler、Looper和MessageQueue,它们之间又有什么关系?它们是如何协作来保证安卓app的正常运行?它们在开发中具体的使用场景是怎样的?今天...
  • 同步和异步消息机制

    2018-12-03 15:25:00
    同步消息机制 两个通信服务之间必须进行同步,而且两个服务必须都是正常的一直处于运行状态的,随时做好通信准备,发送程序在向接收程序发送消息后,阻塞自身与其他应用的通信进程,等待接收程序的返回消息,然后...
  • Handler的异步消息机制

    2018-03-13 14:46:41
    Handler异步通信机制(包含Looper、 MessageQueue)https://www.jianshu.com/p/9fe944ee02f71.作用Handler的消息传递机制用来实现子线程对UI线程中UI的更新。2.相关概念2.1Looper轮循器,扮演MessageQueue和Handler...
  • Android 异步消息机制实现UI处理 1、 Android的UI也是线程不安全的,所以必须在主线程更新UI 否则报错 2、 Android的异步消息处理机制 4个部分:Message、Handler、MessageQueue 和Looper    ①Message:...
  • 异步机制(Asynchronous) -- (二)异步消息机制兼谈Hadoop RPC 2011年01月22日  上篇说了半天,却回避了一个重要的问题:为什么要用异步呢,它有什么样的好处?坦率的说,我对这点的认识不是太深刻(套句俗语,...
  • Android 异步消息机制,其实就是线程通过Looper建立自己的消息循环机制,MessageQueue是FIFO的消息队列,Looper负责从MessageQueue中取出消息,并且分发到消息指定目标Handler对象。Handler对象绑定到线程的局部...
  • Handler是Android提供用来更新UI的一套机制,也是一套消息处理机制,可以用它来发送消息,也可以用它来接收消息。 如果使用Handler首先我们要new一个他的实例进入 public Handler() { this
  • PyQt4的异步消息机制

    2018-07-09 15:27:25
    为了完成这个需求,需要采用一种线程安全的消息机制。因为我采用PyQt4作为GUI的库,因此,直接使用PyQt4的消息机制成为我考虑的首选。在PyQt4里面,发出消息采用emit的方式。比如:1 2 3 4 # 新的pythonic的方式 self...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,584
精华内容 2,633
关键字:

异步消息机制