Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Stacy Devino: Async Tasks, Threads, Pools, and Executors

1fa9cb8c7997c8c4d3d251fb5e41f749?s=47 Realm
July 28, 2016

Stacy Devino: Async Tasks, Threads, Pools, and Executors

Excerpt: There are many ways to use Threads and in the multithreated world in which we live, it can be confusing when, where, and how to use these functions correctly. Still, that assumes you know what they all mean and how to manipulate them. Novices and Experts welcome as there are many schools of thought, but we will explore them all together.
Don’t worry, we have you covered.
Bio: Stacy is a recognized Intel Innovator, Six Sigma Blackbelt, GDG organizer and is the Women Techmakers Lead for Dallas/Ft. Worth. She specializes in Android performance coding stemming from a deep knowledge of the Android OS.
You can usually find her helping people with their projects as well as shooting the breeze with her fellow makers! #perfmatters
Twitter: https://twitter.com/DoesitPew

1fa9cb8c7997c8c4d3d251fb5e41f749?s=128

Realm

July 28, 2016
Tweet

Transcript

  1. Async Task, Threads, Pools, and Executors Oh My! Stacy Devino

    @ 360AnDev 2016
  2. STACY DEVINO • Senior Android Innovator at The Home Depot

    Dallas Technology Center • Works on Consumer Mobile App and Internal Product Innovation • Six Sigma BlackBelt, Intel Innovator, DMS Member, Vintage game collector/restorer • Women Techmakers Lead for Dallas/ Ft. Worth WEBSITES www.stacydevino.com www.ledgoes.com www.openbrite.com EMAIL childofthehorn@gmail.com G+ https://plus.google.com/ +StacyDevino TWITTER @DoesitPew
  3. Why do I need to know Multithreaded Programming? What is

    it? Basically, it allows you to run multiple tasks concurrently (all at the same time) without interfering with each other. Important : CORE SKILL of the modern developer
  4. What is a Thread? Thread is an independent execution worker.

    All of Android works on Threads. Generally, the Main Thread is your UI Thread in Android (ex “Hello World” app). Required for things such as Login, pre-loading, and Web/RESTful APIs String != Bunch of Threads
  5. Android has 4 basic types of Threads Thread (Java Standard)

    Handler (Android Type) AsyncTask (Android Only) HandlerThread (Android Only, Handler/Looper combo) Other stuff we will not be going through: Futures IntentService Jobs / Alarms
  6. Basic Thread What does this do? Compute a new Random

    value to be used based off of a seed value. How is this useful? If you compute big Random values on big Seeds, this could take many processor cycles. long rootRandom = System.currentMillis(); private class RandomThread extends Thread { long seed; RandomThread (long seed){ this.seed = seed; } @Override public void run() { Random seededRandom = new Random (seed); rootRandom = seededRandom.nextInt(); } }
  7. Delayed Tasks with Handler Can be called/used anywhere, ex. Services

    or external classes Allows direct communication with UI/Main Thread, good with Messaging Tasks. private Handler mHandler = new Handler(); private int lifeSignDelay = 5000; private Runnable mainRunnable = new Runnable() { @Override public void run() { sendLifeSign(true); mHandler.postDelayed( mainRunnable, lifeSignDelay); } }
  8. Async Task Can ONLY be called from an Activity (main

    thread,boo) Simplified Interface for Task based objects Good for User Logins / pre-loading data to be shown on the UI public class MyUIActivity extends AppCompatActivity { // …….. private ImageView = view.findViewById(R.id.someView) // OnCreate and all other tasks contained above //Usage // … inside of a function or from onClick new DownloadImageTask() .execute("http://example.com/image.png"); //Async Task private class DownloadImageTask extends AsyncTask<String, Void, Bitmap> { protected Bitmap doInBackground(String... urls) { return loadImageFromNetwork(urls[0]); } protected void onPostExecute(Bitmap result) { mImageView.setImageBitmap(result); } } }
  9. HandlerThread (Handler + Looper) It’s a Thread with an Embedded

    Looper instance, keeps it alive and going handling messages/queue. Basic HandlerThread handlerThread = new HandlerThread("newHandlerThread"); handlerThread.start(); Handler myHandler = new Handler(handlerThread.getLooper()); myHandler.post(new Runnable(){…}); Fancy private void newOpenCamera() { if (mThread == null) { mThread = new CameraHandlerThread(); } synchronized (mThread) { mThread.openCamera(); } } private CameraHandlerThread mThread = null; private class CameraHandlerThread extends HandlerThread { Handler mHandler = null; CameraHandlerThread() { super("CameraHandlerThread"); start(); mHandler = new Handler(getLooper()); } void openCamera() { mHandler.post(new Runnable() { @Override public void run() { oldOpenCamera();//backup } }); } }
  10. Lambda Expressions (only in Java 8) private class RandomThread extends

    Thread { long seed; RandomThread (long seed){ this.seed = seed; } @Override public void run() { Random seededRandom = new Random (seed); rootRandom = seededRandom.nextInt(); } } private Runnable RandomThread = (long seed) -> { Random seededRandom = new Random (seed); rootRandom = seededRandom.nextInt() ; } becomes
  11. Advanced Threads and Thread Management

  12. Self Managed Thread Can be Runnables or Thread Closes itself

    Can Spawn new Threads Example shows linked threads of a simple Socket-level communication app class ConnectThread implements Runnable { @Override public void run() { while (!Thread.currentThread().isInterrupted()) { if (newConnection) { newConnection = false; SocketClass.startClient(); new Thread(new TimeOutThread()).start(); } if (serverReply != null) { if( serverReply.equals(Constants.ACK) ||serverReply.equals(Constants.NAK) ||serverReply.equals(Constants.STOP) { Thread.currentThread().interrupt(); sendCompleteEvent(serverReply); return; } } } } }
  13. Executors It’s Super Effective!
 Executes Runnable Tasks Asynchronous or Sequential

    New Thread Spawner (new Thread(RunnableTask)).start(); becomes Executor executor = anExecutor(); executor.execute(new RunnableTask()); executor.execute(new NextRunnableTask()); Direct Call in Same Thread class DirectExecutor implements Executor { public void execute(Runnable task) { task.run(); } } Asynchronous Call in new Thread class ThreadPerTaskExecutor implements Executor { public void execute(Runnable task) { new Thread(task).start(); } }
  14. ThreadPool Executor Executor which works with a group of maintained

    “Worker” threads. Threads themselves do not die, but merely transform. Create the Pool ThreadPoolExecutor mThreadPool = new ThreadPoolExecutor( // Initial processor pool size Runtime.getRuntime().availableProcessors(), // Max processor pool size Runtime.getRuntime().availableProcessors(), //Time to Keep Alive 3, //TimeUnit for Keep Alive TimeUnit.SECONDS, //Queue of Runnables mWorkQueue ); Using the Pool public class MyTaskManager { //….. // Run the Task on the Pool mThreadPool.execute( someTask.getRunnable()); //.. Now when done mThreadPool.shutdown(); }
  15. Executor Services Control of task that provide Futures (look at

    this elsewhere) in a single Entity. Examples: ScheuduledExecutorService private class NetworkService implements Runnable { private final ServerSocket serverSocket; private final ExecutorService pool; public NetworkService(int port, int poolSize) throws IOException { serverSocket = new ServerSocket(port); pool = Executors.newFixedThreadPool(poolSize); } public void run() { // run the service try { for (;;) { //Run on the new ThreadPool pool.execute( new Handler(serverSocket.accept())); } } catch (IOException ex) { //This signals shutdown the pool pool.shutdown(); } } } class Handler implements Runnable { private final Socket socket; Handler(Socket socket) { this.socket = socket; } public void run() { // read and service request on socket } } * from developer.android.com
  16. RXJava and libraries that have their own Thread Management

  17. aka RXAndroid Advantages: Significantly simplifies writing of modules as 3-4

    threads can be combined in a single Observable. Very easy to set up communication between multiple “Threads” or RXJava components. Pools and maintains worker threads. Easy to serialize thread results and information. Disadvantages: If not used properly, can have leaked messages and observables. (especially in the hands of those who don’t know thread management). It's not always as perfect in management as a specialty built component. Event and Task based, so self propagating processes are more work to set up.
  18. Other Examples of Self Managing Libs RetroFit : Turns Restful

    API calls into Java interfaces. Handles all Thread management and parsing. (by ReactiveX, many contributions by Square... Lots of Jake Wharton) Bolts-Android : Task based model which works on the premise of Promises (Javascript). Allows easy chaining of Asynchronous tasks. (by Parse and Facebook) Picasso : Image Loader that uses ThreadPoolExecutor to preload and size images. (by Square) Image Loader uses ThreadPoolExecutor and Handlers to preload and resize images. (by Bumptech)
  19. Thanks!