Four ways to create threads

1、 Inherit Thread class

public class ThreadTest extends Thread {

    public void run(){
        System.out.println(Thread.currentThread().getName()+"----thread Of run Method is executing ....");
    }
}

2、 Realization Runnable Interface

public class RunnableTest implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"----runnable Of run Method is executing ....");
    }
}

3、 Realization Callable Interface

public class CallableTest implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"----callable Of run Method is executing ....");
        return 1;
    }
}

4、 Use Executors Tool class creates thread pool （ There are four thread pools ）

public class PoolThreadTest implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"----pool Of run Method is executing ....");

    }

public static void main(String[] args) {
 
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();
        PoolThreadTest poolThreadTest = new PoolThreadTest();
        for (int i = 0; i < 2; i++) {
            executorService1.execute(poolThreadTest);
        }
        System.out.println(" The thread task begins to execute ");
        executorService1.shutdown();
  
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(" Execute in three seconds ......");
            }
        },3, TimeUnit.SECONDS);
        scheduledThreadPool.shutdown();

        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 2; i++) {
            fixedThreadPool.execute(new PoolThreadTest());
        }
        fixedThreadPool.shutdown();

        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i <2; i++) {
            cachedThreadPool.execute(new PoolThreadTest());
        }
        cachedThreadPool.shutdown();

    }
}

Be careful

Explanation of four thread pools

newSingleThreadExecutor： Returns a thread pool （ This thread pool has only one thread ）, This thread pool can be used after a thread dies （ Or when something goes wrong ） Restart a thread to replace the original thread to continue execution , The biggest feature of this thread is that it can ensure the sequential execution of various tasks , And no more than one thread will be active at any given time .

newScheduledThreadPool： Create a thread pool , It can be scheduled to run commands after a given delay or to execute on a regular basis .

newCachedThreadPool： Create a cacheable thread pool , If the thread pool length exceeds processing requirements , Free threads can be recycled flexibly , If there is no recovery , New thread . In the use of CachedThreadPool when , Be sure to control the number of tasks , otherwise , Because a lot of threads are running at the same time , It will cause system paralysis .

newFixedThreadPool: Create a thread pool that specifies the number of worker threads . Create a worker thread every time a task is submitted , If the number of worker threads reaches the initial maximum number of thread pools , Then put the submitted tasks into the pool queue .

test

public class Test {
    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
        RunnableTest test = new RunnableTest();
        Thread thread1 = new Thread(test);
        thread1.start();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new CallableTest());
        Thread thread2 = new Thread(futureTask);
        thread2.start();

    }
}