Discussion about java multithreading

1. Topic introduction

Before starting to briefly describe the Java multi-threading mechanism, I have to complain about the poor technology sharing atmosphere in my country's IT industry and the incompetent Internet. Depth of technical solutions. When a guy who was new to Java asked me about Java multi-threading mechanism related issues, I asked him to seek help from Du Niang and let him first learn to try to solve the problem by himself; but he told me that he could not find what he wanted online. I also tried to search the Internet for a long time for information, but I really couldn't find any documents that were detailed and clearly stated. What's even more regrettable is that some documents that may have certain reference value need to be downloaded through abnormal means, such as registering, replying or even spending money to purchase. This will inevitably discourage many people, and ultimately nothing will happen.

I am not deliberately criticizing, but I hope that more people can learn to contribute like Stallman, the father of Linux freedom; if everyone can try to contribute, eventually everyone will Easier to request.

(In the future, when I have time, I will continue to classify and summarize Java knowledge points and put them in my CSDN personal blog; in addition to Java, I will also consider introducing other aspects of content. At that time Please stay tuned^( ..)^)

## 2. Similar problems in reality

Suppose you are the owner of a fast food restaurant. With your hard work, you have finally made the fast food restaurant busy and prosperous. In order to expand sales, you decided to add door-to-door food delivery services. The company's finance tells you that you can do this for expansion. The business has 120,000 yuan to spend. How will you spend the money at this time?

Of course there are many ways to control, and in control, you need to consider the number of people, the scope of food delivery, the form of food delivery, etc.; here we focus on the form of food delivery Details:

1) Buy a Chevrolet Sail;

2) Buy 15 battery cars;

                                                                                                                                                                                                      The remaining money after deducting basic costs such as employee salaries, is used to purchase food delivery tools. I have given two types of food delivery vehicles above. They both have their own advantages: First, the Chevrolet Sail can deliver food faster. speed, and can provide a wider range of food delivery; secondly, using battery carts as a food delivery vehicle can deliver to multiple customers at the same time, and the delivery cost is obviously lower. Between the two, what choice would you make?

It is obvious that the second food delivery vehicle is more practical: in comparison, the latter can handle more customers, and the waiting time of customers at the back is significantly shortened. Just imagine, if you called and ordered lunch, and it was only delivered to you at 6pm just because you were the 25th customer, how would you feel?

## In fact, the fast food restaurant owner’s consideration in choosing multiple battery carts for food delivery is exactly the same as the process’s choice of multi-thread control. Single-threaded programs often have very limited functions. In some cases, Certain areas may not even achieve the performance we expect. For example, when you want server data to be accessed by multiple customers at the same time, a single thread will make this idea come to nothing; in a single-threaded case, the needs of multiple customers will be stored in a stack and executed in sequence, relying on It is difficult for subsequent customers to have a better access experience.

The Java language provides excellent multi-threading support. A multi-threaded program can contain multiple sequential execution streams, and the multiple sequential execution streams do not interfere with each other. In general, using multi-threaded programming has the following advantages:

1) Memory data can be shared between multiple threads;

2) Multiple threads are executed concurrently and can complete multiple tasks at the same time;

3) The Java language has built-in multi-threading function support, thus simplifying multi-threaded programming in Java.

How to create multi-threads

(1) Inherit the Thread class: This method is generally not commonly used, considering that the newly created thread class needs to inherit other parent classes;

 MyThread

(2) Implement the Runnable interface: the most commonly used method

class MyThread implements Runnable{
　　@Overridepublic void run(){      //do something here             }
}

(3) Implement the Callable interface: This method is used when a result needs to be returned In the value scenario, implementing the Collable interface requires implementing its call() method

 class MyThread implements Callable<String>{
　　@Override
　　public String call() throws Exception{
 　　　　//do something here
　　　　return XXX;
　　}
　　
}

public class FutureMain{
　　public static void main(String[] args){
　　　　//构造FutureTask
　　　　FutureTask<String> future = new FutureTask<String>(new MyThread());
　　　　Thread t1 = new Thread(future);
　　　　t1.start();
　　　　//取得call()方法的返回值
　　　　System.out.println("返回值"+future.get());
　　}
}

Of course, in addition to the basic functions, JDK also provides some simple control functions for Future:

boolean cancle(boolean mayInterruptIfRunning);                       //取消任务boolean isCancelled();                                               //是否已经取消boolean isDone();                                                    //是否已完成

The above is the detailed content of Discussion about java multithreading. For more information, please follow other related articles on the PHP Chinese website!