- 继承Thread

继承Thread类，重写run方法实现多线程

package com.noneplus;

class Task1 extends Thread {

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println("Task1输出：" + i);
        }
    }
}

class Task2 extends Thread {

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println("                 Task2输出：" + i);
        }
    }
}

/**
 * @Description: 继承Thread，重写run方法，实现多线程
 * @Author noneplus
 * @Date 2020/8/3 17:34
 */
public class ExtendThread {

    public static void main(String[] args) {

        Task1 task1 = new Task1();
        task1.start();

        Task2 task2 = new Task2();
        task2.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("                                         mainTask输出：" + i);
        }

        //3个线程的执行顺序由CPU的线程调度决定

    }
}

- 实现Runnable接口

Runnable接口解决了单继承的问题

package com.noneplus;

class Task3 implements Runnable {

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println("Task1输出：" + i);
        }
    }
}

class Task4 implements Runnable {

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println("                      Task2输出：" + i);
        }
    }
}

/**
 * @Description: 实现Runnable接口，实现多线程，弥补单继承的问题
 * @Author noneplus
 * @Date 2020/8/3 17:34
 */
public class ImplementRunnable {

    public static void main(String[] args) {

        Task3 runnable3 = new Task3();
        Task4 runnable4 = new Task4();

        Thread task3 = new Thread(runnable3);
        Thread task4 = new Thread(runnable4);

        task3.start();
        task4.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("                                                                  " +
                    " mainTask输出：" + i);
        }

        //3个线程的执行顺序由CPU的线程调度决定

    }
}

- 实现Callable接口

Callable支持返回值（但用多线程加返回值有点奇怪）

package com.noneplus;

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

class Task5 implements Callable {

    @Override
    public Integer call() throws Exception {
        Integer i = 0;
        for (; i < 10; i++) {
            System.out.println("Task5输出：" + i);
        }
        return i;
    }
}

class Task6 implements Callable {

    @Override
    public Integer call() throws Exception {
        Integer i = 0;
        for (; i < 10; i++) {
            System.out.println("             Task6输出：" + i);
        }
        return i;
    }
}


/**
 * @Description: 实现Callable接口，可以定义返回值
 * @Author noneplus
 * @Date 2020/8/3 17:53
 */
public class ImplementCallable {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        for (int i = 0; i < 10; i++) {
            System.out.println("                                         mainTask输出：" + i);
        }

        FutureTask<Integer> futureTask = new FutureTask<Integer>(new Task5());
        FutureTask<Integer> futureTask1 = new FutureTask<Integer>(new Task6());

        Thread thread = new Thread(futureTask);
        Thread thread1 = new Thread(futureTask1);

        thread.start();
        thread1.start();

        System.out.println("任务返回结果："+futureTask.get());
        System.out.println("任务返回结果："+futureTask1.get());

    }
}

- 使用线程池ThreadPoolExecutor

package com.noneplus;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

class Task7 implements Runnable {
    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println("Task7输出：" + i + "当前线程" + Thread.currentThread().getName());
        }
    }
}

class Task8 implements Runnable {
    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println("Task8输出：" + i + "当前线程" + Thread.currentThread().getName());

        }

    }
}

/**
 * @Description: 使用线程池创建线程池，实现线程复用和管理
 * @Author noneplus
 * @Date 2020/8/5 15:38
 */
public class ThreadPool {

    public static void main(String[] args) {
        /**
         * 阿里推荐：ThreadPoolExecutor
         * ```
         * public ThreadPoolExecutor(int corePoolSize,
         *                               int maximumPoolSize,
         *                               long keepAliveTime,
         *                               TimeUnit unit,
         *                               BlockingQueue<Runnable> workQueue)
         * ```
         * 1、corePoolSize 核心线程数大小，当线程数 < corePoolSize ，会创建线程执行 runnable
         *
         * 2、maximumPoolSize 最大线程数， 当线程数 >= corePoolSize的时候，会把 runnable 放入 workQueue中
         *
         * 3、keepAliveTime 保持存活时间，当线程数大于corePoolSize的空闲线程能保持的最大时间。
         *
         * 4、unit 时间单位
         *
         * 5、workQueue 保存任务的阻塞队列
         *
         * 6、threadFactory 创建线程的工厂
         *
         * 7、handler 拒绝策略
         *
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3));

        for (int i=0;i<10;i++)
        {
            threadPoolExecutor.execute(new Task7());

            threadPoolExecutor.execute(new Task8());
        }


    }
}