Shulou(Shulou.com)06/03 Report--

This article mainly explains "how to understand Java multithreading". The content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "how to understand Java multithreading".

Processes and threads

The process is an execution process of the program and the basic unit in which the system runs the program, so the process is dynamic. The system runs a program is the process from a process to create, run and die. In Java, when we start the main function, we actually start a JVM process, and the thread in which the mian function is located is a thread in this process, called the main thread.

A thread is a smaller unit of execution than a process. A process can produce multiple threads during its execution. Unlike a process, multiple threads of the same kind share the heap and method area resources of the process, but each thread has its own program counter, virtual machine and local method stack, so the system is generating a thread, or switching between threads is a much less burden than a process, so a thread is also called a lightweight process.

Concurrency and parallelism

Concurrency: multiple tasks are being executed in the same period of time (not necessarily at the same time)

Parallel: multiple tasks are executed at the same time per unit time.

Context switching

In general, the number of threads in multithreaded programming is larger than the number of CPU cores, and a CPU core can only be used by one thread at any time. In order to make these threads execute effectively, CPU adopts the strategy of allocating time slices and rotating each thread. When a thread runs out of time slices, it will be back in the ready state for other threads to use, which is a context switch.

In other words, the current task saves its state before switching to another task after executing the CPU time slice, so that the state of the task can be loaded the next time the task is switched. The process of a task from saving to reloading is a context switch.

Sleep () and wait ()

The main difference is that the sleep () method does not release the lock, while the wait () method releases the lock.

Both can pause thread execution.

Wait () is typically used for inter-thread interaction / communication, and sleep () is usually used to pause execution.

After the wait () method is called, the thread does not automatically wake up (unless it times out) and requires another thread to call the notify () or notifyAll () method on the same object. After the sleep () method is executed, the thread automatically wakes up.

Start () and run ()

Why does the run () method execute when the start () method is called, and why can't the run () method be called directly?

When we new a Thread, the thread enters the new state, calls the start () method, starts a thread and puts it into the ready state, and then starts running after a time slice. Start () performs the corresponding preparation of the thread and then automatically executes the contents of the run () method, which is really multithreaded work.

Executing the run () method directly executes the run method as a normal method under a mainthread, not in a thread, so it's not multithreaded.

Synchronized keyword

The synchronized keyword is used to solve the synchronization of accessing resources between multiple threads, and can guarantee that only one thread can execute a method or block of code modified by it at any time.

Three main ways to use synchronized:

1. Modified instance method

Lock the current object instance, and obtain the lock of the current object instance before entering the synchronization code.

two。 Modify static method

Locking the current class will affect all object instances of the class, because static members are class members and do not belong to any instance object, so thread A calls the non-static synchronized method of an instance object, while thread B calls the static synchronized method of the class to which the instance object belongs. Because accessing static synchronized methods occupies the lock of the current class, while accessing non-static synchronized methods occupies the current instance object lock.

3. Decorate code block

Specifies the locked object and acquires the lock of the given object before entering the synchronous code base.

Synchronized and ReentrantLock:

1. Both are reentrant locks, that is, you can acquire your own internal locks again. For example, if a thread acquires a lock on an object, the object lock has not yet been released, and it can still acquire it when it wants to acquire the lock of the object again.

two。 The former relies on JVM while the latter relies on API synchronized, which is implemented on JVM, and ReentrantLock on the JDK level. 3.ReentrantLock has more advanced functions than synchronized. ReentrantLock has three main points: ① waits for interruptible ② to achieve fair lock ③ can achieve selective notification.

Volatile keyword

Under the current Java memory model, threads can save variables to local memory (such as registers) instead of reading and writing directly in main memory. This may cause one thread to modify the value of a variable in main memory, while another thread continues to use a copy of its variable value in the register, resulting in data inconsistency.

The volatile keyword solves this problem, indicating that the variable JVM is unstable and has to be read into main memory every time it is used. In addition, another important role is to prevent rearrangement.

Three important features of concurrent execution:

1. Atomicity either all operations are performed and will not be interrupted by any interference, or all operations are not performed. Synchronized can be used to ensure the atomicity of the code.

two。 Visibility when a shared variable is modified, other threads can immediately see the latest value after the modification. Volatile ensures visibility.

3. The sequence of the ordered code in the process of execution, the optimization of Java in the compiler and at run time, the execution order of the code is not necessarily the order in which the code is written, that is, instruction rearrangement. Volatile can disable instruction rearrangement optimization.

ThreadLocal

Usually, the variables we create can be accessed and modified by any thread. What if you want to realize that each thread has its own local variables? This requires the ThreadLocal class.

The main problem of the ThreadLocal class is to bind each thread to its own value. The ThreadLocal class can be compared to a box for storing data, in which private data can be stored for each thread.

When a ThreadLocal variable is created, every thread that accesses the variable has a local copy of the variable, which is where the ThreadLocal name comes from. You can use the get () and set () methods to get the default value or change its value to the value of the copy stored by the current thread, thus avoiding thread safety issues.

In fact, the ThreadLocal class has a static inner class ThreadLocalMap, which can be thought of as a HashMap customized by the ThreadLocal class, and the final variable is placed in the ThreadLocalMap of the current thread, not on the ThreadLocal class. The ThreadLocal class can be seen as an encapsulation of ThreadLocalMap, passing a value.

If two ThradLocal objects are declared in the same thread, the only ThreadLocalMap inside the Thread will be used to store the data. The key of TheadLocalMap is the ThreadLocal object, and value is the value set by calling the set method of the ThreadLocal object.

The key used by ThreadLocalMap is a weak reference to ThreadLocal, while value is a strong reference. So if the ThreadLocal is not strongly referenced from the outside, the key will be cleaned up during garbage collection, but the value will not be cleaned up. In this way, an Entry with a key of null appears in the ThreadLocalMap. If we don't do anything, value can never be recycled by GC, and memory leaks may occur at this time. This situation has been taken into account in the ThreadLocalMap implementation, where records with key of null are cleaned up when the set (), get (), and remove () methods are called. It is best to call the remove () method manually after using the ThreadLocal method.

Thread pool

Pooling technology should be familiar with, thread pooling, database connection pooling, Http connection pooling and so on are all applications of this idea. The main idea of pooling technology is to reduce the consumption of resources each time and improve the utilization of resources. Using thread pools, you can reduce resource consumption, improve response speed, and improve thread manageability.

Runnable and Callable

The Runnable interface does not return a result or throw a check exception, but the Callable interface can. The utility class Excutors can realize the conversion between Runnable objects and Callable objects.

@ FunctionalInterfacepublic interface Runnable {/ / has no return value and cannot throw exceptions public abstract void run ();} execute () and submit ()

The execute () method is used to submit a task that does not require a return value, so it is not possible to determine whether the task was successfully executed by the thread pool.

The submit () method is used to submit tasks that require a return value. The thread pool returns an object of type Future, which can be used to determine whether the task executed successfully or not.

Create a thread pool

Implemented through the constructor ThreadpoolExecutor (described below).

Implemented through the utility class Executors (not recommended) ThreadPoolExecutor:.

FixedThreadPool: this access returns a thread pool with a fixed number of threads. The number of threads in this thread pool remains the same. When a new task is submitted, if there are idle threads in the thread pool, it is executed immediately. If not, the new task is temporarily stored in a task queue, and when a thread is idle, the task in the task queue is processed.

SingleThreadExecutor: the method returns a thread pool with only one thread. If more than one task is submitted to the thread pool, the task is saved in a task queue, waiting for the thread to be idle and executing the tasks in the queue in first-in, first-out order.

CachedThreadPool: this method returns a thread pool that can adjust the number of threads according to the actual situation. The number of threads in the thread pool is uncertain, but if there are idle threads that can be reused, reusable threads are preferred. If all threads are working and new tasks are submitted, a new thread is created to process the task. After the execution of the current task, all threads will return to the thread pool for reuse.

ThreadPoolExecutor

Analysis of important parameters of ThreadPoolExecutor constructor:

CorePoolSize: the number of core threads defines the number of threads that can run at the same time.

MaximumPoolSize: when the tasks stored in the queue reach the queue capacity, the current number of threads that can be run at the same time becomes the minimum number of threads.

WorkQueue: when a new task arrives, it will first determine whether the number of threads currently running reaches the number of core threads, and if so, the new task will be stored in the queue.

KeepAliveTime: when the number of threads in the thread pool is less than corePoolSize, if no new task is submitted at this time, threads outside the core will not be destroyed immediately, but will wait until the waiting time exceeds keepAliveTime before being recycled and destroyed.

The time unit of the unit:keepAliveTime parameter.

ThreadFactory:executor will notice when it creates a new thread.

Handler: saturation strategy ① ThreadPoolExecutor.AbortPolicy: throws a RejectedExecutionException to reject the processing of new tasks. ② ThreadPoolExecutor.CallerRunsPolicy: call the thread running task that runs the server. It will slow down the submission speed for new tasks, affect the overall performance of the program, and increase the queue capacity. ③ ThreadPoolExecutor.DiscardPolicy: don't deal with new tasks, just discard them. ④ ThreadPoolExecutor.DiscardOldestPolicy: this policy discards the earliest outstanding task requests.

Demo

After simulating 10 tasks, we have configured 5 core threads and 100 waiting queues, so only 5 tasks can be executed at a time, and the remaining 5 tasks will be placed in the waiting queue. The remaining 5 tasks will not be completed until the current 5 tasks have been completed.

Public class MyRunnable implements Runnable {private String command; public MyRunnable (String s) {this.command = s;} @ Override public void run () {System.out.println (Thread.currentThread (). GetName () + "start time:" + new Date ()); processCommand (); System.out.println (Thread.currentThread (). GetName () + "end time:" + new Date ());} private void processCommand () {try {Thread.sleep (3000) / / Let it take 3 seconds to execute the task} catch (InterruptedException e) {e.printStackTrace ();}} @ Override public String toString () {return this.command;}} public class Demo {private static final int CORE_POOL_SIZE = 5 private static final int MAX_POOL_SIZE / the number of threads in the kernel is 5 private static final int MAX_POOL_SIZE = 10 private static final Long KEEP_ALIVE_TIME / the number of most expensive threads is 10 private static final int QUEUE_CAPACITY = 100 private static final Long KEEP_ALIVE_TIME / capacity 100 private static final Long KEEP_ALIVE_TIME = 1L / / the waiting time is 1L public static void main (String [] args) {/ / create ThreadPoolExecutor executor = new ThreadPoolExecutor (CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS, new ArrayBlockingQueue (QUEUE_CAPACITY), new ThreadPoolExecutor.CallerRunsPolicy ()) through the definition parameter of the ThreadPoolExecutor constructor definition; / / saturation policy for (int I = 0; I < 10 WorkerThread +) {/ / create WorkerThread object (WorkerThread class implements Runnable connection) Runnable worker = new MyRunnable ("" + I); executor.execute (worker); / / execute Runnable} executor.shutdown (); / / final thread pool while (! executor.isTerminated ()) {} System.out.println ("end") }} / * the running results are as follows: pool-1-thread-3 start time: Mon Mar 29 22:46:02 CST 2021pool-1-thread-2 start time: Mon Mar 29 22:46:02 CST 2021pool-1-thread-4 start time: Mon Mar 29 22:46:02 CST 2021pool-1-thread-5 start time: Mon Mar 29 22:46:02 CST 2021pool-1-thread-1 start time: Mon Mar 29 22:46:02 CST 2021pool-1 -thread-2 end time: Mon Mar 29 22:46:07 CST 2021pool-1-thread-2 start time: Mon Mar 29 22:46:07 CST 2021pool-1-thread-3 end time: Mon Mar 29 22:46:07 CST 2021pool-1-thread-3 start time: Mon Mar 29 22:46:07 CST 2021pool-1-thread-4 end time: Mon Mar 29 22:46:07 CST 2021pool-1-thread-4 start time: Mon Mar 29 22:46 07 CST 2021pool-1-thread-5 end time: Mon Mar 29 22:46:07 CST 2021pool-1-thread-5 start time: Mon Mar 29 22:46:07 CST 2021pool-1-thread-1 end time: Mon Mar 29 22:46:07 CST 2021pool-1-thread-1 start time: Mon Mar 29 22:46:07 CST 2021pool-1-thread-2 end time: Mon Mar 29 22:46:12 CST 2021pool-1-thread-3 end time: Mon Mar 29 22:46:12 CST 2021pool-1-thread-4 end time: Mon Mar 29 22:46:12 CST 2021pool-1-thread-5 end time: Mon Mar 29 22:46:12 CST 2021pool-1-thread-1 end time: Mon Mar 29 22:46:12 CST 2021 end * / Thank you for your reading The above is the content of "how to understand Java multithreading". After the study of this article, I believe you have a deeper understanding of how to understand Java multithreading, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.