[multithreading] is there only one way to implement threads or four ways

Implement a thread , I'm learning Java When , The way I heard the teacher speak , There are three kinds of , Inherit Thread, Realization Runnable, Realization Callable. Some articles on the Internet say there are four , One more thread pool . Others say that only 1 Kind of . So I'm a little interested in exploring how threads are implemented .

1, Inherit Thread
The first way to implement threads is , Inherit Thread class , And rewrite run Method .

There is nothing to say about this kind of .

2, Realization Runnable Interface
The second method , Find a class , Realization Runnable Interface , rewrite run Method , And an instance of this implementation class , Throw it new Thread() In the constructor of .

It can be seen from it that , This approach still depends on new Thread() To create threads , Realized Runnable Interface MyRunnable Not even start Method .MyRunnable It just participates as a parameter of the constructor Thread Construction .

So this MyRunnable What did you do .

Click all the way down and you will find clues here

You can see , Actually MyRunnable As new Thread() Role of parameters , Will be Runnable The interface is assigned to target, Specify this Thread What tasks to run .
in other words , Realization Runnable, In essence, it's just new Thread

3, Realization Callable
The third method , Realization Callable Interface , And rewrite call Method .Callable And Runnable Is the difference between the Callable There is a return value , And may throw exceptions . and Runnable no return value .

And Runnable Different ,Runnable no return value , Therefore, it can be used synchronously ,start It won't block after , You can go on start Next thread or do something else .Callable Because of the return value , If you continue to use synchronization , It will block before returning the result , If you need to establish multiple threads at this time , Then you have to wait for the thread execution to end one by one . Now computers are multi-core cpu, Support multi-threaded simultaneous operation . therefore Callable Constant and asynchronous Future Use a combination of . The demonstration here is also combined Future demonstrate （FutureTask yes Tuture Interface implementation ）.

You can see , Actually Future It is also used as a parameter to participate in the construction Thread, And constructors and Runnable That's the same one . because Future Realized RunnableFuture Interface , and RunnableFuture Interface inherited Runnable Interface and Feature Interface . let me put it another way ,Future Realized Runnable Interface .


Runnable The method has already mentioned ,Runnable structure Thread In fact, by giving Thread Medium Runnable target Variable assignment , Tell thread run How to do . And in the FutureTask in , Rewrote RunnableFuture Of run Method , its run In the method , Would call call Method , That is, the previous implementation Callable Interface when rewriting the thread to do specific tasks call Method .

    public void run() {
    
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
    
            Callable<V> c = callable;
            // In the structure FutureTask when state Set as NEW
            if (c != null && state == NEW) {
    
                V result;
                boolean ran;
                try {
    
                	// Execute here call Method 
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
    
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
    
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

In this way, it is connected , In fact, it's still through new Thread, Appoint Runnable The reference of the implementation class of is target, Appoint run Method . and FutureTask Of run It's called call Method . So we can say , This method is actually through new Thread To build threads .

4, Thread pool
Thread pool is relatively simple . We know , Thread pool itself is not a way to create threads , It just manages the created threads . In essence, we need to rely on the first three ways to implement threads . Therefore, it is not the way to implement threads .

summary
From the above we can see that , The way to really create threads , Essentially only new Thread() A kind of . But show it in a different way , Different new Thread There are three ways , ordinary new Thread, Realization Runnable, Realization Callable. Thread pools are not included , Thread pool is just for managing threads , The threads created in the first three ways will be handed over to you for use and recycling , Creating threads still depends on the first three methods .