java multithreading implementation

1. What is a thread?

Thread: A single sequential control process in a program. A relatively independent and schedulable execution unit within the process is the basic unit for the system to independently schedule and dispatch the CPU.

Multi-threading: Running multiple threads at the same time to complete different tasks in a single program is called multi-threading.

Features:

1) A lightweight process, the smallest executable unit in the program running flow. Threads do not own system resources, and multiple threads share the resources owned by the process.

2) One thread can create another thread, and multiple threads can execute concurrently.

3) When multiple threads seize resources during system operation, there will be discontinuity. What we see is parallel execution, but in fact there is a sequence.

4) A process contains at least one thread, the main thread.

2. What are the statuses of threads?

Threads have five states: new, ready, running, blocked, and terminated.

①New: The thread is created without executing any method, such as Thread th = new Thread().

②Ready: When the start method of the thread is called, the thread status will be triggered to change to the ready state, waiting for the CPU to call. Only threads in the ready state will be scheduled by the CPU, and a single CPU will not execute it immediately.

③Run: When the CPU initiates a call to this thread, it enters the running state.

④Blocking: When a thread no longer has the right to use the CPU for some reason, it will be blocked.种 The following situations are obstructed:

1) Sleep (long mills): The parameters are milliseconds, so that the thread enters the obstruction within the specified time. Once the time passes, it will be ready.

2) suspend() and resume(): suspend will cause the thread to hang, and resume must be executed to resume the thread.

3) yield(): similar to sleep(), but the user cannot specify how long to pause. It can only give the opportunity to threads of the same priority without entering blocking. Just like in a queue, the person in front switches places with the person behind, but they are still in the queue.

4) wait() and notify(): wait() puts the thread into a blocking state. There are two forms, one specifies the number of milliseconds, and the other has no parameters. The former can be evoked through notify() or automatically restored after a specified time; the latter must be evoked through notify().

5) Synchronous blocking: waiting for synchronization lock resources. When multiple threads compete for the same resource, only one thread can obtain the lock, and other threads have to wait.

⑤ Termination: The thread finishes execution, or an exception occurs, and the thread ends.

3. How to create a thread?

There are three ways to implement Java threads: inherit the Thread class, implement the Runnable interface, and use Callable and FutureTask (can have return values)

1. Override the run() method by integrating the Thread class

class MyThread extends Thread {

@Override

public void run() {

for (int i = 0; i

System.out.println(Thread.currentThread().getName() + " " + i ; ;

MyThread th1 = new MyThread();

MyThread th2 = new MyThread();

th1.start();

th2.start();

}

}

Output: main

Thread-1 0

Thread-0 0

Thread-1 1

Thread-1 2

...

The logic to be implemented by the thread is written in the run method, by executing the thread's start() Method to put the thread into the ready state and wait for the CPU to allocate resources.

You can see that two threads execute in parallel and get the CPU randomly.

2. Tried implementing the Runnable interface and the run() method

class MyThread implements Runnable {

@Override

public void run() {

for (int i = 0; i

System.out.println(Thread.currentThread().getName() + " " + i);

}

}

}

public class ThreadDemo {

public static void main( String[] args) {

System.out.println(Thread.currentThread().getName());

MyThread th = new MyThread();

Thread t1 = new Thread(th);

Thread t2 = new Thread(th);

t1.start();

t2.start();

}

}

Output: main

Thread-0 0

Thread-0 1

Thread- 1 0

Thread-0 2

...

Instantiate Thread by passing the MyThread instance into the Thread constructor, call the start method of Thread, and start the thread.

ps: What is the difference between inheriting Thread and implementing the Runnable interface?

1: The former is single inheritance, which has limitations, but multiple interfaces can be implemented.

2: The latter can realize resource sharing.

In multi-threaded programming, it is strongly recommended to use Runnable

3. Use Callable and Future interfaces to create threads.

Specifically, create an implementation class of the Callable interface and implement the clam() method.

And use the FutureTask class to wrap the object of the Callable implementation class, and use this FutureTask object as the target of the Thread object to create a thread.

class MyCallable implements Callable {

@Override

public Integer call() throws Exception {

return 1;

}

}

public class ThreadDemo {

public static void main (String[] args) {

Callable myCallable = new MyCallable();//Instantiate MyCallable

FutureTask ft = new FutureTask(myCallable);//Package FutureTask

Thread thread = new Thread (ft); // Pass the FutureTask into the Thread structure and instantiate the thread

thread.start(); // Start the thread

Integer result = ft.get(); // Get the return value

System. out.println(result);

}

}

1) Implement the call() method in the Callable interface. This is the logic to be executed by the thread.

2) The get() method of FutureTask will block until the call() method is executed and the return value is obtained.