Java创建多线程的四种方式

一、继承Thread类

1.创建一个继承于Thread类的子类
2.重写Thread类的run() -->将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象
4.通过此对象调用start():
① 启动当前线程
② 调用当前线程的run()

代码演示

/**
 * @Description: 开启多线程的第一种方法
 * @Date:Created in 2020/6/8 17:19
 */

public class MyThread {

    public static void main(String[] args) {
        MyThreadTest p = new MyThreadTest();
        p.start();
        for (int i = 0; i < 100; i++){
            if(i%2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class MyThreadTest extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++){
            if(i%2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

二、实现Runnable接口

1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()

代码演示

/**
 * @Date:CreatedIn 2020/6/8 19:54
 * @Description: 开启多线程的第二种方法
 * 1、创造一个类实现名字为Runnable接口
 * 2、重写run()函数
 * 3、在run()函数中完成自己线程内需要处理的工作
 * 4、创建自己类的对象
 * 5、将自己的类的对象传入Thread类的构造函数
 * 6、通过Thread的对象调用start()方法
 * 两种方法对比：
 * 开发中优先选择实现Runable接口的这种方法
 * 优点：1、Runable方法可以避开java类的单继承性的缺点
 *      2、实现的方式适合来处理多个线程有共享数据的情况
 *  本质：
 *      其实Thread类也是通过实现Runable接口的形式来重写run()方法开启多线程的
 *      所以我们可以跳过继承Thread类选择直接去实现Runable接口中run()方法开启多线程。
 */
class MThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
        for (int i = 0; i < 100; i++) {
            if (i %2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class MyThread1 {
    public static void main(String[] args) {
        MThread myThread = new MThread();
        Thread t1 = new Thread(myThread);
        t1.start();
        System.out.println(Thread.currentThread().getName());


    }
}

三、实现Callable接口

代码演示

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

/**
 * @Date:CreatedIn 2020/6/9 17:07
 * @Description:
 * 开启多线程的第三种方法：通过实现Callable接口的方式
 * 这种方式的优点是可以有返回值，而且可以抛异常。
 * 还支持泛型
 *
 */
class GetSum implements Callable{

    @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 GetSumTest {
    public static void main(String[] args) {
        //创建类
        GetSum getSum = new GetSum();
        //使用FutureTask类对象作为参数传递给Thread的构造器
        FutureTask futureTask = new FutureTask(getSum);
        new Thread(futureTask).start();
        try {
            int res = (int)futureTask.get();
            System.out.println(res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

四、线程池（响应速度提高了，提高了资源的重用率，便于管理）

代码演示

import java.util.concurrent.*;

/**
 * @Date:CreatedIn 2020/6/9 17:28
 * @Description:
 * 开启多线程的第四种方式：使用线程池（开发中常用）
 * corePoolSize:核心池大小
 * maximumPoolSize:最大线程数
 * KeepAliveTime:线程没有任务时最多保持多长时间会终止
 */
class Thread4 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 Thread5 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2 != 0)
            {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class Thread4Test {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
//        ThreadPoolExecutor service = (ThreadPoolExecutor)executorService;
//        service.setCorePoolSize(10);
//        service.setMaximumPoolSize(20);
//        service.setKeepAliveTime();

        executorService.execute(new Thread4());
        executorService.execute(new Thread5());
        //executorService.submit()此方法是对应Callable接口的方式 ，可以用FutureTask类调用get()返回值。
        executorService.shutdown();//关闭线程池
    }
}