「Java基础入门」Java怎么创建线程？

为了方便大家理解，本文分别用四种创建线程的方式计算1到100之间偶数的和

1.继承Thread类

继承Thread类是Java中最基本的一种创建线程的方法。使用此方法时，需要重写Thread类的run方法，并在run方法中定义想要执行的任务代码。接着，创建一个Thread对象并调用其start()方法即可启动该线程。

public class ThreadTest {
    public static void main(String[] args) {
        sumTest sumTest= new sumTest();
        sumTest.run();
    }

}
class sumTest extends Thread{
    @Override
    public void run() {
        int sum = 0 ;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }

        }
        System.out.println(sum);
    }
}

2.实现Runnable接口

实现Runnable接口同样也可以用来创建线程。此方法相较于第一种方法更加灵活，因为Java不支持多重继承，若已经有一个父类，就无法再继承Thread类了。而实现Runnable接口则可以避免这个问题。与继承Thread类类似，使用此方法时需要实现Runnable接口中的run方法，并将其作为参数传递给Thread类的构造函数。最后同样需要调用Thread对象的start()方法来启动线程。

public class RunnableTest {
    public static void main(String[] args) {
        runnable1 runnable1 = new runnable1();
        new Thread(runnable1).start();

    }
}

class runnable1 implements Runnable {

    @Override
    public void run() {

        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }

        }
        System.out.println(sum);

    }
}

3.实现Callable接口

实现Callable接口创建线程的方法主要是为了提供对线程执行结果的支持。Callable是带泛型的接口，其中的call()方法签名如下：V call() throws Exception 。即call()方法可以返回带泛型的值，并且可能会抛出异常。和Runnable不同，Callable接口是建立在Executor框架之上的，它使用Future类来存储异步计算结果，所以通过Callable创建的线程可以获取到返回值。使用Callable创建线程时，需要将其实例化为FutureTask对象，并将其作为参数传给Thread类的构造函数。

public class CallableTest {
    public static void main(String[] args) {
        callable1 callable1 = new callable1();
        //1.实例化futureTask
        FutureTask futureTask = new FutureTask(callable1);
        //2.将futureTask放入线程中去启动
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());//3.get接收返回值(可不需要返回值)
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class callable1 implements Callable {


    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                sum+= i;
            }

        }
        return sum;//会自动装箱
    }
}

4.创建线程池

创建线程池是非常优雅的方式来管理和重用一组线程。Java提供了Executor框架，可以通过Executors工厂类快速创建一个线程池。其中最基本的是newFixedThreadPool方法，可以创建一个指定大小的线程池，使用时需要提供Runnable或Callable的实现。线程池中会执行这些任务，并在需要时自动回收线程资源，以供下一次使用。

public class ThreadPoll {
    public static void main(String[] args) {
        //1.创建线程池可容纳最多的线程数量
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2.调用execute方法（适合用实现runnable接口的类，callable用的是submit方法）
        //3.传入实现了runnable接口的类
        service.execute(new threadPool());
        //4.关闭连接池
        service.shutdown();
    }
}
class threadPool implements Runnable{

    @Override
    public void run() {
        int sum = 0 ;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }

        }
        System.out.println(sum);
    }
}

4.1，三种Excuutors方式

public class ThreadPool {
    public static void main(String[] args) {
//        ExecutorService service = Executors.newSingleThreadExecutor();//单个线程，只有一个线程在执行
//        ExecutorService service = Executors.newFixedThreadPool(5);//固定线程，指定线程数
        ExecutorService service = Executors.newCachedThreadPool();//可变线程数，有多少来多少
        try {
            for (int i = 0; i < 10; i++) {
                service.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            service.shutdown();
        }
    }
}

4.2 但是工作一般不使用Excuutors来创建线程池

原因1：阿里创作手册上写了

原因2：看源码所得知，其实他也是调用的基础的构造函数

七大参数

例如：