Java 并发（多线程）超详细

Java 并发

此文章已收录至项目 Developer-Knowledge-Base

信息来源

https://www.cnblogs.com/snow-flower/p/6114765.html

java 中的 Lock 锁

https://javaguide.cn/java/concurrent/java-concurrent-questions-03.html

https://www.cnblogs.com/lifegoeson/p/13683785.html

线程和进程

程序是由指令和数据有序组成的静态概念，程序本身没有运行的含义，只有在处理器赋予其生命（操作系统执行）时，它才能成为一个活动的实体，即进程。进程是程序在执行过程中分配和管理资源的基本单位，它是一个动态概念，每个进程都拥有独立的地址空间和系统资源，如内存、文件、网络连接等。不同的进程之间相互独立，并且需要通过 IPC（进程间通信）机制进行数据交换和通信。

进程可以包括多个线程，线程是 CPU 调度和分派的基本单位，是进程的一部分，它们共享进程所拥有的全部资源，并且可以共享对象和资源，如有冲突或需要协同处理，线程之间可以进行沟通以解决冲突或保持同步。一个线程只能属于一个进程，但一个进程可以包括多个线程，而必须至少包括一个线程。通过多线程技术，可以在一个进程中创建多个线程，让它们在同一时刻并发地去处理不同的任务。

在操作系统中运行的程序就是进程，一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等

有了线程技术，我们就可以在一个进程中创建多个线程，让它们在“同一时刻”分别去做不同的工作了。这些线程共享同一块内存，线程之间可以共享对象、资源，如果有冲突或需要协同，还可以随时沟通以解决冲突或保持同步。

注意：很多多线程是模拟出来的，真正的多线程是指有多个 cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个 cpu 的情况下，在同一个时间点，cpu 只能执行一个代码，因为切换的很快，所以就有同时执行的错局。

• 在 Java 程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，GC 线程，而 main()称之为主线程，为系统的入口，用于执行整个程序
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
• 线程会带来额外的开销，如 CPU 调度时间，并发控制开销
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

Java 实现多线程

继承 Thread

Thread 类在 Java.lang 包中定义，一个类只继承 Thread 类，此类就称为多线程操作类

在 Thread 子类中必须明确地覆写 Thread 类中的 run() 方法，此方法为线程的主体
定义语法

Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方 法就是通过 Thread 类的 start() 实例方法。start() 方法是一个 native 方法，它将启动一个新线 程，并执行 run() 方法

native 方法称为本地方法。在 java 源程序中以关键字“native”声明，不提供函数体。其实现使用 C/C++语言在另外的文件中编写，编写的规则遵循 Java 本地接口的规范 (简称 JNI)。简而言就是 Java 中声明的可调用的使用 C/C++实现的方法。Object.class 类中的 getClass() 方法、hashCode() 方法、clone() 方法都是 native 方法

class 类名称 extends Thread类{ //继承 Thread 类
 属性...;     //类中定义方法
 方法...;     //类中定义方法
 public void run(){    //覆写 Thread 类中的 run() 方法，此方法是线程的主体
         线程主体;
 }
}

启动多线程需要使用从 Thread 类中继承而来的 start() 方法

若通过 Thread 类实现多线程，那么只能调用一次 start() 方法，若调用多次，则会抛出 IllegalThreadStateException 异常

通过在 run() 方法前加 synchronized 关键字，使多个线程在执行 run() 方法时，以排队的方式进行处理

synchronized public void run()

通过 this 关键字可以指定当前线程的变量

可以直接调用 Thread 类的 run 方法吗？

调用 start() 方法方可启动线程并使线程进入就绪状态，直接执行 run() 方法的话不会以多线程的方式执行。

实现 Runnable 接口

class 类名称 implements Runnable{ //实现 Runnable 接口
 属性...;           //类中定义属性
 方法...;           //类中定义方法
 public void run(){ //覆写 Runnable 接口中的 run() 方法
  线程主体;
 }
}

若要启动实现了 Runnable 接口的多线程，必须靠 Thread 类完成启动

Thread 类提供了两个构造方法：public Thread(Runnable target) 和 public Thread(Runnable target,String name) 两个构造方法

具体实现方法

class A implements Runnable {
    private String name;

    public A(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(name + "线程+i=" + i);
        }
    }
}


public class test {
    public static void main(String[] args) {
        A a = new A("A");
        A b = new A("B");
        Thread c = new Thread(a);
        Thread d = new Thread(b);
        c.start();
        d.start();
    }
}

Thread 类和 Runnable 接口

参考： https://www.cnblogs.com/dolphin0520/p/3949310.html

Thread 类也是 Runable 接口的子类

如果一个类继承 Thread 类，则不适合于多个线程共享资源，而实现了 Ruanable 接口，就可以方便地实现资源共享
实现 Runnable 接口相当于继承 Thread 类来说，有以下显著优势：

1. 适合多个相同程序代码的线程去处理同一资源的情况
2. 可以避免由于 Java 的单继承特性带来的局限
3. 增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的

建议在开发中使用 Runnable 接口实现多线程

通过 Callable 和 Future 创建线程

创建线程的 2 种方式，一种是直接继承 Thread，另外一种就是实现 Runnable 接口。

这 2 种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。

如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。

而自从 java 1.5 开始，就提供了 Callable 和 Future，通过它们可以在任务执行完毕之后得到任务执行结果

Callable 接口代表一段可以调用并返回结果的代码;Future 接口表示异步任务，是还没有完成的任务给出的未来结果。所以说 Callable 用于产生结果，Future 用于获取结果。

1. Callable 类似于 Runnable，但是它有返回值，Runnable 没有。
2. new Thread(futureTask);的方式来创建 FuntureTask 任务，FuntureTask 是一个实现了 Runnable 和 Future 接口的类
3. call() 方法可以抛出异常，run() 方法不可以。
4. Callable 规定 (重写) 的方法是 call()，Runnable 规定（重写）的方法是run()。
5. 运行 Callable 任务可以拿到一个 Future 对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过 Future 对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果

示例：

public static void main(String[] args) throws ExecutionException, InterruptedException {
    // 创建线程池
    ExecutorService executorService = Executors.newCachedThreadPool();

    // 提交 Callable 任务
    Future<String> future = executorService.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "hhhh";
        }
    });

    // 获取结果
    String result = future.get();
    System.out.println(result);

    // 关闭线程池
    executorService.shutdown();
}

Callable

Callable 位于 java.util.concurrent 包下，它也是一个接口，在它里面也只声明了一个方法，只不过这个方法叫做 call()：

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

一般情况下是配合 ExecutorService 来使用的，ExecutorService 的 submit 方法可以提交一个 Callable 的参数

Future

Future 就是对于具体的 Runnable 或者 Callable 任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过 get 方法获取执行结果，该方法会阻塞直到任务返回结果。

Future 类位于 java.util.concurrent 包下，它是一个接口，在 Future 接口中声明了 5 个方法

1. boolean cancel(boolean mayInterruptIfRunning):用来取消任务，如果取消任务成功则返回 true，如果取消任务失败则返回 false。参数 mayInterruptIfRunning 表示是否允许取消正在执行却没有执行完毕的任务，如果设置 true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论 mayInterruptIfRunning 为 true 还是 false，此方法肯定返回 false，即如果取消已经完成的任务会返回 false；如果任务正在执行，若 mayInterruptIfRunning 设置为 true，则返回 true，若 mayInterruptIfRunning 设置为 false，则返回 false；如果任务还没有执行，则无论 mayInterruptIfRunning 为 true 还是 false，肯定返回 true。

2. isCancelled()表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。

3. isDone()表示任务是否已经完成，若任务完成，则返回 true；

4. get() 用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；

5. get(long timeout, TimeUnit unit) 用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回 null。

FutureTask

FutureTask 是 Future 接口的一个唯一实现类，FutureTask 实现了 RunnableFuture 接口，而 RunnableFuture 继承了 Runnable 接口和 Future 接口所以它既可以作为 Runnable 被线程执行，又可以作为 Future 得到 Callable 的返回值。

因为实现了 Runnable 所以可以直接使用 Thread 提交线程

// 创建 FutureTask
FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {
    @Override
    public String call() throws Exception {
        return "aa";
    }
});

//启动线程
new Thread(futureTask).start();

// 获取执行结果
String result = futureTask.get();
System.out.println(result);

它的两个构造器如下

FutureTask(Callable<V> callable);
FutureTask(Runnable runnable, V result);

传入 Runnable 和 result 的构造函数就是用来封装 Callable 任务的。它要求我们传入一个 Runnable 对象和一个泛型 V，表示 Callable 任务的返回类型。在内部，FutureTask 会将 Runnable 对象转换为一个 Callable 对象，并在执行时返回 result 的值。

通过线程池

参考： https://javaguide.cn/java/concurrent/java-concurrent-questions-03.html

线程和数据库连接这些资源都是非常宝贵的资源。那么每次需要的时候创建，不需要的时候销毁，是非常浪费资源的。那么我们就可以使用缓存的策略，也就是使用线程池。

使用线程池的好处：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

ExecutorService threadPool = Executors.newFixedThreadPool(10);
while (true) {
    threadPool.execute(new Runnable() {
        // 提交多个线程任务，并执行
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is running ..");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
}

mport java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.*;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Date date1 = new Date();
        int taskSize = 5;
        //创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(taskSize);
        List list = new ArrayList();
        for (int i = 0; i < taskSize; i++) {
            Callable c = new MyCallable(i + " ");
            //执行任务并获取Future对象
            Future f = (Future) pool.submit(c);
            // System.out.println(">>>" + f.get().toString());
            list.add(f);
        }
        // 关闭线程池
        pool.shutdown();
        // 获取所有并发任务的运行结果
        for (Future f : list) {
            // 从Future对象上获取任务的返回值,并输出到控制台
            System.out.println(">>>" + f.get().toString());
        }

        Date date2 = new Date();
        System.out.println("----程序结束运行----,程序运行时间【"
                + (date2.getTime() - date1.getTime()) + "毫秒】");

    }
}

class MyCallable implements Callable