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

This article mainly introduces "how to create and run threads in Java concurrent programming". In daily operations, I believe that many people have doubts about how to create and run threads in Java concurrent programming. Xiaobian 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 "how to create and run threads in Java concurrent programming". Next, please follow the editor to study!

I. there are five ways to create and run threads. First, inherit the Thread class.

This way is the most basic way, friends who have studied java all know, do not repeat. It is important to note that the override implementation uses the run method and the running thread is the start method.

Public class FirstWay extends Thread {@ Override public void run () {System.out.println ("the first way to implement threads: inheriting the Thread class");} / / Simulation test public static void main (String [] args) {new FirstWay (). Start ();}} second: implement the Runnable interface

The second implementation is still very basic, inheriting the Runnable interface and rewriting the run method to implement thread running logic. It is important to note that the running thread needs to have a layer of new Thread.

Public class SecondWay implements Runnable {@ Override public void run () {System.out.println ("the second way to implement threads: implementing the Runnable interface");} / / Simulation test public static void main (String [] args) {new Thread (new SecondWay ()). Start ();}} third: implement the Callable interface

The third way is to implement the Callable interface, and both the Callable interface and the Runable interface can implement threads.

Public class ThirdWay implements Callable {@ Override public String call () throws Exception {System.out.println ("the third way to implement threads: implementing the Callable interface"); return "Callable interface with a return value and can throw an exception";} / / Simulation test public static void main (String [] args) throws ExecutionException, InterruptedException {FutureTask futureTask = new FutureTask (new ThirdWay ()); new Thread (futureTask) .start () / / blocking method, get the return value of call method System.out.println (futureTask.get ()); / / print: Callable API with a return value, you can throw an exception}}

The differences are as follows:

The threading method of Callable interface is call, and the threading method of Runable interface is run.

Callable has a return value. Runable API cannot have a return value.

The return value of the Callable interface method call can be set to be generic. The String data type is used in the following example

Callable interface method call method can throw an exception, while Runable interface run method cannot throw an exception

The Callable interface method runs through new Thread (futureTask). Start (), and the get method of FutureTask can get the return value of the Callable interface method call method

If the Callable interface method call method is abnormal, the same exception will be thrown when the get method of FutureTask is called

Fourth: thread pool + execute

Starting from the JDK5 version, java provides thread pool support by default. Running threads in a thread pool way can avoid application downtime caused by unlimited thread expansion, and also save resources and time costs for thread creation and destruction frequently.

Public class FourthWay implements Runnable {@ Override public void run () {System.out.println (Thread.currentThread (). GetName () + ": Runnable interface is implemented in a different way, using thread pool");} public static void main (String [] args) {/ / create a fixed thread pool ExecutorService threadPool = thread (5) For (int I = 0 * I < 10 * I * * +) {threadPool.execute (new FourthWay ());}

Thread pool ExecutorService uses the execute method to run the thread implementation of the Runnable interface run method. The common feature of the execute method and the run method is that there is no return value.

Pool-1-thread-5: implement thread Runnable interface, but run differently. Use thread pool pool-1-thread-2: implement thread Runnable interface, but run differently. Use thread pool pool-1-thread-4: implement thread Runnable interface, but run differently. Use thread pool pool-1-thread-4: implement thread Runnable interface, but run differently. Use thread pool pool-1-thread-4: implement thread Runnable interface, but run differently, use thread pool pool-1-thread-1: implement thread Runnable interface, but run differently, use thread pool pool-1-thread-4: implement thread Runnable interface, but run differently, use thread pool pool-1-thread-3: implement thread Runnable interface, but run differently Use thread pool pool-1-thread-2: implement thread Runnable interface, but run differently, use thread pool pool-1-thread-5: implement thread Runnable interface, but run differently

As you can see from the above results, there are five threads in the thread pool. After the thread is finished, it is not destroyed, but goes back to the thread pool, and the next execution gets the thread resources from the thread pool and runs again.

Fifth: thread pool + submit

The following example thread pool ExecutorService uses the submit method to run the threaded implementation of the Callable interface call method. The common feature of the submit method and the call method is the existence of a return value.

The return value of the Callable interface call method can be defined by a generic type

The return value of the ExecutorService thread pool submit method is Future

The get method of Future can get the return value of the call method, and if the call method throws an exception, the get method of Future will also throw an exception.

Public class FifthWay implements Callable {@ Override public String call () throws Exception {return Thread.currentThread () .getName () + ": the Callable API returns a value and can throw an exception";} / / Simulation test public static void main (String [] args) throws ExecutionException, InterruptedException {/ / saves the result of multithreaded execution List retList = new ArrayList () / / create a fixed-size thread pool ExecutorService threadPool = Executors.newFixedThreadPool (5); for (int I = 0 java8 I < 10 java8 iPool +) {Future future = threadPool.submit (new FifthWay ()); retList.add (future.get ());} / / java8 syntax, print thread (System.out::println);}}

There is a small syntax sugar in the above code, retList.forEach (System.out::println); it is a method reference provided by java8

Pool-1-thread-1:Callable API with return value, you can throw exception pool-1-thread-2:Callable API with return value, you can throw exception pool-1-thread-3:Callable API with return value, you can throw exception pool-1-thread-4:Callable API with return value, you can throw exception pool-1-thread-5:Callable API with return value, you can throw exception pool-1-thread-1:Callable API with return value You can throw an exception pool-1-thread-2:Callable API with return value, you can throw exception pool-1-thread-3:Callable API with return value, you can throw exception pool-1-thread-4:Callable interface with return value, you can throw exception pool-1-thread-5:Callable interface with return value, you can throw exception to this, you can end the study of "how to create and run threads in Java concurrent programming" I hope I can solve everyone's 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.