1. Environment
idea
2. Why use multithreading
As the saying goes: When people gather firewood, the flame is high. Why not let one person pick up firewood! ! ! Unity of course! ! But the most important thing is to improve efficiency
So the same is true in the program. You can talk about a thread as a person. In order to speed up the program efficiency, multithreading appears.
3. What is a thread
Interview Question: What is the difference between a thread and a process
Answer: A thread is a way of running a program, and a process is a collection of threads
4. How to create a thread
For multi-threaded execution, we ignore the minimum error by default. The default is to execute at the same time. As for who executes first, it depends on who can strengthen the execution right of the CPU first.
4.1 Implement the Thread class
public class ThreadTest extends Thread { // Override the run method of the Thread type @Override public void run() { System.out.println( "The child thread runs -------" ); // The logic code executed by the thread for ( int i=0;i<20;i++ ){ System.out.println(getName()+"i:"+i); } System.out.println( "Thread end" ); } }
Create test class
public static void main(String[] args) { ThreadTest threadTest = new ThreadTest(); // Create thread threadTest.start(); // Start thread for(int i=0;i<20;i++){ System.out.println(Thread.currentThread().getName() +"i:"+i); // The code that the main thread needs to run } }
Why not use the thread.run() method to start multithreading: Since we create threads like ordinary new objects, using the run method is equivalent to calling methods, rather than starting multithreading
4.2 Inheriting the Runnable interface
public class ThreadTest implements Runnable { // Rewrite the run method of Thread type public void run() { System.out.println( "The child thread runs -------" ); // The logic code executed by the thread for ( int i=0;i<20;i++ ){ System.out.println(Thread.currentThread().getName()+"i:"+i); } System.out.println( "Thread end" ); } }
Create test class
public static void main(String[] args) { ThreadTest threadTest=new ThreadTest();//创建线程 Thread thread=new Thread(threadTest); thread.start(); // Start thread for(int i=0;i<20;i++){ System.out.println(Thread.currentThread().getName() +"i:"+i); // The code that the main thread needs to run } }
Comparing this method with the previous one, it can be seen that the two methods of creating threads are different
Interview question: Is it better to use the inherited Thred class or implement the Runnable interface to create a thread?
Answer: It is good to implement the Runnable interface, because Java only supports single inheritance, but supports multiple implementations
4.3 Use anonymous inner classes to create multithreading
public static void main(String[] args) { Thread thread = new Thread( new Runnable() { // Anonymous inner class public void run() { // Business logic code for ( int i=0;i<20;i++ ){ System.out.println(Thread.currentThread().getName()+"子线程i:"+i); } } }); thread.start(); for ( int i=0;i<20;i++){ // Main thread logic code System.out.println(Thread.currentThread().getName()+"i:"+ i); } }
4.4 Common APIs for Multithreading
Common thread api methods |
|
start() |
start thread |
currentThread() |
Get the current thread object |
getID() |
Get the current thread ID Thread- number The number starts from 0 |
getName() |
Get the current thread name |
sleep(long mill) |
sleeping thread |
Stop() |
stop the thread, |
Common thread constructor |
|
Thread() |
Allocate a new Thread object |
Thread(String name) |
Allocates a new Thread object with the specified name as its name . |
Thread(Runable r) |
Allocate a new Thread object |
Thread(Runable r, String name) |
Allocate a new Thread object |
Five. Mutual conversion of several states of multi-threading
5.1 New state
When a thread is created with the new operator, such as new Thread(r) , the thread has not yet started running, and the thread is in a new state. When a thread is in the nascent state, the program has not yet started running the code in the thread
5.2 Ready state
A newly created thread does not automatically start running. To execute the thread, the thread's start() method must be called. When the thread object calls the start() method, the thread is started. The start() method creates the system resources for the thread to run, and schedules the thread to run the run() method. When the start() method returns, the thread is in the ready state.
The thread in the ready state does not necessarily run the run() method immediately, the thread must also compete with other threads for CPU time, and the thread can only be run if the CPU time is obtained. Because in a single- CPU computer system, it is impossible to run multiple threads at the same time, and only one thread is running at a time. So there may be multiple threads in the ready state at this point. Threads that are in the ready state are scheduled by the Java runtime system's thread scheduler .
5.3 Operational Status
When the thread gets CPU time, it enters the running state and actually starts to execute the run() method .
5.4 Blocking state
During the running process of the thread, it may enter the blocking state for various reasons :
1> The thread enters the sleep state by calling the sleep method;
2> The thread calls an operation that is blocked on I/O , that is, the operation does not work until the input and output operations are completed. will return to its caller;
3> the thread is trying to get a lock, and the lock is being held by another thread;
4> the thread is waiting for a trigger condition;
5.5 State of death
There are two reasons why a thread dies:
1) the run method exits normally and dies naturally,
2) an uncaught exception terminates the run method and the thread dies suddenly.
In order to determine whether the thread is currently alive (that is, it is either runnable or blocked), the isAlive method needs to be used. This method returns true if it is runnable or blocked ; if the thread is still new and not runnable, or if the thread dies, it returns false.
6. The role of join() method
To call the join() method of that thread is to execute the current thread when that thread is finished executing
E.g:
public static void main(String[] args) { final Thread thread1= new Thread( new Runnable() { // Anonymous inner class public void run() { // Business logic code for ( int i=0;i<20; i++ ){ System.out.println(Thread.currentThread().getName()+"子线程i:"+i); } } }); Thread thread2 = new Thread( new Runnable() { // Anonymous inner class public void run() { // business logic code try { thread1.join(); } catch (InterruptedException e) { e.printStackTrace (); } for (int i=0;i<20;i++){ System.out.println(Thread.currentThread().getName()+"子线程i:"+i); } } }); thread2.start(); thread1.start(); }
Result: without thread1.join()
join thread1.join()