Summary of process and thread knowledge points 1

Catalog

One . Concept

1. What is a thread

2. Why have threads

3. Difference between process and thread

4.java The relationship between threads and operating system threads

Two . Four ways to create threads

Method 1   Inherit Thread class

Method 2 Realization Runnable Interface

Method 3 adopt ExecutorService and Callable Interface implements a thread with a return value

Method four Thread pool based execute(), Create a temporary thread

3、 ... and . Common thread scheduling methods

  Waiting and notifying ：

1.wait()：

2.wait(long timeout) ：

3.wait(long timeout, int nanos)：

4.notify() :

5.notifyAll() ：

6.join()：

Thread to sleep

1.sleep(long millis) :

Give up the priority

1.yield() ：

Thread the interrupt

1.void interrupt() ：

2.boolean isInterrupted() ⽅ Law ：

3.boolean interrupted() ⽅ Law ：

---

---

One . Concept

1. What is a thread

A thread is an execution flow , Each thread can execute its own code in order , Between multiple threads “ meanwhile ” Execute multiple copies of code .

2. Why have threads

A thread is the smallest unit of program execution .

2.1“ Concurrent programming ” Become “ Just need to ”.

In order to improve computing power , Need multi-core CPU, To make the most of multicore CPU, Some tasks require “ wait for IO”, In order to allow waiting time to do some other work , You need to use parallel programming .

2.2 Compared with threads

Although multiple processes can also realize concurrent programming , But threads are lighter than processes .

• Creating threads is faster than creating processes
• Destroying threads is faster than destroying processes
• Scheduling threads is faster than scheduling processes

2.3" Thread pool "(ThreadPool) and " coroutines " (Coroutine)

Although threads are already lighter than processes , But people are not satisfied , Hence the " Thread pool " and " coroutines " .

3. Difference between process and thread

• Processes contain threads , Each process has at least one thread , The main thread
• Process is an independent unit of system resource allocation and scheduling , Thread is the smallest unit of program running
• The process has its own independent memory space address , Threads only enjoy the necessary resources for instruction flow execution , Such as ： register 、 Stack
• The threads of unified processes share memory and file resources , You can communicate directly without using the kernel
• Thread creation 、 Switch . Termination is more efficient than process

4.java The relationship between threads and operating system threads

Thread is a concept in operating system . The operating system kernel implements the mechanism of thread , It also provides some for the user layer API For users to make use ( for example Linux Of pthread library ).

Java Standard library Thread Class can be considered to be provided to the operating system API Further abstraction and encapsulation are carried out .

Two . Four ways to create threads

Method 1   Inherit Thread class

1. Inherit Thread To create a thread class , Definition Thread Subclasses of classes , rewrite run Method ,run（） Inside the method is the execution body of the thread .

class MyThread extends thread {
    @override
    public void run() {
        System.out.println(" This is the code that the thread runs ");
    }
}

2.  establish Thread Subclass （MyThread） example

MyThread mt = new MyThread();

3.  Start thread

mt.start();

public class ThreadTest {
 /**
 *  Inherit Thread class 
 */
 public static class MyThread extends Thread {
 @Override
     public void run() {
         System.out.println("This is child thread");
     }
 }

 public static void main(String[] args) {
     MyThread t = new MyThread();
     t.start();
  }
}

Method 2 Realization Runnable Interface

1. Realization Runable Interface

class MyRunnable implements Runnable {
@Override
public void run() {
    System.out.println(" Here is the code that the thread runs ");
    }
}

2. establish Thread Class instance , call Thread The construction method of will Runnable Object as target Parameters

Thread t = new Thread(new MyRunnable());

3. call start Method

t.start();

public class MyRunnable implements Runnable {
     public void run() {
         System.out.println("Runnable!");
     }
     public static void main(String[] args) {
         MyRunnable task = new MyRunnable();
         new Thread(task).start();
     }
}

Method 3 adopt ExecutorService and Callable Interface implements a thread with a return value

1. Create a class implementation Callable Interface

2. rewrite call() Method

such ⽅ The formula can be expressed by FutureTask Get task execution ⾏ The return value of

public class CallerTask implements Callable<String> {
     public String call() throws Exception {
         return "Hello,i am running!";
     }
     public static void main(String[] args) {
         // Create asynchronous tasks 
         FutureTask<String> task=new FutureTask<String>(new CallerTask());
         // Start thread 
         new Thread(task).start();
         try {
         // Waiting for execution ⾏ complete , And get the return result 
             String result=task.get();
             System.out.println(result);
         } catch (InterruptedException e) {
             e.printStackTrace();
             } catch (ExecutionException e) {
                 e.printStackTrace();
             }
     }        
}

Method four Thread pool based execute(), Create a temporary thread

We can use the cache strategy to create threads using thread pools

Create ：

（1） Creating a thread pool

（2） Call the thread pool execute() Method

（3） Methods using anonymous inner classes , establish Runnable object , And rewrite run() Method

public class EThread {
    public static void main(String[] args) {
        // Creating a thread pool 
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        for(int i = 0;i<10;i++) {
            // call execute() Method to create a thread 
            // Methods using anonymous inner classes , establish Runnable object , And rewrite run() Method 
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());   
                }
            });
        }
    }
}

3、 ... and . Common thread scheduling methods

  Waiting and notifying ：

stay Object class There is ⼀ Some functions can ⽤ Waiting and notification of threads .

1.wait()：

When ⼀ Threads A transfer ⽤⼀ Shared variables wait()⽅ Legal time , Threads A It's going to get stuck , Hair ⽣ Next ⾯⼏ Only in this case will it return ：

（1） Threads A transfer ⽤ Shared objects notify() perhaps notifyAll()⽅ Law ;

（2） Other threads call ⽤ Thread A Of interrupt() ⽅ Law , Threads A Throw out InterruptedException Exception return .

2.wait(long timeout) ：

This ⽅ the aspects of things ⽐ wait() ⽅ Too much ⼀ individual Timeout parameters , The difference is , If the thread A transfer ⽤ Shared objects wait(long timeout)⽅ After the law , Not in the specified timeout ms Wake up by other threads in time , So this ⽅ Law will still be because of timeout ⽽ return .

3.wait(long timeout, int nanos)：

Its internal tone ⽤ Yes. wait(long timout） function .

On ⾯ The thread waits ⽅ Law ,⽽ The wake-up thread is mainly the next ⾯ Two ⽅ Law ： 

4.notify() :

⼀ Threads A transfer ⽤ Shared objects notify() ⽅ After the law , Will wake up ⼀ In this shared variable ⽤ wait series ⽅ Thread suspended after method . ⼀ There may be multiple threads waiting on shared variables , Specifically Which waiting thread to wake up is random Of .

5.notifyAll() ：

It is different from raising the shared variable ⽤ notify() The function wakes up the ⼀ Threads notifyAll()⽅ The law will wake up all due adjustments on the shared variable ⽤ wait series ⽅ Law ⽽ Suspended threads .

Thread class Also provided ⼀ individual ⽅ Law ⽤ Waiting ⽅ Law ：

6.join()：

If ⼀ Threads A Of board ⾏ 了 thread.join() sentence , Its meaning is ： Current thread A wait for thread End of thread ⽌ After that, I started from thread.join() return .

Thread to sleep

1.sleep(long millis) :

Thread Class static ⽅ Law , When ⼀ Hold on ⾏ Thread in A transfer ⽤ 了 Thread Of sleep⽅ After the law , Threads A Will temporarily give up the execution of the specified time ⾏ power , But threads A Monitor resources owned ,⽐ Such as The lock is still held and cannot be surrendered . When the specified sleep time is up, the function will return normally , Then participate in CPU The scheduling , Get CPU You can continue to transport resources ⾏.

Give up the priority

1.yield() ：

Thread Class static ⽅ Law , When ⼀ A thread call ⽤ yield ⽅ Legal time , It's actually dark ⽰ The thread scheduler requests the current thread to give up ⾃⼰ Of CPU , But thread scheduler Sure ⽆ The condition ignores this dark ⽰.

Thread the interrupt

Java The thread interrupt in is ⼀ A mode of collaboration between threads , By setting the interrupt flag of the thread It can't end directly ⽌ The execution of this thread ⾏,⽽ Is the interrupted thread according to the interrupt state ⾃⾏ Handle .

1.void interrupt() ：

Interrupt threads , for example , When a thread A shipment ⾏ when , Threads B It can be adjusted ⽤ Threads interrupt() ⽅ Method to set the interrupt flag of the thread as true and ⽴ Return . Setting a sign is just setting a sign ,  Just send the message of stop sign , In fact, it does not affect the operation .

2.boolean isInterrupted() ⽅ Law ：

Detect whether the current thread is interrupted .

3.boolean interrupted() ⽅ Law ：

Detect whether the current thread is interrupted ,true: Let thread stop false: Didn't stop . And isInterrupted The difference is , The ⽅ If the current thread is found to be interrupted , The interrupt flag is cleared