#messagequeuing | Explore Tumblr posts and blogs

jacob-cs · 7 years ago

Link

original source : https://stackoverflow.com/questions/12877944/what-is-the-relationship-between-looper-handler-and-messagequeue-in-android

android handlerthread, looper, handler 개념잡기 좋은 내용

A Looper is a message handling loop: it reads and processes items from a MessageQueue. The Looper class is usually used in conjunction with a HandlerThread (a subclass of Thread).

A Handler is a utility class that facilitates interacting with a Looper—mainly by posting messages and Runnable objects to the thread's MessageQueue. When a Handler is created, it is bound to a specific Looper (and associated thread and message queue).

In typical usage, you create and start a HandlerThread, then create a Handler object (or objects) by which other threads can interact with the HandlerThread instance. The Handler must be created while running on the HandlerThread, although once created there is no restriction on what threads can use the Handler's scheduling methods (post(Runnable), etc.)

The main thread (a.k.a. UI thread) in an Android application is set up as a handler thread before your application instance is created.

Aside from the class docs, there's a nice discussion of all of this here.

It's widely known that it's illegal to update UI components directly from threads other than main thread in android. This android document (Handling Expensive Operations in the UI Thread) suggests the steps to follow if we need to start a separate thread to do some expensive work and update UI after it's done. The idea is to create a Handler object associated with main thread, and post a Runnable to it at appropriate time. This Runnable will be invoked on the main thread. This mechanism is implemented with Looper and Handler classes.

The Looper class maintains a MessageQueue, which contains a list messages. An important character of Looper is that it's associated with the thread within which the Looper is created. This association is kept forever and can't be broken nor changed. Also note that a thread can't be associated with more than one Looper. In order to guarantee this association, Looper is stored in thread-local storage, and it can't be created via its constructor directly. The only way to create it is to call prepare static method on Looper. prepare method first examines ThreadLocal of current thread to make sure that there isn't already a Looper associated with the thread. After the examination, a new Looper is created and saved in ThreadLocal. Having prepared the Looper, we can call loop method on it to check for new messages and have Handler to deal with them.

As the name indicates, the Handler class is mainly responsible for handling (adding, removing, dispatching) messages of current thread's MessageQueue. A Handler instance is also bound to a thread. The binding between Handler and Thread is achieved via Looper and MessageQueue. A Handler is always bound to a Looper, and subsequently bound to the thread associated with the Looper. Unlike Looper, multiple Handler instances can be bound to the same thread. Whenever we call post or any methods alike on the Handler, a new message is added to the associated MessageQueue. The target field of the message is set to current Handler instance. When the Looper received this message, it invokes dispatchMessage on message's target field, so that the message routes back to to the Handler instance to be handled, but on the correct thread. The relationships between Looper, Handler and MessageQueue is shown below:

Let's start with the Looper. You can understand the relationship between Looper, Handler and MessageQueue more easily when you understand what Looper is. Also you can better understand what Looper is in the context of GUI framework. Looper is made to do 2 things.

1) Looper transforms a normal thread, which terminates when its run() method returns, into something that runs continuously until Android app is running, which is needed in GUI framework (Technically, it still terminates when run() method returns. But let me clarify what I mean, below).

2) Looper provides a queue where jobs to be done are enqueued, which is also needed in GUI framework.

As you may know, when an application is launched, the system creates a thread of execution for the application, called “main”, and Android applications normally run entirely on a single thread by default the “main thread”. But main thread is not some secret, special thread. It's just a normal thread that you can also create with new Thread() code, which means it terminates when its run() method returns! Think of below example.

#thread #android #handler #handlerthread #looper #messagequeue #message

0 notes

smsgatewayindia · 2 years ago

Text

SMPP SOFTWARE

Empower your Business with our Feature-Rich SMPP Software for efficient SMS communication

• High-throughput Message Sending

• Message Queue Management

• Message Routing and Filtering

• Real-time Monitoring and Reporting

• Customizable

https://smppcenter.com

#SMPPsoftware #SMScommunication #highthroughput #messagequeue #messagerouting #realtime #monitoring #reporting #customizable #businessautomation #efficiencyboost

0 notes

timviecplus · 5 years ago

Text

Lập trình viên (Junior Developer.Net)

https://ift.tt/3cjxanC - Là nhân viên của VNIs: - Phát triển hệ thống hóa đơn điện tử trên nền tảng .NET - Xây dựng ASP.NET MVC, API, Windows Service, Single Page Application, Microservice ... - Làm Front-end với HTML5, CSS3, JSON, XML, CSV, Bootstrap, AngularJS - Làm Back-end với .Net Core, .Net Framework , Entity Framework, SQL Server, Redis cache, MessageQueue, Multiple thread - Thiết kế Database với Indexes, Partition, Fragmentation, Job, Transaction, Store Procedure - Làm Dependency Injection, Design Pattern (Repository, UnitOfWork, Singleton, CQRS, Domain Driven Design, Module) ... - Làm về unit test, system test, load test, optimize souce code, security, performance, turning hệ thống - Được sử dụng SQL Server Profiler, Database Engine Turning Advisor ... - Làm việc theo phương pháp Agile Scrum #timviec #timvieconline #cv #cvxinviec #cvonlinetimviec #cv.timviec.com.vn #tuyendung

0 notes

releaseteam · 6 years ago

Link

via Twitter https://twitter.com/releaseteam

#IFTTT #Twitter

0 notes

e-commerce-magento · 6 years ago

Text

RT @atwixcom: December #MageNews digest 🗞 is out: 🚨 PHP 7.1 EOL 🧘‍♂️Adobe Sensei Under the Hood 🛠 MessageQueue 👷‍♂️ PageBuilder 🚓 Security Updates 🤝 Community Experience ..and even MORE RT if you like it: https://t.co/BbrdQH46d2 https://t.co/WZAZ5HrUza

December #MageNews digest 🗞 is out: 🚨 PHP 7.1 EOL 🧘‍♂️Adobe Sensei Under the Hood 🛠 MessageQueue 👷‍♂️ PageBuilder 🚓 Security Updates 🤝 Community Experience ..and even MORE RT if you like it: https://t.co/BbrdQH46d2 pic.twitter.com/WZAZ5HrUza

— Atwix (@atwixcom) December 17, 2019

from Twitter https://twitter.com/fbeardev

#magento #ecommerce #web #sales

0 notes

libliboom · 6 years ago

Text

HaMeR framework

Handler + Message + Runnable and Looper + MessageQueue from Android

#android

0 notes

programmingsolver · 6 years ago

Text

MessagePriorityQueue Revisited Solution

In the Module 4 on polymorphism, we transformed MessagePriorityQueue and MessageQueue in Java into generic Queue<T> and aPriorityQueue<T> classes based on our own AbstractQueue<T> interface. Now that we have been introduced to the Java Collections framework, it is time to take the next step by replacing our own Queue class and AbstractQueueinterface with the ones from the Java Collection…

View On WordPress

0 notes

heartcentrictech · 5 years ago

Text

Let's talk about technology folks👩🏻‍💻 I'm very interested in Cloud Technology☁️ lately and very inspired about what Microsoft Azure brings in the market🥰 You already realize everything is turned out to be online. Therefore, web based applications are highly demanded these days. Due to high volume of traffic, it's challenging to keep applications available and responsive with a high performance💁‍♀️ I want to talk about message queue for those who are interested and techie🦸‍♀️ A message💌 queue is a queue of messages sent between applications. It includes a sequence of work objects that are waiting to be processed. Message queues📨 can be used to decouple heavyweight processing, to scale up easily and to provide loose connectivity among various components. Azure Storage Queue is advised to when following are concern; 💭Async communication 💭Passing messages from an Azure Web role to an Azure worker role 💭Load Leveling 💭Load Balancing 💭Temporal Decoupling 💭Loose coupling Comment below what technologies you are currently working with🦋 or what technologies make you inspired🎊 Looking forward to hearing your thoughts✨ Always with passion🔥

#cloud #cloud technology #microsoft #microsoft azure #azure cloud #messagequeue #azure storage #azure storage queue #heartcentrictech #heartcentrictechmentoring #heartcentricbusiness #tech #technology

0 notes

jacob-cs · 8 years ago

Link

original source : https://medium.com/@ali.muzaffar/handlerthreads-and-why-you-should-be-using-them-in-your-android-apps-dc8bf1540341

This was my first and last encounter with them for a while. It seemed like a very low level API and something that may not necessarily be meant to be used by app developers. I had rarely (almost never) seen it used in any code sample for how to do perform asynchronous tasks in Android. I did mentioned them as a way to do asynchronous processing in my article 8 ways to do asynchronous processing in Android and counting, even there, I deferred to just regular Theads and ignored how HandlerThreads are used.

It wasn't till a recent conversation with Colt McAnlis at the BABBQ15 that I heard the mentions of HandlerThreads again. The difference this time was that they were in context of how they process commands from a queue and how this makes for situations where you have to perform a lot of asynchronous tasks. This sounded like just about every application I have written, so why weren't these mentioned more readily in Android Development literature?

Since the BABBQ, I’ve looked some into HandlerThreads and from what I figure, there are 2 main reasons why developers/educators may be inclined to not mention HandlerThreads.

HandlerThreads run outside of your activity’s lifecycle, so they need to be cleaned up properly or else you will have thread leaks. This is especially dangerous if you are using them for long running processes. I recall Colt mentioning (I may be wrong) that you can have HandlerThreads with a timeout, so if they haven’t processed anything from the queue in a while, they should terminate themselves. I haven’t been able to find any way of doing this, short of extending HandlerThreads and adding the functionality myself. Update: HandlerThread doesn’t have a time out, a ThreadpoolExecutor has a timeout that can be used to wind down unused threads.

There is no convenient mechanism for posting results back to the main thread. This means more boilerplate code.

What is the problem with AsyncTask

AsyncTasks have a single thread dedicated to them, so if you spin off more than one AsyncTask, they aren’t truly asynchronous. This is not necessarily a problem, but it is restrictive if you do want multiple threads. With each AsyncTask that is spun off, a thread is created and destroyed which, if you have a lot of AsyncTasks is a performance issue.

What is wrong with Service

Services are executed on the main thread, so they aren't really asynchronous. You have to create a separate thread for them to use if you want them to be asynchronous. With both of these you still have a new thread being created and destroyed.

Why not use IntentService

As Ian Lake points out (link to discussion on Google+), IntentService does use HandlerThread internally (link to source) and this does make them a great option to use. He also points out that there is ever only one instance of a Service in existence at any given time and it has only one HandlerThread. This means that if you need more than one thing to happen at the same time, IntentServices may not be a good option. However, looking at the source for the IntentService, it does illustrate that the techniques discussed below are in fact used within the Android SDK itself and as such it is a design pattern you should be familiar with.

How do I use HandlerThreads

There are 2 main ways that I found to use HandlerThreads.

Create a new HandlerThread, create a new Handler using this HandlerThread and post your tasks on this handler.

Extend HandlerThread inside your CustomHandlerThread, create a Handler to process your task. You would take this approach if you know the task you want to perform and just need to pass in parameters. An example would be creating a HandlerThread to download images or perform networking operations.

Implementation of HandlerThread

The implementation is very straight forward.

HandlerThread handlerThread = new HandlerThread("MyHandlerThread"); handlerThread.start(); Looper looper = handlerThread.getLooper(); Handler handler = new Handler(looper);

As I mentioned earlier, we create a new HandlerThread and give it any name. We then start the HandlerThread, get the Looper for the HandlerThread and pass it to a handler.

Then, in order to use it, you simply have to post Runnable to the Handler thread.

handler.post(new Runnable(){…});

If you have a few different tasks you would like to perform on the background thread, it may be a better idea to extend handler and adding handling for different messages. Note, there is still one background thread here. If you want more threads, you’ll have to create more Handlers and HandlerThreads.

if (mHandler == null) { mHandler = new Handler(looper) { @Override public void handleMessage(Message msg) { switch (msg.what) { case SOMETHING_ACTION: { doSomething(); break; } case SOMETHING_ELSE_ACTION: doMoreThings(); break; default: break; } } }; } //usage mHandler.obtainMessage(SOMETHING_ACTION, ""); mHandler.sendMessage(msg);

IMPORTANT: Remember to call handlerThread.quit() when you are done with the background thread or on your activities onDestroy() method.

As you can see, Option 1 is probably best suited in situations where you don’t have a lot of code. I haven’t covered the scenario of posting back the result to the main thread either.

Posting back the results to the UI thread

There are two approaches that are best used here. You can either make a LocalBroadcast with the result:

Intent in = new Intent(DO_SOMETHING_RESULT); in.putExtra(DO_SOMETHING_RESULT, result); LocalBroadcastManager.getInstance(context).sendBroadcast(in);

The great thing about this approach is that you can simply receive the result on the Main thread without having to do anything extra. The down side is that the method is a lot slower than using a callback.

In order to use a callback, you can explicitly get a Handler on the main thread:

Handler mainHandler = new Handler(context.getMainLooper()); Runnable myRunnable = new Runnable() { @Override public void run() { MainActivity.this.onResult(); } // This is your code }; mainHandler.post(myRunnable);

Or, if you are creating the Handler on the main thread, simply calling new Handler() should return a Handler on the main thread.

Implementation of HandlerThreads by creating a custom HandlerThread, is simply a combination of the techniques that I have shown above. There is a great blog post by Nikita that explains how to do this. He also has a great post in which he explain Looper, Handler and HandlerThread and the interaction between them I highly recommend reading this to get a deeper understanding of how Android apps work.

#android #looper #handler #handlerthread #java #thread #messagequeue

0 notes

myprogrammingsolver · 6 years ago

Text

MessagePriorityQueue Revisited Solution

View On WordPress

0 notes

specindia · 8 years ago

Text

8 Ways Your Android App Can Leak Memory

One advantage of a garbage-collecting-language like Java is that it removes the need for developers to explicitly manage allocated memory. This reduces the likelihood of a segmentation fault crashing the app or an unfreed memory allocation bloating the heap, thus creating safer code. Unfortunately, there are other ways that memory can be leaked logically within Java. Ultimately, this means that your Android apps are still susceptible to wasting unnecessary memory and crashing as a result of out-of-memory (OOM) errors.

Traditional memory leaks occur when you neglect to free allocated memory before all related references go out of scope. Logical memory leaks, on the other hand, are the result of forgetting to release references to objects that are no longer needed in your app. If a strong reference to an object still exists, the garbage collector cannot remove the object from memory. This is particularly problematic in Android development if you happen to leak a Context. This is because Contexts such as Activities contain many references to large amounts of memory, i.e. view hierarchies and other resources. If you leak a Context, you are also leaking everything that it points to. Android mostly runs on mobile devices with limited memory capacity so it’s very likely for your app to run out of available memory if too many leaks take place.

Detecting logical memory leaks would be a subjective matter if the useful lifespan of an object were not clearly defined. Thankfully, activities have very explicitly defined lifecycles that reveal the point at which we can easily consider an instance of an Activity object to have been leaked.The onDestroy() method of an Activity is called at end-of-life and indicates that it is being destroyed either through programmer intention or because Android needs to recuperate some memory. If this method completes but the Activity instance can be reached by a chain of strong references from a heap root, then the garbage collector cannot mark it for removal from memory - despite the original intention to delete it. As a result, we can define a leaked Activity object as one that persists beyond its natural lifecycle.

Activities are very hefty objects, so you should never choose to defy the Android framework’s handling of them. However, there are ways that an Activity instance can become unintentionally leaked. In Android, all of the pitfalls that lead to potential memory leaks revolve around two fundamental situations. The first memory-leak-category is caused by a process-global static object that exists regardless of the app’s state and maintains a chain of references to the Activity. The other category is caused when a thread that outlasts the Activity’s lifetime neglects to clear a strong reference chain to that Activity. Let’s examine a few different ways that you might come across these situations.

1. Static Activities

The easiest way to leak an Activity is by defining a static variable inside the class definition of the Activity and then setting it to the running instance of that Activity. If this reference is not cleared before the Activity’s lifecycle completes, the Activity will be leaked. This is because the object representing the class of the Activity (i.e., MainActivity) is static and remains loaded in memory for the entire runtime of the app. If this class object holds a reference to your Activity instance, it therefore won’t be eligible for garbage collection.

void setStaticActivity() { activity = this; } View saButton = findViewById(R.id.sa_button); saButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { setStaticActivity(); nextActivity(); } });

2. Static Views

A similar situation would be implementing a singleton pattern where an activity might be visited often and it would be beneficial to keep the instance loaded in memory so that it can be restored quickly. However, for reasons stated before, defying the defined lifecycle of an Activity and persisting it in memory is an extremely dangerous and unnecessary practice - and should be avoided at all costs.

But what if we have a particular View that takes a great deal of effort to instantiate but will remain unchanged across different lifetimes of the same Activity? Well then let’s make just that View static after instantiating it and attaching it to the View hierarchy, like we do here. Now if our Activity is destroyed, we should be able to release most of its memory.

void setStaticView() { view = findViewById(R.id.sv_button); } View svButton = findViewById(R.id.sv_button); svButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { setStaticView(); nextActivity(); } });

Wait, what? Surely you knew that an attached View will maintain a reference to its Context, which, in this case, is our Activity. By making a static reference to the View, we’ve created a persistent reference chain to our Activity and leaked it. Don’t make attached Views static and if you must, at least detach them from the View hierarchy at some point before the Activity completes.

3. Inner Classes

Moving on, let’s say we define a class inside the definition of our Activity’s class, known as an Inner Class. The programmer may choose to do this for a number of reasons including increasing readability and encapsulation. What if we create an instance of this Inner Class and maintain a static reference to it? At this point you might as well just guess that a memory leak is imminent.

void createInnerClass() { class InnerClass { } inner = new InnerClass(); } View icButton = findViewById(R.id.ic_button); icButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { createInnerClass(); nextActivity(); } });

Unfortunately because one of the benefits of Inner Class instances is that they have access to their Outer Class’s variables, they must maintain a reference to the Outer Class’s instance which causes our Activity to be leaked.

4. Anonymous Classes

Similarly, Anonymous Classes will also maintain a reference to the class that they were declared inside. Therefore a leak can occur if you declare and instantiate an AsyncTask anonymously inside your Activity. If it continues to perform background work after the Activity has been destroyed, the reference to the Activity will persist and it won’t be garbage collected until after the background task completes.

void startAsyncTask() { new AsyncTask<Void, Void, Void>() { @Override protected Void doInBackground(Void... params) { while(true); } }.execute(); } super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); View aicButton = findViewById(R.id.at_button); aicButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { startAsyncTask(); nextActivity(); } });

5. Handlers

The very same principle applies to background tasks declared anonymously by a Runnable object and queued up for execution by a Handler object. The Runnable object will implicitly reference the Activity it was declared in and will then be posted as a Message on the Handler’s MessageQueue. As long as the message hasn’t been handled before the Activity is destroyed, the chain of references will keep the Activity live in memory and will cause a leak.

void createHandler() { new Handler() { @Override public void handleMessage(Message message) { super.handleMessage(message); } }.postDelayed(new Runnable() { @Override public void run() { while(true); } }, Long.MAX_VALUE >> 1); } View hButton = findViewById(R.id.h_button); hButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { createHandler(); nextActivity(); } });

6. Threads

We can repeat this same mistake again with both the Thread and TimerTask classes.

void spawnThread() { new Thread() { @Override public void run() { while(true); } }.start(); } View tButton = findViewById(R.id.t_button); tButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { spawnThread(); nextActivity(); } });

7. Timer Tasks

As long as they are declared and instantiated anonymously, despite the work occurring in a separate thread, they will persist a reference chain to the Activity after it has been destroyed and will yet again cause a leak.

void scheduleTimer() { new Timer().schedule(new TimerTask() { @Override public void run() { while(true); } }, Long.MAX_VALUE >> 1); } View ttButton = findViewById(R.id.tt_button); ttButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { scheduleTimer(); nextActivity(); } });

8. Sensor Manager

Finally, there are system services that can be retrieved by a Context with a call to getSystemService. These Services run in their own processes and assist applications by performing some sort of background work or interfacing to the device’s hardware capabilities. If the Context want to be notified every time an event occurs inside a Service, it needs to register itself as a listener. However, this will cause the Service to maintain a reference to the Activity, and if the programmer neglects to unregister the Activity as a listener before the Activity is destroyed it will be ineligible for garbage collection and leak will occur.

void registerListener() { SensorManager sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE); Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ALL); sensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_FASTEST); } View smButton = findViewById(R.id.sm_button); smButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { registerListener(); nextActivity(); } });

Now that you’ve seen an array of various memory leaks you can see just how easy it is to accidentally leak a massive amount of memory. Remember, although in the worst case this will cause your app to run out of memory and crash, it might not necessarily always do this. Instead, it can eat up a large but non-lethal amount of your app’s memory space. In this case, the app has less memory to allocate for other objects and thus your garbage collector will need to run more often to free up space for new objects. Garbage collection is a very expensive operation and will cause noticeable slowdown for the user. Stay aware of potential reference chains when instantiating objects in your Activities and test for memory leaks often!

This Post was originally published here : http://blog.nimbledroid.com/2016/05/23/memory-leaks.html

0 notes