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

This article will explain in detail how to create threads from Thread and Runnable interfaces as well as Callable. The content of the article is of high quality, so the editor shares it for you as a reference. I hope you will have some understanding of the relevant knowledge after reading this article.

I am a thread, my English name is Thread, although my scenery is boundless now, it seems that everyone knows it, but my life experience is tragic and strange.

First place: inherit Thread

Next, I'm going to show you my birth process, which is also my first life experience.

Creation method 1

The most original way to create a thread is to inherit the Thread class and override the run () method. The implementation code is as follows:

/ / creation method 1: inherit Thread class MyThread extends Thread {@ Override public void run () {System.out.println ("Hello, thread ~");}} / Test public class ThreadExample {public static void main (String [] args) {/ / create thread Thread thread = new MyThread (); / / start thread thread.start () }} variant method

The above method of creating a thread is a bit cumbersome. We can also use anonymous objects to directly override the run () method when creating the Thread class. The implementation code is as follows:

/ / variant 1: create thread Thread T1 = new Thread () {@ Override public void run () {System.out.println ("thread variant");}; / / start thread t1.start () anonymously; inherit the shortcomings of Thread

The design of the Java language is single inheritance, so when you inherit Thread, you can no longer inherit other classes.

In other words, if I stay with my biological mother (extends Thread) all the time, I won't get a good education, so I'm destined to be ordinary when I grow up, which may be why my mother passed me on to distant relatives.

The second mother: realizing Runnable

In the Java language, although it is not possible to implement multi-inheritance, it can implement multiple interfaces, so I lived like a fish in water at my second mother's house.

Mode 2 of creation

Similar to inheriting the Thread class, implementing the Runnable interface overrides the run () method. The specific implementation code is as follows:

Public class ThreadExample2 {/ / creation method 2: implement Runnable interface static class MyThread implements Runnable {@ Override public void run () {System.out.println ("Hello, Thread ~");}} / / Code Test public static void main (String [] args) {/ / create Runnable subclass MyThread myThread = new MyThread () / / create thread Thread thread = new Thread (myThread); / / start thread thread.start ();}} variant method 1: anonymous Runnable

The above interface that implements Runnable has a simpler implementation. We can use anonymous Runnable to create a thread, as shown in the following code:

/ / variant 1: anonymous Runnable mode Thread T2 = new Thread (new Runnable () {@ Override public void run () {System.out.println ("I am a thread variant ~");}}); / / start thread t2.start (); variant method 2:Lambda creates Runnable

After JDK 8, we can use Lambda expressions to manipulate the code, so we also have a simpler implementation for creating anonymous Runnable classes, as shown in the following code:

/ / Variety 2: use Lambda anonymous Runnable method Thread T3 = new Thread (()-> {System.out.println ("I am Mutant 2");}); / / start thread t3.start ()

Note: the above implementation code only supports JDK version 1.8 +.

The third mother: the richest man in the village

Although my first two mothers are very kind to me, it is too limited for me, who is arrogant and surprised that he wants to save the universe and maintain world peace in the future. so I have always wanted to go to the other side of the ocean to pursue my dream, but the financial resources of the "first two" mothers are not enough to support me to do so.

However, my second family and the richest family in the village are close friends. After learning about my ambition, their family is willing to give money to each other and help me go to the other side of the ocean to pursue my dream. So in gratitude, my second mother asked me to recognize the richest family as my godfather and godmother on the spot. In this way, I have a third mother.

Creation method 3

Although the first two creation methods are good, neither of them can receive the return value after thread execution, so Callable and Futrue are added after JDK 1.5 to receive the return value after thread execution. The specific implementation code is as follows:

Import java.util.Random; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; / * thread creation example 3 * / public class CreateThreadExample3 {/ / creation method 3: implement Callable interface static class MyCallable implements Callable {@ Override public Integer call () throws Exception {int num = new Random () .nextInt (10) System.out.println ("generate random number:" + num); return num;}} / / Code test public static void main (String [] args) throws ExecutionException, InterruptedException {/ / create Callable sub-object MyCallable callable = new MyCallable (); / / use FutureTask with Callable sub-object to get the execution result FutureTask futureTask = new FutureTask (callable) / / create thread Thread thread = new Thread (futureTask); / / start thread thread.start (); / / get the result of thread execution int result = futureTask.get (); System.out.println ("get the execution result of child threads in the main thread:" + result);}}

The execution result of the above code is as follows:

As can be seen from the above results, using Callable with FutrueTask can correctly get the return value after thread execution. And my story ends here, and I finally live up to the expectations of my three mothers. Although I can't save the universe and maintain world peace, I can also make some contributions in the programming world. this is the story of me and my three mothers.

The first-person "Thread" perspective talks about three ways to create threads. The first is to inherit Thread, but because the Java language does not allow multiple inheritance, you cannot inherit other classes after inheriting Thread, so there is a second way to implement the Runnable interface. However, although the first two implementations can create threads, they cannot receive the return value after thread execution, so there is a third implementation, Callable, through which we can get the return value after thread execution.

On how to create threads from the Thread and Runnable interfaces as well as Callable to share here, I hope the above can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

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.