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

This article mainly introduces "what are the methods to achieve Java threads". In daily operations, I believe that many people have doubts about the methods of realizing Java threads. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful to answer the doubts about "what are the methods to achieve Java threads?" Next, please follow the editor to study!

Understand two things: why is there essentially only one way to implement threads? How is it better to implement the Runnable interface than to inherit the Thread class implementation thread?

1: common ways to implement threads: implement Runable interface public class RunnableThread implements Runnable {@ Override public void run () {System.out.println ("implementing threads with Runnable interface");} public static void main (String [] args) {Thread thread=new Thread (new RunnableThread ()); thread.start ();}}

As shown in the code, you first implement the Runnable interface through the RunnableThread class, then override the run () method, and then you just need to pass this instance that implements the run () method to the Thread class to implement multithreading.

2: inherit the Thread class public class ExtendsThread extends Thread {@ Override public void run () {System.out.println ("implementing threads with inherited Thread classes");}}

Unlike the first approach, it does not implement the interface, but inherits the Thread class and overrides the run () method in it.

3: thread pool creates threads

Here is the source code in the thread pool to see how the thread pool implements threads:

/ * The default thread factory * / static class DefaultThreadFactory implements ThreadFactory {private static final AtomicInteger poolNumber = new AtomicInteger (1); private final ThreadGroup group; private final AtomicInteger threadNumber = new AtomicInteger (1); private final String namePrefix; DefaultThreadFactory () {SecurityManager s = System.getSecurityManager (); group = (s! = null)? S.getThreadGroup (): Thread.currentThread (). GetThreadGroup (); namePrefix = "pool-" + poolNumber.getAndIncrement () + "- thread-" } public Thread newThread (Runnable r) {Thread t = newThread (group, r, namePrefix + threadNumber.getAndIncrement (), 0); if (t.isDaemon ()) t.setDaemon (false) If (t.getPriority ()! = Thread.NORM_PRIORITY) t.setPriority (Thread.NORM_PRIORITY); return t;}}

For thread pools, threads are essentially created through a thread factory, which defaults to DefaultThreadFactory, which sets some default values for threads created by the thread pool, such as the name of the thread, whether it is a daemon thread, and the priority of the thread. But in the end, threads are created through new Thread (), but with a little more parameters.

4: Callable creation thread public class CallableTask implements Callable {@ Override public Integer call () throws Exception {return new Random (). NextInt ();} public static void main (String [] args) throws ExecutionException, InterruptedException {ExecutorService executorService = Executors.newFixedThreadPool (10); Future future = executorService.submit (new CallableTask ()); System.out.println (future.get ()); System.out.println (future.isDone ()) System.out.println (future.isCancelled ());}}

The Runnable creation thread has no return value, while Callable and its associated Future, FutureTask, can return the result of the thread execution as a return value, as shown in the code, implements the Callable interface, and sets its generics to Integer, and then it returns a random number.

However, both Callable and FutureTask, first of all, like Runnable, are a task that needs to be executed, not that they are threads themselves. They can be executed in a thread pool, as shown in the code. The submit () method puts the task into the thread pool, and the thread is created by the thread pool. No matter what method is used, it is ultimately executed by the thread, while the creation of child threads is still inseparable from the two basic ways mentioned at the beginning, that is, implementing the Runnable interface and inheriting the Thread class.

5: anonymous inner class, lambda expression creation thread public static void innerClassThread () {new Thread (new Runnable () {@ Override public void run () {System.out.println ("anonymous inner class creation thread");}}) .start () } public static void lambdaThread () {new Thread (()-> {System.out.println ("lambda expression creation thread");}) .start ();}

In fact, anonymous inner classes or lambda expressions create threads, which only implement threads at the syntax level, and cannot be attributed to the way of implementing multithreading, as shown in the code of anonymous inner classes implementing threads, which simply uses an anonymous inner class to send the Runnable that needs to be passed in to the instance.

Second: why is there essentially only one way to implement threads?

After learning about the above ways to create threads, we find that all the other ways to create threads are just a layer of encapsulation outside new Thread (); the only difference is that the thread runs differently.

Implement the content of thread execution by implementing the Runnable interface

The start () method needs to be called to start the thread, and the start () method will eventually call the run () method. The source code of the run () method in Thread is as follows:

/ * What will be run. * / private Runnable target; @ Override public void run () {if (target! = null) {target.run ();}}

Target is actually a Runnable, and what the actual thread executes is the run method in the interface of the Runnable.

Implements what the thread executes, inheriting the way the Thread class overrides the run () method

The start () method needs to be called to start the thread, and the start () method will eventually call the run () method, but the run () method at this time has been overridden by the subclass because of inheritance, so what the thread executes at this time is the run method of the subclass.

The running content mainly comes from two places, either from target or from the run () method overridden by subclasses. So it can be summarized as follows: in essence, there is only one way to implement a thread, new Thread (), but there are two ways to implement what a thread executes, either by implementing the Runnable interface, or by inheriting the way the Thread class overrides the run () method, passing in the code we want to execute and let the thread execute.

Third: how is it better to implement the Runnable interface than to inherit the Thread class implementation thread?

There is only one run () method in Runnable, which defines what needs to be executed. In this case, the Runnable class is decoupled from the Thread class, and the Thread class is responsible for thread startup and property setting.

The reason for java single inheritance is that once a class inherits the Thread class, it has no way to inherit other classes later, which limits the future extensibility of the code.

In some cases, performance can be improved. If you inherit the Thread class, you need to create a new independent thread each time a task is executed; by implementing the Runnable interface, you can transfer the task directly to the thread pool and use some fixed threads to complete the task, eliminating the need to destroy new threads each time, which greatly reduces the performance overhead.

At this point, the study of "what are the ways to implement Java threads" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

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.