On Android multi-threaded programming

Multithreading in Android is actually multi-threading in Java SE, just for ease of use, Android encapsulates some classes, such as Asynctask, Handlerthread, etc., in the daily development process, we often need to perform some time-consuming operations, For example, to initiate a network request, in consideration of other external factors such as speed, the server may not immediately respond to our request, if you do not put this operation in the sub-thread to execute, it will cause the main thread is blocked, today we are from the basis of multi-threaded discussion

First, the basic usage of threads

For Andorid multithreading, we're talking about thread and Runnable. Normally we'll start a new thread as follows

1) inherit from thread to create child thread

Define a thread that only needs to create a new class to inherit from thread, and then override the parent class's Run method to

[Java]View PlainCopy

1. /**
2. * Inherit thread Create child thread
3. */
4. Class MyThread extends Thread {
5. @Override
6. public Void Run () {
7. //handling of specific logic
8. }
9. }

So how do you start this thread? Just create an instance of MyThread and call its start () method so that the code in the Run () method runs on the child thread, as follows:

[Java]View PlainCopy

1. New MyThread (). Start ();

2) Implement Runnable interface to create child threads

Inheritance is highly coupled, and more often we choose to implement a Runnable interface to implement a sub-thread, as follows:

[Java]View PlainCopy

1. /**
2. * Implement Runnable interface to create child threads
3. */
4. Class MyThread implements Runnable {
5. @Override
6. public Void Run () {
7. //handling of specific logic
8. }
9. }

If you use this notation, the method of starting the thread also needs to be changed accordingly, as follows:

[Java]View PlainCopy

1. MyThread MyThread = new MyThread ();
2. New Thread (MyThread). Start ();

The thread constructor takes a Runnable parameter, and the new MyThread is the object that implements the Runnable interface, so it can be passed directly into the thread's constructor, and then it's the same as above, calling the STA of thread RT () method, the code in the Run () method runs in the child thread.

3) Create child threads directly using anonymous classes

[Java]View PlainCopy

1. New Thread (new Runnable () {
2. @Override
3. public Void Run () {
4. //handling of specific logic
5. }
6. }). Start ();

If you do not want to define a class to implement the Runnable interface, you can also use the same way as the anonymous class, this implementation is the most common to us

These are the same things that we used when we created the child threads, basically the same as in Java

4) The difference between Thread and Runnable

In fact, thread is also a Runnable, it implements the Runnable interface, in the Thread class has a Runnable type of Target field, representing the task to be executed in this sub-thread, the code is as follows:

Thread Part Source code:

[Java]View PlainCopy

2. Public class Thread implements Runnable {
4. /* What'll be run. * *
6. private Runnable target;
8. /* The group of this thread * /
10. Private Threadgroup Group;
14. private String name;
16. /* 
18. * The requested stack size for this thread, or 0 if the creator did
20. * Not specify a stack size. It's up to the VM to do whatever it
22. * Likes with this number; Some VMs would ignore it.
24. */
26. private long stackSize;
30. /** 
32. * Initialize thread and add thread to Threadgroup
34. *
36. * @param g
38. * @param target
40. * @param name
42. * @param stackSize
44. */
46. private void init (Threadgroup g, Runnable Target, String name, long stackSize) {
48. Java.lang.Thread parent = CurrentThread ();
50. //group parameter is empty, gets the thread-only group for the current thread
52. if (g = = null) {
54. g = Parent.getthreadgroup ();
56. }
58. this.group = g;
60. this.name = name;
62. //Set Target
64. this.target = target;
66. / * Stash The specified stack size in case the VM cares * /
68. this.stacksize = stackSize;
70. }
74. Public Thread () {
76. Init (null, null, null, 0);
78. }
82. Public Thread (Runnable target) {
84. Init (null, target, null, 0);
86. }
90. Public Thread (threadgroup Group, Runnable target) {
92. Init (group, Target, null, 0);
94. }
98. Public Thread (Runnable target, String name) {
100. Init (null, target, name, 0);
102. }
106. Public Thread (threadgroup Group, Runnable Target, String name) {
108. Init (group, target, name, 0);
110. }
114. Public Thread (threadgroup Group, Runnable Target, String name,
116. long StackSize) {  
118. Init (group, target, name, stackSize);
120. }
124. /** 
126. * Start a new thread and execute the target run function if target is not empty
128. * No person executes the current object's run () method
130. */
132. public synchronized Void Start () {
134. //Call Nativecreate to start a new thread
136. Nativecreate (This, stackSize, daemon);
138. started = true;
140. }
144. @Override
146. public Void Run () {
148. if (target! = null) {
150. Target.run ();
152. }
154. }
156. }

Above is the part of thread source code, we see in fact thread also implemented the Runnable interface, and ultimately the thread is executed by the Runnable, rather than thread,thread just Runnable packaging, and through some states to manage the thread With scheduling, Runnable defines an executable task that has only one run () function with no return value, as follows:

[Java]View PlainCopy

2. Public interface Runnable {
4. /** 
6. * When a object implementing interface <code>Runnable</code> is used
8. * To create a thread, starting the thread causes the object ' s
10. * <code>run</code> method to being called in that separately executing
12. * Thread.
14. * <p>
16. * The general contract of the method <code>run</code> are it may
18. * Take any action whatsoever.
20. *
22. * @see Java.lang.thread#run ()
24. */
26. public abstract Void run ();
28. }

When a thread is started, the Target's run () function is executed in the child thread if the target of the thread is not NULL, otherwise the virtual machine executes the thread's own run () function

Second, the thread wait, sleep, join, yield

The basic usage of thread is relatively simple, usually the replication run () function, and then the thread's start () method starts the thread, and next we look at the difference between wait, sleep, join, yield

1) Wait

When a thread executes to the wait () method, it enters into a waiting pool associated with the object while freeing the object's machine lock so that other threads can access it, the user can use Notify, Nitifyall, or specify sleep time to wake up the thread in the current waiting pool, note: Wait () , notify (), Notifyall () must be placed in the Synchronized block, or an exception will be thrown

2) Sleep

This function is a static function of thread that causes the calling thread to go to sleep because sleep () is a static method of the thread class, so it cannot alter the object lock, so when the sleep () method is called in a Synchronized block, the thread sleeps, But the object's lock is not released, and other threads cannot access the object, even if sleep holds the lock on the object

3) Join

Wait for the target thread to finish before continuing execution

4) yield

Thread comity, the target thread is transitioning from the running state to the ready state, that is, giving up execution permissions so that other threads can take precedence, but other threads can take precedence over unknown

Third, thread pool

When we need to frequently create multiple threads for time-consuming operations, it is not a good way to go through the new thread every time, and every time new thread creates and destroys objects with poor performance, threads lack unified management, may create unlimited new threads, compete with each other, May consume too much system resources lead to deadlock, and lack of regular execution, periodic execution, thread interruption and other functions, Java provides 4 kinds of thread pool, it can effectively manage, dispatch threads, avoid excessive waste of system resources, its advantages are as follows:

1) Reuse of existing threads, reduce object creation, cost of destruction

2) can effectively control the maximum number of concurrent threads, improve the utilization of system resources, while avoiding excessive resource competition, to avoid clogging

3) Provide the functions of timing execution, regular execution, single thread, concurrency control, etc.

Simply put, the thread pool principle is simple to explain is to create multiple threads and management, the task submitted to the thread will be assigned to the thread pool to execute, through the thread pool unified scheduling, management makes multithreaded use more simple and efficient, such as:

The thread pool implements the Executorservice interface, and the interface defines the interface that is required to implement it, and its implementation is threadpoolexecutor and Scheduledthreadpoolexecutor. Threadpoolexecutor is the most common thread pool implementation we use, Scheduledthreadpoolexecutor is used to perform periodic tasks, and usually we do not create a thread pool directly from new, because the process of creating parameters is relatively complex, So the JDK provides us with a Executor factory class to simplify this process.

Guidelines for using thread pools:

1) do not queue up tasks that synchronize the results of other tasks, which can lead to deadlocks, where all the threads in the deadlock are occupied by tasks that wait for the result of the queued task, which in turn cannot execute because all threads are busy

2) Understand the task, to effectively adjust the size of the thread pool, you need to understand the tasks being queued and what they are doing

3) The size of the thread pool is basically to avoid two types of errors, too few threads or too many threads, fortunately for most applications, too much and too little leeway between the wide

Today's introduction of the basic are some of the theoretical things, and some may seem boring, we should understand it, and to Friday, I wish you a happy weekend

Reference: Guo Shindi Line code, Android advanced

On Android multi-threaded programming