Please! Stop asking me these questions about multithreading

[[340332]]

This article is reprinted from the WeChat public account "Code Farmer Tian Xiaoqi", the author is Xiaoqi Benqi. To reprint this article, please contact Code Farmer Tian Xiaoqi's public account.

Many students are troubled by multithreading because it is difficult to use it in their own projects, but it will be asked in any high-paying job interview. After all, large companies now use multithreading and high concurrency, so it is definitely not possible without a thorough understanding of this content.

Today's article, as a basic article on multithreading, first discusses the following issues:

• Why use multithreading?
• Program vs Process vs Thread
• 4 ways to create a thread?

Why use multithreading?

The emergence of any technology is to solve existing problems.

Previously, the Internet was mostly stand-alone services with a small scale; now it is more of a cluster service. If multiple users access the server at the same time, there will be many threads accessing it concurrently.

For example, in an e-commerce system, at the same time, such as during a rush sale at the top of the hour, a large number of users access the server at the same time, so the systems developed in the company now are basically multi-threaded.

Using multithreading does improve the efficiency of operation, but at the same time, we also need to pay special attention to the addition, deletion and modification of data, which is the thread safety issue, such as HashMap vs HashTable, Vector vs ArrayList mentioned before.

There are many ways to ensure thread safety, such as locking, but other problems may arise such as deadlock, so multi-threading related issues will be more troublesome.

Therefore, we need to understand the principles of multithreading and the problems it may cause and how to solve them in order to get a high-paying job.

Processes vs Threads

Program​

When talking about process, we have to talk about program first.

To put it simply, a program is a code, or a collection of instructions. For example, "WeChat.exe" is a program, and this file is ultimately executed by the CPU.

process

When a program is running, it is a process.

So the program is "dead" and the process is "alive".

For example, in the task manager, there are processes, which are applications that are "activated".

Q: Are these processes executed in parallel?

A single-core CPU can only execute one process in a time slice. However, because it switches very quickly, we cannot feel it, which creates an illusion of multiple processes. (A multi-core CPU is really executing in parallel.)

Q: What if the process is not completed?

When process A has executed a time slice but has not yet finished, in order to facilitate the next execution, it is necessary to save the data information that has just been executed. This is called "saving the scene".

Then, when you grab the resources to execute next time, you will first "restore the scene" and then continue execution.

This cycle repeats itself.

Such repeated saving and restoring are additional overhead and will also slow down the execution of the program.

Q: Is there a more efficient way?

If the two threads belong to the same process, there is no need to save and restore the scene.

This is the idea behind the NIO model, and it is also the reason why the NIO model is much more efficient than the BIO model. We will talk about this later.

thread

A thread is a specific execution path in a process, which is what actually does the work.

In a process, only one thread can be executed in a time slice, but because the time slice switching speed is very fast, it seems that they are carried out at the same time.

There is at least one thread in a process. For example, the main thread is the main() function we usually write, which is a user thread; and the gc thread is produced by the JVM, which is responsible for garbage collection and is a daemon thread.

Each thread has its own stack, which records the relationship between the methods in the thread.

But all threads in a process share the heap.

Then different processes cannot access each other's memory. Each process has its own memory space, which is virtual memory.

Through this virtual memory, each process feels that it owns the entire memory space.

The mechanism of virtual memory is to shield the limitations of physical memory.

Q: What if the physical memory is used up?

Using a hard disk, such as the paging file of a Windows system, is to put part of the virtual memory on the hard disk.

Correspondingly, the program will run very slowly at this time, because the read and write speed of the hard disk is much slower than the memory. It is a slowness that we can feel. This is why the computer will become stuck if too many programs are opened.

Q: How big is this virtual memory?

For a 64-bit operating system, each program can use 64 binary bits, which is a large space of 2^64!

If you are still unclear about binary content, reply "binary" in the official account to get the corresponding article~

Summarize

To summarize, in one time slice, a CPU can only execute one process.

After the CPU allocates resources to a process, the process starts running; the threads in the process compete for resources. Only one thread can execute in a time slice, and whoever grabs it first gets the resources.

Multi-process vs Multi-thread

Each process is independent, and a problem with process A will not affect process B;

Although threads also run independently, threads in a process share the same heap. If a thread is out of memory, all threads in the process are finished.

Therefore, multi-process can improve the fault tolerance of the system, and the biggest advantage of multi-threading is that communication between threads is very convenient.

Communication between processes requires the use of additional mechanisms, such as interprocess communication (IPC), or network transmission.

How to create a thread

A bunch of concepts have been discussed above. Next, let’s look at the specific implementation.

In Java, multithreading functionality is implemented through the java.lang.Thread class, so let's take a look at this class first.

From the document we can see that the Thread class directly inherits Object and it also implements the Runnable interface.

The official documentation also states two ways to create threads:

One way is to inherit from the Thread class and override run(). The run() method contains the code to be executed by this thread.

At startup, create an instance of the new class and call the start() method to start the thread.

The second is to implement the Runnable interface and implement run(). The run() method also contains the code to be executed by this thread;

The slightly different thing is that to start a thread, you need to create a new thread, pass the instance of the class that implements the Runnable interface just created into it, and then call start(), which is actually the proxy mode.

If the interviewer asks you if you have any other questions, you can also say:

Implement the Callable interface;

Start a thread through the thread pool.

But in fact, when using the thread pool to start a thread, it is also created in one of the first two ways.

I won’t go into detail about these two methods here, let’s take a closer look at the first two methods.

Inheriting the Thread class

 public class MyThread extends Thread {
 @Override
 public void run() {
 for ( int i = 0; i < 100; i++) {
 System.out.println ( "Xiao Qi 666:" + i) ;
 }
 }
 public   static void main(String[] args) {
        MyThread myThread = new MyThread();
 myThread.start();
 for ( int i = 0; i < 100; i++) {
 System.out.println ( "main thread" + i + ": Sister Qi 666" ) ;
 }
 }
 }

Here,

• The main function is the main thread, the entry point of the program, and executes the entire program;
• After the program starts executing, a new thread myThread is started, and "Xiao Qi" is output in this thread;
• The main thread executes in parallel and outputs "Main thread i: Sister Qi".
  

Let's take a look at the result. Two threads are praising me alternately.

Q: Why is the result different from what I ran?

In multi-threading, the results of each run may be different, because we cannot manually control which thread grabs the resources first at what time.

Of course, we can add priority to the thread, but a high priority cannot guarantee that the thread will be executed first. It can only be said that there is a greater probability of grabbing resources and executing first.

Implementing the Runnable interface

This method is used more often.

 public class MyRunnable implements Runnable {
 @Override
 public void run() {
 for ( int i = 0; i < 100; i++) {
 System.out.println ( "Xiao Qi 666:" + i) ;
 }
 } 
 
 public   static void main(String[] args) {
        new Thread(new MyRunnable()).start(); 
 
 for ( int i = 0; i < 100; i++) {
 System.out.println ( "main thread" + i + ": Sister Qi 666" ) ;
 }
 }
 }

The results are similar:

As mentioned above, the way to start a thread here is slightly different from the previous one, because the newly created class only implements the Runnable interface, so a thread is needed to "proxy" it, so we need to pass the instance of our newly created class into a thread, which is actually the proxy mode. This design pattern will be discussed in detail later.

summary

So which of these two methods is better?

It is better to use Runnable interface, mainly because of Java single inheritance.

Another thing to note is that when starting a thread, start() is used instead of run().

Calling run() just calls this method, which is a normal method call; while start() starts the thread, and then the JVM calls the run() of the thread.

Well, that's all for the first article on multithreading. This is mainly to help you review the basic concepts and help those who have not been exposed to multithreading to get started. If you want to read more articles about multithreading, remember to like and leave a message for me~