Program process Basic concept of thread

Program

To accomplish a specific task , A collection of instructions written in a language . That is, a piece of static code , Static objects .

process

It's an execution of the program , Or a running program . It's a dynamic process ： It has its own production , The process of existence and extinction , Life cycle .
Is the unit of resource allocation , At run time, the system allocates different memory areas for each process .

Threads

Processes can be further refined into threads , It's an execution path inside a program .
One Java Applications java.exe, There will be at least three threads :main( The main thread ) gc() Garbage collection thread , Exception handling threads
Thread as the unit of scheduling and execution , Every thread It has independent running stack and program counter , Low cost of thread switching .
Multiple threads in a process share the same memory unit / Memory address space -> They allocate objects from the same heap , You can access the same variables and objects . This makes inter thread communication easier and more efficient , However, the shared system resources operated by multiple threads may bring security risks .

Parallel and concurrent

parallel : Multiple CPU Perform multiple tasks at the same time
Concurrent : One CPU Perform multiple tasks at the same time

Memory structure diagram

Multiple threads share the method area and heap , Each thread has its own virtual machine stack and program counter

Thread creation and startup

Java Linguistic JVM Allow programs to run multiple threads , It passes through java.lang.Thread Class .

Thread Class

1. Each thread passes through a particular Thread Object's run() Method to complete the operation , Often run() The body of the method is called the thread body .
2. Through the Thread Object's start Method () To start this thread , Instead of calling directly run()

Mode one ： Inherit Thread

1. Create and inherit from Thread Subclasses of classes
2. rewrite Thread Class run() Method , The operations that the thread needs to perform can be declared in run In the method .
3. establish Thread Subclass object
4. Call through this object start()

// Multithreading creation   Mode one : Inherit Thread class 
class MyThread extends Thread{
    
    // rewrite run Method 
    @Override
    public void run() {
    
        for(int i=0;i<100;i++){
    
            System.out.println(i);
        }
    }
}
public class ThreadTest {
    
    public static void main(String[] args) {
    
        MyThread myThread = new MyThread();
        // Enable the current thread and call the current thread's run Method   It can only be called once 
        myThread.start();
        // The printed effect is and run() Mixed in the method   This indicates that there are two threads executing 
        for(int i=0;i<100;i++){
    
            System.out.println(i+"******main Threads ******");
        }
    }
}

Thread The common method of

start()

Start thread , And execute the object's run() Method

run()

The operation that a thread performs when it is scheduled

String getName()

Returns the name of the thread

void setName(String name)

Set the thread name

static Thread currentThread()

Returns the current thread . stay Thread In subclass is this, It is usually used for the main thread and Runnable Implementation class .

yield()

Thread concession , Pause the currently executing thread , Give the execution opportunity to threads with the same or higher priority .

join()

In a thread a Calling thread b Of join() Method , The thread a It's blocked , Until the thread b After full implementation , Threads a To end the blocking .

static void sleep(long millis)

Causes the current active thread to abandon within a specified time CPU control , Give other threads a chance to be executed , When the time is up, the current thread will start executing .

stop()

Force end of thread life cycle , Obsolete and not recommended

boolean isAlive()

return boolean, Determine if the thread is alive