创建线程的四种方式

public class ThreadTest extends Thread {

    public void run(){
        System.out.println(Thread.currentThread().getName()+"----thread的run方法正在执行....");
    }
}

public class RunnableTest implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"----runnable的run方法正在执行....");
    }
}

public class CallableTest implements Callable {
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"----callable的run方法正在执行....");
        return 1;
    }
}

public class PoolThreadTest implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"----pool的run方法正在执行....");

    }

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("线程任务开始执行");
        executorService1.shutdown();
  
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("三秒后执行......");
            }
        },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();

    }
}

四种线程池讲解

newSingleThreadExecutor：返回一个线程池（这个线程池只有一个线程）,这个线程池可以在线程死后（或发生异常时）重新启动一个线程来替代原来的线程继续执行下去,这个线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

newScheduledThreadPool：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

newCachedThreadPool：创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

newFixedThreadPool:创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

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 futureTask = new FutureTask(new CallableTest());
        Thread thread2 = new Thread(futureTask);
        thread2.start();

    }
}