The document discusses threads and handlers in Android. It contains the following key points: 1. Threads allow for concurrent execution while the main thread is responsible for UI updates. Additional threads can be used for network requests and background tasks. 2. Handlers allow threads to communicate by posting messages and runnables to a message queue. This avoids direct method calls between threads. 3. The main thread has a looper by default while custom threads require adding a looper. Handlers are used to post tasks from a thread's looper queue back to the main thread for UI updates.

1. Eden Bugdary Machluf
Advanced sessions
Threads
31/07/18

2. First,

3. > 3500 members
Largest Android Active
Community

4. Android Academy Staff
Yonatan Levin
Google Developer
Expert &
CTO @ KolGene
Yossi Segev
Mobile engineer
Colu
Refael Ozeri
Founder & CEO
Hero Apps
Eden Bugdary
Mobile developer @
AppNext

5. What Do We Do?
● Android Fundamentals
● Android UI / UX
● Community Hackathon
● Android Advanced
● Mentors Program
● Active community

6. Moscow

7. Mentors program
NOW!

8. https://bit.ly/2Nn9dAf

9. Logistics

10. facebook.com/groups/android.academy.ils/

11. https://bit.ly/2MWtigC

12. Android Advanced Course
22.8 - UI, GPU, Animations
16.9 - Clean Architecture
3.7 - CPU & Memory
31.7 - Threads & Network

14. Timor Surkis
Android Dev @ Gini Apps
Superhuman tech guy

15. Artyom Okun
Mobile Developer @ Colu
Awesome crunchy guy

16. Eden Bugdary Machluf
Advanced sessions
Threads
31/07/18

17. Eden Bugdary Machluf
Android Academy
Mobile developer @Appnext

18. What is a Thread?

19. CPU & processes
CPU Process
1 ...
Thread
1 ...

20. Thread
A thread of execution is the smallest sequence of
programmed instructions that can be managed
independently.

21. When launching an app...
Application
Process
Main
Thread

22. The main thread
UI rendering
Application
components
User interaction
Lifecycle callbacks
Main thread
Queue

23. The main thread is very busy

24. 25
– When blocked - system shows ANR dialog
android.os.NetworkOnMainThreadException
– Exception on network operations
– Exclusive interaction with the UI

25. Leaving the Main thread

26. java.lang.Thread
public class MyThread extends Thread {
@Override
public void run() {
doStuff();
}
}
MyThread myThread = new MyThread();
myThread.start();

27. Getting back to the Main thread

28. Back to the main thread
We can:
– Activity.runOnUiThread(runnable)
– View.post(runnable)

29. Back to the Main Thread
runOnUiThread(new Runnable() {
@Override
public void run() {
mTextView.setText("Some data update");
}
});

30. Back to the Main Thread
runOnUiThread(new Runnable() {
@Override
public void run() {
mTextView.setText("Some data update");
}
});

31. Back to the Main Thread
runOnUiThread(new Runnable() {
@Override
public void run() {
mTextView.setText("Some data update");
}
});

32. From a View
mTextView.post(new Runnable() {
@Override
public void run() {
mTextView.setText("Some data update");
}
});

33. From a View
mTextView.post(new Runnable() {
@Override
public void run() {
mTextView.setText("Some data update");
}
});

34. From a View
mTextView.post(new Runnable() {
@Override
public void run() {
mTextView.setText("Some data update");
}
});

35. How does it work??

36. Threads in JAVA
new
MyThread()
start() run()
– One-time use only.
– Dies after executing it’s run() method.
– It’s not legal to start a thread more than once.

37. We have a problem
Create new thread consumes
system resources and memory.
How much memory?

38. Let’s make
threads
reusable

39. How it works?
We will need 3 players:
– Looper
– Message
– Handler

40. “
android.os.Looper
– Keeping its thread alive.
– Only one Looper per thread.
– Thread don’t get a Looper by default.*
– MessageQueue created when we create Looper.

41. android.os.Message
Two types of Messages:
– Data Message
– Task Message

42. android.os.Message
Message holding data.
Field Name Description
what int - Unique identifier
when long - timestamp
arg1, arg2 int - “Low cost” parameters
obj Object
data Bundle

43. android.os.Message
Message holding a task (Runnable).
Field Name Description
callback Runnable task
when long - timestamp

44. So it’s simple...
Task
Thread
Looper
MessageQueue

45. android.os.Handler
– Creating messages.
– Inserting messages to the queue.
– Removing messages in the queue.
– Consuming messages.

46. Thread
Looper
MessageQueue

47. Thread
Looper
MessageQueue
Handler

48. Thread
Looper
MessageQueue
Handler
Handler

49. Thread
Looper
MessageQueue
Handler
Handler

50. Thread
Looper
MessageQueue
Handler
Handler

51. Thread
Looper
MessageQueue
Handler
Handler

52. Thread
Looper
MessageQueue
Handler
Handler

53. Thread
Looper
MessageQueue
Handler
Handler

54. Thread
Looper
MessageQueue
Handler
Handler

55. Thread
Looper
MessageQueue
Handler
Handler

56. Thread
Looper
MessageQueue
Handler
Handler

57. Questions?

58. 60
Enough theory
Let’s see some code

59. View.java
public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
return attachInfo.mHandler.post(action);
}
getRunQueue().post(action);
return true;
}

60. View.java
public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
return attachInfo.mHandler.post(action);
}
getRunQueue().post(action);
return true;
}

61. View.java
public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
return attachInfo.mHandler.post(action);
}
getRunQueue().post(action);
return true;
}

62. View.java
public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
return attachInfo.mHandler.post(action);
}
getRunQueue().post(action);
return true;
}

63. View.java
public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
return attachInfo.mHandler.post(action);
}
getRunQueue().post(action);
return true;
}

64. Activity.java
final Handler mHandler = new Handler();
mUiThread = Thread.currentThread();
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
mHandler.post(action);
} else {
action.run();
}
}

65. Activity.java
final Handler mHandler = new Handler();
mUiThread = Thread.currentThread();
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
mHandler.post(action);
} else {
action.run();
}
}

66. Activity.java
final Handler mHandler = new Handler();
mUiThread = Thread.currentThread();
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
mHandler.post(action);
} else {
action.run();
}
}

67. Activity.java
final Handler mHandler = new Handler();
mUiThread = Thread.currentThread();
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
mHandler.post(action);
} else {
action.run();
}
}

68. Activity.java
final Handler mHandler = new Handler();
mUiThread = Thread.currentThread();
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
mHandler.post(action);
} else {
action.run();
}
}

69. Activity.java
final Handler mHandler = new Handler();
mUiThread = Thread.currentThread();
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
mHandler.post(action);
} else {
action.run();
}
}

70. Road Map

71. Overview
1. A Looper is created and attached to a thread.
2. Handler is created.
3. The Handler create a Message.
4. The Handler insert the Message into the Looper queue.
5. The Handler is consuming/executing the message.

72. Overview
ꢈ A Looper is created and attached to a thread.
ꢈ Handler is created.
ꢈ The Handler create a Message.
ꢈ The Handler insert the Message into the Looper queue.
ꢈ The Handler is consuming/executing the message.

73. Fancy thread
public class FancyThread extends Thread {
@Override
public void run() {
Looper.prepare();
// Code is missing for simplicity
Looper.loop();
}
}

74. Overview
✓ A Looper is created and attached to a thread.
ꢈ Handler is created.
ꢈ The Handler create a Message.
ꢈ The Handler insert the Message into the Looper queue.
ꢈ The Handler is consuming/executing the message.

75. Handler creation
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
// do stuff
}
};
mHandler = new Handler(new Handler.Callback()) {
@Override
public boolean handleMessage(Message msg) {
return false; // return true if msg consumed
}
});

76. Handler creation
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
// do stuff
}
};
mHandler = new Handler(new Handler.Callback()) {
@Override
public boolean handleMessage(Message msg) {
return false; // return true if msg consumed
}
});
//Or...

77. Handler creation
mHandler = new Handler(Looper looper) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
// do stuff
}
};
mHandler = new Handler(Looper looper, new Handler.Callback()) {
@Override
public boolean handleMessage(Message msg) {
return false; // return true if msg consumed
}
});

78. Handler creation
mHandler = new Handler(Looper looper) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
// do stuff
}
};
mHandler = new Handler( Looper looper, new Handler.Callback()) {
@Override
public boolean handleMessage(Message msg) {
return false; // return true if msg consumed
}
});
//Or...

79. Fancy thread
public class FancyThread extends Thread {
@Override
public void run() {
Looper.prepare();
mHandler = new Handler(Looper.myLooper(), callback);
Looper.loop();
}
}

80. Fancy thread
public class FancyThread extends Thread {
@Override
public void run() {
Looper.prepare();
mHandler = new Handler(Looper.myLooper(), callback);
Looper.loop();
}
}

81. Fancy thread
public class FancyThread extends Thread {
//...
public Handler getHandler() {
return mHandler;
}
}

82. Overview
✓ A Looper is created and attached to a thread.
✓ Handler is created.
ꢈ The Handler create a Message.
ꢈ The Handler insert the Message into the Looper queue.
ꢈ The Handler is consuming/executing the message.

83. Creating a Message

84. Creating a Message
// Data messages
Message.obtain(Handler h);
Message.obtain(Handler h, int what);
Message.obtain(Handler h, int what, Object o);
Message.obtain(Handler h, int what, int arg1, int arg2);
Message.obtain(Handler h, int what, int arg1, int arg2, Object o);
// Task message
Message.obtain(Handler h, Runnable task);

85. Creating a Message
// Data messages
Message.obtain(Handler h);
Message.obtain(Handler h, int what);
Message.obtain(Handler h, int what, Object o);
Message.obtain(Handler h, int what, int arg1, int arg2);
Message.obtain(Handler h, int what, int arg1, int arg2, Object o);
// Task message
Message.obtain(Handler h, Runnable task);

86. Creating a Message with Handler
Message msg = handler.obtainMessage(/*...*/);
this.obtainMessage(/*...*/);

87. Creating a Message
Message message = Message.obtain(); // Return empty message from pool
message.what = 4;
message.arg1 = 100;
message.arg2 = 200;
message.obj = new Object();
message.setData(bundle);

88. Creating a Message
Message message = new Message(); !! Avoid !!

89. Overview
✓ A Looper is created and attached to a thread.
✓ Handler is created.
✓ The Handler create a Message.
ꢈ The Handler insert the Message into the Looper queue.
ꢈ The Handler is consuming/executing the message.

90. “
Insert a Message
to the queue

91. “
Inserting message to the queue
// Data messages
boolean handler.sendMessage(msg);
boolean handler.sendMessageAtFrontOfQueue(msg);
boolean handler.sendMessageDelayed(msg, 2000);
// and more...

92. “
Inserting message to the queue
// Task messages
boolean handler.post(Runnable r)
boolean handler.postAtFrontOfQueue(Runnable r)
boolean handler.postDelayed(Runnable r, long delayMillis)
// and more...

93. “
Creating and Inserting message to the queue
// Reference to our Handler
Handler fancyHandler = mFancyThread.getHandler();
// Create data message with what = 1
Message msg = fancyHandler.obtainMessage(1);
// Adding the message to the queue
fancyHandler.sendMessage(msg);

94. “
Creating and Inserting message to the queue
// Reference to our Handler
Handler fancyHandler = mFancyThread.getHandler();
// Create data message with what = 1
Message msg = fancyHandler.obtainMessage(1);
// Adding the message to the queue
fancyHandler.sendMessage(msg);

95. “
Creating and Inserting message to the queue
// Reference to our Handler
Handler fancyHandler = mFancyThread.getHandler();
// Create data message with what = 1
Message msg = fancyHandler.obtainMessage(1);
// Adding the message to the queue
fancyHandler.sendMessage(msg);

96. “
Creating and Inserting message to the queue
// Reference to our Handler
Handler fancyHandler = mFancyThread.getHandler();
// Create data message with what = 1
Message msg = fancyHandler.obtainMessage(1);
// Adding task message to the queue
fancyHandler.post(new MyRunnable());

97. Removing a Message
from the queue

98. Removing a Message from the queue
// Remove task message
Handler.removeCallbacks(Runnable r);
// Remove data messages
Handler.removeMessages(int what);
// Remove everything
Handler.removeCallbacksAndMessages(null);
// AND more...

99. Removing a Message from the queue
// Remove task message
Handler.removeCallbacks(Runnable r);
// Remove data messages
Handler.removeMessages(int what);
// Remove everything
Handler.removeCallbacksAndMessages(null);
// AND more...

100. Removing a Message from the queue
// Remove task message
Handler.removeCallbacks(Runnable r);
// Remove data messages
Handler.removeMessages(int what);
// Remove everything
Handler.removeCallbacksAndMessages(null);
// AND more...

101. Overview
✓ A Looper is created and attached to a thread.
✓ Handler is created.
✓ The Handler create a Message.
✓ The Handler insert the Message into the Looper queue.
ꢈ The Handler is consuming/executing the message.

102. Consuming Data Message
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 1:
Logger.d("Received message type - 1");
break;
case 2:
Logger.d("Received message type - 2");
break;
}
}};

103. Consuming Task Message
// No extra work is needed.
fancyHandler.post(new Runnable() {
@Override
public void run() {
// Will run on the Handler thread.
}
});

104. Keep it clean!
Don’t forget to call quit()
on your Looper when it is no
longer needed!

105. FancyActivity.java
@Override
protected void onStop() {
super.onStop();
mFancyThread.getHandler().post(new Runnable() {
@Override
public void run() {
Looper.myLooper().quit();
}
});
}

106. FancyActivity.java
@Override
protected void onStop() {
super.onStop();
mFancyThread.getHandler().sendEmptyMessage(-1);
}

107. FancyActivity.java
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case -1:
Looper.myLooper().quit();
return true;
}
}

108. Looper.quit() VS .quitSafely()
.quit() .quitSafely()
– All pending in the queue, Including
messages ready to be dispatched -
are discarded.
– Looper won’t process new
messages.
– Discards only messages that are not
ready to dispatch. Ready messages
will be dispatched.
– Looper won’t process new
messages.
– Only from API 18.

109. Overview
✓ A Looper is created and attached to a thread.
✓ Handler is created.
✓ The Handler create a Message.
✓ The Handler insert the Message into the Looper queue.
✓ The Handler is consuming/executing the message.

110. 113
Phew… Questions?

111. 114
P.S:
The Main thread is
just a “regular”
thread with a Looper.

112. The Main thread Looper
‒ The Main thread is the only thread with a Looper by default.
‒ The Looper cannot be stopped.
‒ You can access the Main thread Looper from anywhere
with: Looper.getMainLooper()

113. Main Thread Handler creation
Handler mainHandler = new Handler(Looper.getMainLooper());
mainHandler.post(new Runnable() {
@Override
public void run() {
Log.d(TAG, "I'm running on the Main thread.");
}
});

114. 117
Messages passing is a powerful
async mechanism
but it can be hard to implement
from scratch.
Luckily, You don’t have
too...

115. HandlerThread
Flexible tasks chaining in a queue.

116. HandlerThread - Example use
case
“Our app onboarding flow has 6 different
network calls.”

117. HandlerThread
- A Thread with a “free” Looper implementation.

118. HandlerThread
HandlerThread handlerThread = new HandlerThread("MyHandlerThread");
//Make sure to call start() before creating the Handler!
handlerThread.start();
Handler handler = new Handler(mMyHandlerThread.getLooper());
Accessing the
thread looper

119. HandlerThread - Stopping
handlerThread.quit();
// or
handlerThread.quitSafely(); // API >= 18

120. HandlerThread- don’t forget
- Remember to quit().
- Call start() before calling getLooper().

121. HandlerThread
- Flexible, reusable tasks chaining.
- Guarantees thread safety.
- Implementation can take a while.

122. ThreadPoolExecutor
Easy work distribution between multiple threads.

123. ThreadPoolExecutor -
Example use case
“I need to allow my users to upload
multiple pictures from their gallery
simultaneously.”

124. ThreadPoolExecutor
– Managing a pool of thread.
– Creating/terminating threads as necessary.
– Utilize the Executor interface.

125. Executor.java
public interface Executor {
void execute(Runnable command);
}

126. Pre-defined Executors
// Single thread is executing the tasks in order.
Executors.newSingleThreadExecutor();
// Keeping the number of threads constant.
Executors.newFixedThreadPool(n);
// Dynamic size pool - grows/shrinks as needed.
// with 60 sec idle time per thread.
Executors.newCachedThreadPool();

127. Pre-defined Executors
// Single thread is executing the tasks in order.
Executors.newSingleThreadExecutor();
// Keeping the number of threads constant.
Executors.newFixedThreadPool(n);
// Dynamic size pool - grows/shrinks as needed.
// with 60 sec idle time per thread.
Executors.newCachedThreadPool();

128. Pre-defined Executors
// Single thread is executing the tasks in order.
Executors.newSingleThreadExecutor();
// Keeping the number of threads constant.
Executors.newFixedThreadPool(n);
// Dynamic size pool - grows/shrinks as needed.
// with 60 sec idle time per thread.
Executors.newCachedThreadPool();

129. How it works?
Task
ThreadPoolExecutor
Threads Pool
Queue

130. How it works?
Task
ThreadPoolExecutor
Threads Pool
Queue

131. How it works?
ThreadPoolExecutor
Threads Pool
Queue

132. How it works?
Task
ThreadPoolExecutor
Threads Pool
Queue

133. How it works?
Task
ThreadPoolExecutor
Threads Pool
Queue

134. How it works?
ThreadPoolExecutor
Threads Pool
Queue

135. Stopping ThreadPoolExecutor
mExecutor.shutdown();
mExecutor.shutdownNow();

136. ThreadPoolExecutor
– Easy to deal with threads work distribution.
– Useful out-of-the-box implementations available.
– Implementing efficiently requires time.

137. Summary
– All the threads are made from 3 main components:
Looper, Handler and Messages.
– We can create our own thread just like android system
does.
– Android can make our lives easier if we choose to use
the (kind of) out of box ready components.

138. Eden Bugdary Machluf
Thank you!