多线程

1.什么是并发与并行

并行：指两个或多个事件在同一时刻发生（同时发生）。
并发：指两个或多个事件在同一个时间段内发生，但不是同一时刻。

2.什么是进程、线程

进程：
进程是正在运行的程序的实例。
进程是线程的容器，即一个进程中可以开启多个线程。
比如打开一个浏览器、打开一个word等操作，都会创建进程。
线程：
线程是进程内部的一个独立执行单元；
一个进程可以同时并发运行多个线程；
比如进程可以理解为医院，线程是挂号、就诊、缴费、拿药等业务活动

3.线程创建

Java中线程有四种创建方式：
1.继承Thread类
2.实现Runnable接口
3.实现Callable接口
4.线程池

1.继承Thread类

步骤：先继承Thread，然后重写Thread类中的run方法。

//继承Thread
public class MyThread extends Thread {
//重写run方法
//@Override是伪代码,表示重写。(当然不写@Override也可以)
//可以当注释用,方便阅读；
//编译器可以给你验证@Override下面的方法名是否是你父类中所有的，如果没有则报错。
//例:你如果没写@Override，而你下面的方法名又写错了，这时你的编译器是可以编译通过的，
//因为编译器以为这个方法是你的子类中自己增加的方法。
    @Override
    public void run(){
        for (int i = 0 ;i <10 ; i++){
            //打印输出时间戳
            System.out.println("myThread执行了="+ new Date().getTime());
        }
    }

}

测试类：

public class ThreadCreate {
    public static void main(String[] args) {
        //1.创建自定义线程类实例
        MyThread myThread = new MyThread();
        //2.启动线程
        myThread.start();
        //3.在main主线程打印信息
        //java程序启动都是通过main方法启动，在main方法启动时就会创建一个线程，
        //这个线程就叫做主线程
        for (int i = 0; i <10; i++){
            //打印输出时间戳 
            System.out.println("main主线程执行了："+ new Date().getTime());
        }
    }
}

2.实现Runnable接口

步骤：首先自定义类实现Runnable接口，然后在run方法中写需要的线程任务

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i =0;i<10;i++){
            //简单来说Thread是线程的意思.
            //current()是个静态方法.意思是返回当前执行这段代码的线程
            //意思就是,获取当前执行这段代码的线程的名字
            System.out.println(Thread.currentThread().getName()+"执行时间："+new Date().getTime()+";执行次数："+i);
        }
    }
}

然后在启动线程的地方new一个Thread实例，再将new Runnable 传进去，在通过start()方法启动就好了

   public static void main(String[] args) {
        //实现Runnable接口创建线程
        //1.通过Thread类执行MyRunnable类
        //"MyRunnable"是自定义线程名，系统默认的是Thread-0或-1这样按规则生成的
        Thread thread = new Thread(new MyRunnable(), "MyRunnable"  );
        //2.启动线程
        thread.start();
        //3.在main主线程打印信息
        for (int i = 0; i <10; i++){
            System.out.println(Thread.currentThread().getName()+"主函数执行时间："+new Date().getTime()+";执行次数："+i);
        }
    }
}

3.实现Callable接口

Callable需要使用FutureTask类帮助执行，FutureTask类结构如下：
FutureTask是一个类，实现了RunnableFuture接口，而RunnableFuture接口是继承了Future和Runnable两个接口，所以Callable接口最后被调用也是通过Runnable接口去调用的，Callable是依赖Runnable的，Future接口是帮助我们获取Callable接口在执行过程中的一些返回值或是终止Callable接口的执行，可以操控线程的执行过程

Future接口常用方法：
判断任务是否完成：isDone()
能够中断任务：cancel()
能够获取任务执行结果：get()
步骤：先定义类实现Callable接口并且指定泛型（返回值类型），然后将业务逻辑放入call()方法体中

//Callable<>需要指定泛型，就是返回值类型，可以指定任意类型
public class MyCallable implements Callable<String> {

    //call()方法和run()方法类似，区别在于call()有返回值
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "执行时间：" + new Date().getTime() + "循环次数" + i);
        }
        return "MyCallable接口执行完成";
    }
}

然后在执行时需要先创建FutureTask实例，实例中的泛型要和Callable接口中的泛型一致，然后在执行FutureTask实例，执行完成后可以通过Future接口方法查看状态

public class ThreadCreate {
    public static void main(String[] args) {
        //实现Callable接口
        //创建FutureTask实例，创建MyCallable实例
        FutureTask<String> task = new FutureTask<>(new MyCallable());
        //创建Thread实例，执行FutureTask
        Thread thread = new Thread(task, "MyCallable");
        thread.start();
        //打印主线程信息
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "线程执行时间：" + new Date().getTime() + ";执行次数：" + i);
        }
        //获取Callable执行结果
        //此处会抛出异常
        try {
            String result = task.get();
            System.out.println("MyCallable执行结果是"+result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4.线程池

线程池线类关系图:

**Executor接口：**声明了execute(Runnable runnable)方法，执行任务代码
**ExecutorService接口：**继承Executor接口，声明方法：submit、invokeAll、invokeAny以及shutDown等
**AbstractExecutorService抽象类：**实现ExecutorService接口，基本实现ExecutorService中声明的所有方法
**ScheduledExecutorService接口：**继承ExecutorService接口，声明定时执行任务方法
**ThreadPoolExecutor类：**继承类AbstractExecutorService，实现execute、submit、shutdown、shutdownNow方法
**ScheduledThreadPoolExecutor类：**继承ThreadPoolExecutor类，实现ScheduledExecutorService接口并实现其中的方法
Executors类：
提供快速创建线程池的方法

步骤：首先自定义类实现Runnable接口，然后在run方法中写需要的线程任务

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i =0;i<10;i++){
            //简单来说Thread是线程的意思.
            //current()是个静态方法.意思是返回当前执行这段代码的线程
            //意思就是,获取当前执行这段代码的线程的名字
            System.out.println(Thread.currentThread().getName()+"执行时间："+new Date().getTime()+";执行次数："+i);
        }
    }
}

使用线程池调用Runnable接口

public class ThreadCreate {
    public static void main(String[] args) {
        //使用线程池创建线程
        //使用Executors获取线程池对象,newFixedThreadPool()固定数量的线程池，将最大线程数放入方法中
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //使用线程池对象获取线程并执行MyRunnable实例
        //使用execute()执行线程，需要返回一个Runnable类型的参数
        //MyRunnable()正好实现了Runnable接口
        executorService.execute(new MyRunnable());
        //打印主线程信息
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "线程执行时间：" + new Date().getTime() + ";执行次数：" + i);
        }
    }
}

小结：

实现接口和继承Thread类比较

1. 接口更适合多个相同的程序代码的线程去共享同一个资源。
2. 接口可以避免java中的单继承的局限性。
3. 接口代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable接口的线程，不能直接放入继承Thread的类。

扩充：

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。

Runnable和Callable接口比较

相同点：
两者都是接口；
两者都可用来编写多线程程序；
两者都需要调用Thread.start()启动线程；
不同点：
实现Callable接口的线程能返回执行结果；而实现Runnable接口的线程不能返回结果；
Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的不允许抛异常；
实现Callable接口的线程可以调用Future.cancel取消执行 ，而实现Runnable接口的线程不能
注意点：
Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞！