线程的创建的几种方式

线程的创建

1.继承Thread类

自定义类声明为Thread的子类然后重写run方法，创建线程对象，调用start方法启动线程

public class TestThread1 extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("方法线程："+Thread.currentThread().getName()+"\t"+i);
        }
    }

    public static void main(String[] args) {

        TestThread1 testThread1 = new TestThread1();

        testThread1.start();//start方法的作用：启动当前线程，调用当前线程的run方法

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程："+Thread.currentThread().getName()+"\t"+i);
        }
    }
}

2、实现Runnable接口

public class TestThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
    }

    public static void main(String[] args) {
        TestThread2 testThread2 = new TestThread2();
        new Thread(testThread2,"方法线程1").start();
        new Thread(testThread2,"方法线程2").start();
    }
}

比较继承Thread和实现Runnable方式创建线程：

开发中优先选择实现Runnable接口的方式

原因：

1. 实现方式没有类的单继承性的局限性
2. 实现方式更适合用来处理多个线程共享数据的情况

联系：Thread类实现了Runnable接口

相同点：都要重写run(),将线程要执行的逻辑声明在run()中

3、实现Callable接口

JDK 5.0 新增的创建线程的方式

与使用Runnable相比，Callable功能更强大一些：

1. 相比run()方法，可以有返回值，重写call()方法
2. 方法可以抛出异常
3. 支持泛型的返回值
4. 需要借助FutureTask 类，比如获取返回结果

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        //创建Callable实现类的对象
        TestCallable testCallable = new TestCallable();

        //将此callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask<Integer> futureTask = new FutureTask<>(testCallable);

        //将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread类的对象，并调用start
        new Thread(futureTask).start();

        try {
            //get()返回值即为FutureTask构造器参数callable实现类重写的call()方法的返回值
            Integer sum = futureTask.get();
            System.out.println("sum="+sum);
        } catch (InterruptedException  ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4、使用线程池

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁的创建和销毁、实现重复利用。

好处：

1. 提高响应速度（减少创建新线程的时间）
2. 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
3. 便于线程管理，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

在《阿里巴巴 Java 开发手册》“并发处理”这一章节，明确指出线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。

JDK5.0起提供了线程池相关API：ExecutorService和Executors

ExecutorService：真正的线程池接口。常见了类ThreadPoolExecutor

void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
<T>Future<T>submit(CallabIe<T>task)：执行任务，有返回值，一般又来执行Callable
void shutdown()：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

Executors.newCachedThreadPool():创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n):创建一个可重用固定线程数的线线程池
Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class ThreadPool {
    public static void main(String[] args) {
        //提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        //设置线程池的属性
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

        //指定线程的操作，需要提供实现Runnable接口或callable接口实现类的对象
        service.execute(new NumberThread());
        service.execute(new NumberThread2());
        service.submit(new NumberThread3());
        service.shutdown();
    }
}

class NumberThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class NumberThread2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class NumberThread3 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }
}

另外，《阿里巴巴 Java 开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 构造函数的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。具体内容的深入学习可以参考Javaguide