方式1：继承Thread类

步骤：

1. 创建一个继承于Thread类的子类
2. 重写Thread的run()方法
3. 创建当前Thread子类的对象
4. 通过实例对象调用start()方法，启动线程----》JAVA虚拟机会调用run()方法
   实现：

public class TestMyThread {
    public static void main(String[] args) {
        //创建自定义线程对象1
        MyThread mt1 = new MyThread("子线程1");
        //开启子线程1
        mt1.start();
        
        //创建自定义线程对象2，分别创建对象开启线程，不可以数据共享，若要共享需要创建static变量
        MyThread mt2 = new MyThread("子线程2");
        //开启子线程2
        mt2.start();
    }
}

方式2：实现Runnable接口

步骤：

1. 创建一个实现Runnable接口的类
2. 实现接口中的run()方法
3. 创建实例对象
4. 将此对象作为参数传到Thread类的构造器中，创建Thread类的实例
5. 通过Thread的实例对象调用start()方法，启用线程—》JAVA虚拟机会调用run()方法
   实现：

public class TestMyRunnable {
    public static void main(String[] args) {
        //创建自定义类对象  线程任务对象
        MyRunnable mr = new MyRunnable();
        //创建线程对象1
        Thread t1 = new Thread(mr, "长江1");
        t1.start();

		//创建线程对象2，注意两个线程传入的是同一个对象，可以实现数据共享
        Thread t2 = new Thread(mr, "长江2");
        t2.start();
    }
}

方式3：实现Callable接口

1. 与使用Runnable相比，Callable功能更强大些。

• 相比run()方法，call()可以有返回值，更灵活。
• call()方法可以使用throws抛出异常，更灵活
• Callable使用泛型参数，可以指明具体的call()返回值类型，更灵活。

2. Future接口

• 可以对具体Runnable，Callable任务的执行接口进行取消，查询是否完成，获取结果等
• FutureTask是Future接口的唯一的实现类
• FutureTask同时实现了Runnable,Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

3. 缺点：在获取分线程执行结果的时候，当前线程或主线程受阻塞，效率较低。
   实现：

/*
 * 创建多线程的方式三：实现Callable （jdk5.0新增的）
 */
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class CallableTest {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();

        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();


//      接收返回值
        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

方式4: 使用线程池

背景：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁，实现重复利用。

好处：

• 提高了程序执行的效率(线程已经提前创建好了)
• 提高了资源复用率(执行完的线程并未销毁，还可以继续执行其他任务，不需要每次都创建)
• 可以设置相关参数，对线程池中的线程进行管理

corePoolSize: 核心池的大小
maximumPoolSize: 最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止。多余空闲线程的存活时间。当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余空闲线程会被销毁直到剩下corePoolSize为止。
unit: keepAliveTime的单位
workQueue: 里面放了被提交但是尚未执行的任务
threadFactory: 表示线程池中工作线程的线程工厂，用于创建线程
handler: 拒绝策略，当队列满了并且工作线程大于等于线程池的最大线程数时，对任务的拒绝方式。

四种拒绝策略

• AbortPolicy(默认)：直接抛出RejectedExecutionException异常阻止系统正常进行
• CallerRunsPolicy：调用者运行一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量
• DiscardPolicy: 改变略默默丢弃无法处理的任务，不予任何受理也不抛出异常，如果允许任务丢弃，这是最好的一种策略
• DiscardOldestPolicy: 抛弃队列中等待最久的任务，然后将当前任务加入队列，然后再次提交任务

ExecutorService: 真正的线程池接口，常见子类ThreadPoolExecutor

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

• Executors: 一个线程池的工厂类，通过此类的静态工厂方法可以创建多种类型的线程池对象。

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

实现：

// 这里使用实现Runnable的方式
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 NumberThread1 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 Callable {
    @Override
    public Object call() throws Exception {
        int evenSum = 0;//记录偶数的和
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                evenSum += i;
            }
        }
        return evenSum;
    }

}

public class ThreadPoolTest {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//        //设置线程池的属性
//        System.out.println(service.getClass());//ThreadPoolExecutor
        service1.setMaximumPoolSize(50); //设置线程池中线程数的上限

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

        try {
            Future future = service.submit(new NumberThread2());//适合使用于Callable
            System.out.println("总和为：" + future.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
        //3.关闭连接池
        service.shutdown();
    }

}