多线程初始化

背景

1. 面试高频考点

2. 接口优化：大量请求同一个接口时，并发问题的出现。

3. 扩展：线程池，线程安全问题，生产者消费者问题

名词解释

进程

关键词：资源分配的基本单位，程序执行实例

顺序

一个人写三个项目，完成一个项目的所有的开发才能开始下一个项目的。

例如：先开始写项目A的代码再写项目B的代码，再写项目C（线程）的代码，在没完成任何一个项目前不允许参与其他项目的开发。

线程

关键词：程序执行时的最小单位，堆栈，局部变量，CPU独立调度执行

单核CPU：多个线程在单个CPU核上来回切换执行，一个人（单核CPU）可以任意开始，例如：先开始写项目C（线程）的代码再写项目A（线程）的代码，再写项目B（线程）的代码，再写项目A（线程）的代码, 来回切换写直到把三个项目都完成。

多核CPU：多个线程在多个CPU核上来回切换执行。三个人（多核CPU）写三个项目的代码（线程）。这三个人随意开始任意项目，三个人面对三个项目肯定是比一个人坐三个项目效率快的。但是容易出现有两个人想同时写一个项目（这就是并发的开始...）。

并发

三十个人写三个项目，效率是快了。但是可能会出现三个十个人都想写同一个项目，这就导致了一个项目被三十个人请求。这就是并发。

并行

创建线程的三种方式

1.继成java.lang.Thread, 重写run()方法

public class ThreadBuilder {
    public static void main(String[] args) {
        new ProgrammingThread().start();

    }
}

class ProgrammingThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " " + Thread.currentThread().getId());
    }
}

Thread-0 11

如果本身就已经继承了一个类就不能再去继承Threads了（爹只能有一个）。这个时候就要实现Runnable接口。

2.Thread 类实现Runnable接口, 重写run()方法

为了启动RunnableThread，需要首先实例化一个Thread，并传入自己的RunnableThread实例

public class RunnableBuilder {
    public static void main(String[] args) {
        RunnableThread runnableThread = new RunnableThread();
        // 为了启动RunnableThread，需要首先实例化一个Thread，并传入自己的RunnableThread实例
        Thread thread = new Thread(runnableThread);
        thread.start();
    }
}

class RunnableThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " " + Thread.currentThread().getId());
    }
}

Thread-0 11

3.实现Callable接口

前面两种都是无返回值的，无返回值的需要实现Runnable接口，想要有返回值必须实现Callable接口。执行Callable后可以获取一个Future对象，使get方法就可以获取Callable里的对象了。除此之外Callable还可以抛出异常。

package com.jilingy.demo02;

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

public class CallableBuilder {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableThread callableThread = new CallableThread();
        FutureTask<Integer> result = new FutureTask<>(callableThread);
        Thread thread1 = new Thread(result, "线程11111111     ");
        thread1.start();
        System.out.println("结果：" + result.get());
    }
}

class CallableThread implements Callable<Integer> {
    @Override
    public Integer call() {
        int target = 0;
        for (int i = 0; i < 100; i++) {
            target++;
            System.out.println("当前线程： " + Thread.currentThread().getName() + target);
        }
        return target;
    }
}

步骤： 

1. 首先创建线程的执行体：一个Callable实现类，然后重写call方法，该方法是具有返回值的。

2. 由Callable创建一个FutureTask对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

3. 使用FutureTask对象作为Thread对象的target创建并启动新线程

4. 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值其中，Callable接口(也只有一个方法)

完全异步的时候可以使用1和2两种方法进行线程，因为没有任何返回结果的线程，不用关心结果。