About terminating tasks in thread pool

Use the thread pool itself to delete or terminate tasks , There is a necessary premise ：
The task must exist in the queue .

Why do you say that? ？

Because what we call “ Delete task ” Refer to ThreadPoolExecutor Of remove Method ：

    public boolean remove(Runnable task) {
    
        boolean removed = workQueue.remove(task);
        tryTerminate(); // In case SHUTDOWN and now empty
        return removed;
    }

You can see , It's from workQueue Removed from ;
in other words , If the task has been run , Theoretically, you cannot use thread pool to delete .

such as ：

	private static void testNormalRemove() {
    
		ThreadPoolExecutor tpe = new ThreadPoolExecutor(1, 3, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>(3));

		Thread task1 = new Thread(new Runnable() {
    
			@Override
			public void run() {
    
					while (true) {
    
						try {
    
							TimeUnit.SECONDS.sleep(2);
						} catch (InterruptedException e) {
    
							e.printStackTrace();
						}
						System.out.println("normal1," + Thread.currentThread().getId());
					}
				}
		});
		Thread task2 = new Thread(new Runnable() {
    
			@Override
			public void run() {
    
				while (true) {
    
					try {
    
						TimeUnit.SECONDS.sleep(3);
					} catch (InterruptedException e) {
    
						e.printStackTrace();
						return;
					}
					System.out.println("normal2," + Thread.currentThread().getId());
				}
			}
		});
		tpe.execute(task1);
		tpe.execute(task2);

		try {
    
			TimeUnit.SECONDS.sleep(6);
		} catch (InterruptedException e) {
    
			e.printStackTrace();
		}
		System.out.println(tpe.getQueue().size());
		System.out.println("remove task2," + tpe.remove(task2));

		try {
    
			TimeUnit.SECONDS.sleep(6);
		} catch (InterruptedException e) {
    
			e.printStackTrace();
		}

	}

Here you are task1、task2 Two tasks , The core thread of the created thread pool is 1, that task1 It will be run immediately after being added , and task2 Will be added to the queue waiting to run , The principle can refer to Analysis of the principle of thread pool , that task2 Yes, it can be. remove The success of , and task1 Can't be remove Of , because Not in the queue at all 了 .

Of course , There are some special thread pools , Each task is actually added to the queue , such as ScheduledThreadPoolExecutor When adding tasks , In fact, every task is added to the queue ：

    public void execute(Runnable command) {
    
        schedule(command, 0, NANOSECONDS);
    }

    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay,
                                       TimeUnit unit) {
    
        if (command == null || unit == null)
            throw new NullPointerException();
        RunnableScheduledFuture<?> t = decorateTask(command,
            new ScheduledFutureTask<Void>(command, null,
                                          triggerTime(delay, unit)));
        delayedExecute(t);
        return t;
    }

    private void delayedExecute(RunnableScheduledFuture<?> task) {
    
        if (isShutdown())
            reject(task);
        else {
    
            super.getQueue().add(task);
            if (isShutdown() &&
                !canRunInCurrentRunState(task.isPeriodic()) &&
                remove(task))
                task.cancel(false);
            else
                ensurePrestart();
        }
    }

In this way, the added tasks can be deleted ;
Of course, it should be noted that the added tasks are encapsulated RunnableScheduledFuture, So remember to convert to RunnableScheduledFuture Then delete , If using schedule Or others scheduleXX Method , Will go straight back to RunnableScheduledFuture, You can delete the returned value .

Other thread pools are not so “ Good luck ” 了 , Follow the general rules , Only in excess of corePoolSize Will join the queue ;
There is a method to stop threads inside the thread pool , But the scheduling methods inside the thread pool are mostly private, Cannot be called , Like this ：

    private void processWorkerExit(Worker w, boolean completedAbruptly) {
    
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
            decrementWorkerCount();

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
    
            completedTaskCount += w.completedTasks;
            workers.remove(w);
        } finally {
    
            mainLock.unlock();
        }
		// A little 
    }

Threads or tasks that have been run are encapsulated as Worker, But about Worker Our method is not open to the public , This is also the reason why most thread pools cannot finely control threads —— Of course , Threads themselves are very fine-grained .

On the whole , Once the thread starts , It is difficult to stop by conventional means , It is often necessary to throw exceptions or add return Or force interrupt To stop ;
If you need to master threads , Then the use is similar to ScheduledThreadPoolExecutor Thread pool is also a good choice in some scenarios .