Getting started with multithreading in Java

This article is mainly to learn the Java in the multi-threaded things.

One, understanding multithreading .

What is the mechanism of multithreading? He is allowed to execute multiple instruction streams concurrently in the program, each of which is called a thread and is independent of each other.

A thread, also known as a lightweight process, has independent execution control as a process, and the operating system is responsible for scheduling, except that the line Cheng has a separate storage space, but instead shares a storage space with other threads in the owning process, which makes communication between threads much simpler than the process.

The execution of multiple threads is concurrent, that is, logically "simultaneous", regardless of whether it is physical "simultaneous", if the system has only one CPU, then the real "at the same time" is not possible, but because the CPU speed is very fast, the user does not feel the difference, so do not need to care about it.

Second,the implementation of multi-threading in Java

Specific to the Java memory model, because Java is designed as a cross-platform language, in memory management, there is obviously a unified model. There is a main memory in the system, all the variables in Java are stored in memory, all the threads are shared, each thread has its own working memory, and the working memory is a copy of some variables stored in primary storage, and the threads operate on all variables in working memory, and the threads cannot access each other directly. Variable delivery needs to be done through main memory.

As a fully object-oriented language, Java provides class java.lang.Thread to facilitate multi-threaded programming. This class provides a number of ways to make it easier for us to control our individual threads. The most important method of the tread class is run (), which is called by the method Start () of the thread class to provide the code that our thread wants to execute.

Method One: Inherit the thread class, overwriting the run () method

We rewrite the run () method in the subclass of the thread class that we created, adding the code that the thread is going to execute. As follows:

1  Public classMyThreadextendsthread{2     3     intCount = 1, number;4      PublicMyThread (intnum) {5Number =num;6SYSTEM.OUT.PRINTLN ("Create Thread:" +Number );7     }8     9      Public voidrun () {Ten          while(true){ OneSYSTEM.OUT.PRINTLN ("thread" + number + ": Count" +count); A             if(++count = = 6) -                 return ; -         } the     } -      -      Public Static voidMain (string[] args) { -          for(inti = 0; I < 5; i++){ +             NewMyThread (i+1). Start (); -         } +     } A}

The results are as follows:

Create thread: 1To create a thread:2Thread 1: Count1Thread 1: Count2Thread 1: Count3Thread 1: Count4Thread 1: Count5Thread 2: Count1Thread 2: Count2Thread 2: Count3Thread 2: Count4To create a thread:3Thread 2: Count5To create a thread:4Thread 3: Count1Thread 3: Count2Thread 3: Count3Thread 3: Count4Thread 3: Count5To create a thread:5Thread 4: Count1Thread 4: Count2Thread 4: Count3Thread 4: Count4Thread 4: Count5Thread 5: Count1Thread 5: Count2Thread 5: Count3Thread 5: Count4Thread 5: Count5

One thing to note here is that in the main function, the start function is used instead of the run function, and you can try it out by using the run function to get the sequential output. Why would you use start instead of run? Some people say that the start function will be called when the first multi-threaded initialization, and then call the Run function, also some people say through the source of the start

 Public synchronized voidstart () {/*** This method isn't invoked for the main method thread or ' system ' * Group threads Created/set up by the VM.     Any of the new functionality added * to this method in the future May has to also is added to the VM.         * * A Zero status value corresponds to state "NEW". */        if(Threadstatus! = 0 | | This!=me)Throw Newillegalthreadstateexception (); Group.add ( This);        Start0 (); if(Stopbeforestart) {stop0 (throwablefromstop); }}Private native voidStart0 ();

You can see that the call is Start0 (), which uses the keyword native, which represents the function that calls the local operating system, so you need to use the start () function. Because multithreaded implementations require the support of the local operating system. When run is called, the system does not initialize the multithreaded environment, or it is in a thread. Alternatively, start is to create and start a thread, and run simply runs the code in its thread.

This method is simple and clear, in line with everyone's habit, but there is a big drawback, that is, if our class has been inherited from a class, we can no longer inherit the thread class, then we do not want to create a new class, then how to write? As follows.

Method Two: Implement Runnable interface.

The runnable interface has only one method run (), we declare our class implements the Runnable interface, the interface provides this method, writes our thread code into it, completes this part of the task.

But the Runnable interface does not have any support for threading, and we must also create an instance of the thread class, which is implemented by the thread class's constructor public thread (Runnable target).

Here is an example:

1  Public classMyThreadImplementsrunnable{2     intCount = 1, number;3      PublicMyThread (intnum) {4Number =num;5SYSTEM.OUT.PRINTLN ("Create thread" +Number );6     }7      Public voidrun () {8          while(true){9SYSTEM.OUT.PRINTLN ("Thread" +number+ ": Count:" +count);Ten             if(++count==6) One                 return ; A         } -     } -      Public Static voidMain (string[] args) { the          for(inti = 0; i<5; i++){ -             NewThread (NewMyThread (i+1) . Start (); -         } -     } +}

The results are as follows:

Create thread 1 Create thread 2 thread 1: Count:1Thread 1: Count:2Thread 1: Count:3Create thread 3 thread 2: Count:1Thread 1: Count:4Thread 2: Count:2Thread 1: Count:5Create thread 4 Thread 2: Count:3Thread 3: Count:1Thread 3: Count:2Thread 2: Count:4Thread 3: Count:3Create thread 5 thread 3: Count:4Thread 4: Count:1Thread 4: Count:2Thread 4: Count:3Thread 4: Count:4Thread 5: Count:1Thread 2: Count:5Thread 5: Count:2Thread 4: Count:5Thread 3: Count:5Thread 5: Count:3Thread 5: Count:4Thread 5: Count:5

Strictly speaking, it is also possible to create an instance of the thread subclass, but it must be noted that the subclass must not overwrite the Run method of the thread class, otherwise the thread will execute the Run method of the subclass instead of the Run method we used to implement the Runnable interface class.

Using the Runnable interface to enable multithreading allows us to accommodate all of the code in a class, and the downside is that we can only use one set of code, and if you want to create multiple threads and have different code for each thread, you have to create additional classes, This is not as straightforward as using multiple classes to inherit the thread's compact.

So how do you choose runnable and thread?

In fact, thread is also implemented runnable, thread and runnable have implemented the Run method.

The difference between thread and runnable

If a class inherits the Thread, it is not suitable for resource sharing. However, if the runable interface is implemented, it is easy to realize the resource sharing.

1 classHelloextendsThread {2      Public voidrun () {3          for(inti = 0; I < 7; i++) {4             if(Count > 0) {5System.out.println ("count=" + count--);6             }7         }8     }9  Ten      Public Static voidMain (string[] args) { OneHello H1 =Newhello (); AHello H2 =Newhello (); -Hello H3 =Newhello (); - H1.start (); the H2.start (); - H3.start (); -     } -   +     Private intCount = 5; -}

The results are as follows

Count= 5Count= 4Count= 5Count= 4Count= 5Count= 3Count= 2  Count= 3Count= 1count = 4count = 2count= 1Count= 3count = 2count= 1

It is clear here that the sharing of resources (count) is not implemented, and the transposition runnable

1 classMyThreadImplementsrunnable{2  3     Private intTicket = 5;//5 Tickets4  5      Public voidrun () {6          for(inti=0; i<=20; i++) {7             if( This. ticket > 0) {8System.out.println (Thread.CurrentThread (). GetName () + "Selling tickets" + This. ticket--);9             }Ten         } One     } A } -  Public classLzwcode { -       the      Public Static voidmain (String [] args) { -MyThread my =NewMyThread (); -         NewThread (My, Window No. 1th)). Start (); -         NewThread (My, Window No. 2nd)). Start (); +         NewThread (My, Window No. 3rd)). Start (); -     } +}

The results are as follows

Window 2nd is selling Ticket number 52nd window is selling ticket 22nd window is selling ticket 13th window is selling ticket 41st window is selling ticket 3

summarized as follows:

Implementing the Runnable interface has advantages over inheriting the thread interface:

1. Suitable for multiple threads of the same program code to process the same resource

2. You can avoid the restriction of single inheritance in Java

3. Increase the robustness of the program, the code can be shared by multiple threads, code and data Independent.

In short, for multi-threading, although I use not much, but for looking for work or what is very useful. This is only the basic multi-threaded problem, but also in-depth study of the details of multi-threaded things. That's a primer.

Getting started with multithreading in Java