并发编程基础

几个基本概念

• 同步&异步

  • 同步（Synchronous）
    同步方法一旦调用必须等待方法调用返回后才会继续后续行动
  • 异步（AsyncChronous）
    异步调用更像传递一个消息，一旦开始方法调用就会返回，调用者可以进行后续的操作，在java中异步方法异步都会在宁外一个线程中执行，就比如CompletableFutre 的runAsync方法一样
    

• 并发&并行
  并发和并行都可以表示两个或者多个任一起执行

  • 并发
    并发是指多个任务交替执行，多个任务还可能串行的执行
  • 并行
    并行是真正意义上的多个任务同时执行
    

• 临界区
  表示公共资源或者共享数据能够被多个线程使用，但是每次使用只能有一个线程使用（比如办公室的一个打印机，一次只能给一个人打印文件）

• 阻塞&非阻塞
  阻塞和非阻塞是指多个线程的相互影响（比如一个线程占用了临界区资源，那么其他需要使用该资源的线程就会被阻塞），而同步和异步是指方法调用

• 死锁&饥饿&活锁
  死锁、饥饿、活锁都是多线程的活跃性问题

  • 死锁
    线程通常是彼此占用对方需要的锁，但是又不愿意释放自己的锁而导致的
  • 饥饿
    饥饿时指一个或者多个线程一直获取不到需要的资源而无法继续执行（比如一个线程优先级太低，而高优先级的线程不断抢占它的资源，那么低优先级的线程一直无法得到资源进而无法进行后续的工作）
  • 活锁
    多个线程之间相互谦让将资源让给其他线程，大家都在相互谦让导致没有人能
    够获取到资源

• 原子性
  是指一个操作时不可中断的，即使在多个线程环境下，一旦一个操作开始，就不会受其他线程的干扰（比如两个线程对一个int i = 0 进行赋值-1或1，不管两个线程如何操作，i的值要么是-1，要么是1）

• 可见性
  可见性是指一个线程修改了某个共享变量，其他线程是否能够立即知道这个修改，对于串行程序不存在这个问题，但是多线程环境就不一样了，（如果CPU1和CPU2 共享一个变量t，那么CPU1会将t缓存到寄存器中，如果CPU2上的某个线程修改了这个变量，CPU1可能无法意识到这个变化依然读取的是cache或者寄存器中的值）

• 有序性
  程序在执行的过程中可能会发生指令重排

• 进程&线程

  • 进程
    比如windows里运行的QQ，微信等程序，他们直接不会共享内存数据
  • 线程
    比如QQ可以边视频，边传文件，而传文件和视频就是线程，线程之间是可以共享内存数据的，进程可以看做是线程的容器

• 两个重要的定律

  • Amdahl
    加速比定律

  • GustsaFson

• 线程安全

并行基础

• java 线程的生命周期

Thread 类里面定义线程的状态枚举
    public enum State {
         // 线程还没开始刚创建
        NEW,
        // 线程可运行的状态，此时可能需要等其他系统资源，比如处理器
        RUNNABLE,
        // 线程等待monitor lock.比如遇到synchronized代码块，线程就会暂停执行直到拿到monitor lock
        BLOCKED,
         // 当一个线程调用Object.wait，Thread.join， LockSupport.park这些方法时就会进入等待状态，wait方法会直到宁外的线程调用Object.notify() 或者Object.notifyAll()方法
        WAITING,
        // 线程会进入一个有限的等待时间（比如Thread.sleep，Object#wait(long)，Thread#join（long）等方法 ）
        TIMED_WAITING,
        // 线程被中断
        TERMINATED;
    }

• 线程的创建与启动
  方式一，继承于Thread类，并重写run方法

public class MyThread extends Thread {
    @Override
    public void run(){
        System.out.printf("do a job");
    }
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

方式二、
实现Runnable接口(lambda 表达式的写法)

        new Thread(()->{
            System.out.printf("do a job");
        }).start();

因为java是单继承，所以使用runnable接口的方式更加灵活
创建线程的方法可以直接继承Thread，也可以实现Runnable接口

• 正确停止线程的姿势
  线程的正确停止应该是使用一种非暴力的方式让线程停止，避免因为强制停止线程而导致关键任务未执行完或者数据一致性被破坏
  • 1 使用一个volatile修饰的标记变量来让退出run方法的逻辑

      public class ThreadExitTest {
  
          private static volatile boolean isStop = false;
  
          public static void main(String[] args) throws InterruptedException {
                new Thread(()->{
                while (!isStop){
                    System.out.println("i am running");
                 }
                }).start();
                TimeUnit.SECONDS.sleep(2L);
                isStop = true;
        }
      }
  

  ``一定要使用volatile关键字修饰isStop（volatile 关键字能够保证多个线程对变量修改的内存可见性）
  • 2 使用线程中断方法（Thread#interrupt，Thread#interrupted，Thread#isInterrupted ）方法进行退出，线程中断不会是线程立即退出，而是给目标线程发出一个退出的通知，至于目标线程要如何处理完全由目标线程来决定。
    这几个方法的区别

public void interrupt() // 通知目标线程中断，设置中断标志位
public boolean isInterrupted() // 判断当前线程是否被中断
public static boolean interrupted() // 判断当前线程是否被中断,但同时会清除中断标记

几个例子
例子一

        Thread t = new Thread(()->{
            while (true){
                System.out.printf("i am running");
            }
        });
        t.start();
        TimeUnit.SECONDS.sleep(2L);
        t.interrupt();

t 调用了 interrupt方法但是程序仍然会继续执行，因为 run方法没有处理任何的中断逻辑
例子二

        Thread t = new Thread(()->{
            while (true){
                System.out.println("i am running");
                if (Thread.currentThread().isInterrupted()){
                    break;
                }
            }
        });
        t.start();
        TimeUnit.SECONDS.sleep(2L);
        t.interrupt();

当t.interrupt 方法后，中断标志被设置为true，此时目标线程会检查这个标志，并处理相应的退出线程方法的逻辑
例子三
当线程中有sleep，wait, join等方法时会抛出InterruptException，我们可以在目标线程中捕获InterruptException，然后处理相应的退出线程逻辑，因为当线程调用interrupt 方法时，目标线程就会立即捕获InterruptException 异常

• 线程中禁用的方法
  stop，resume，suspend，就不多说了，他们因为比较暴力，也比较容易产生死锁，所以都是不推荐使用的

• Object的wait&notify&nofityAll
  java 多各线程之间可以通过wait和notify来进行协调工作，当一个线程调用object.wait会先获得锁，调用wait方法结束后，CPU会记录当前线程的堆栈信息，并且释放锁（此时其他线程也可以获得锁并调用wait方法），当前线程则进入了object对象线程等待队列，当有其他线程调用object.notify时，jvm会随机从object的线程等待队列中挑选一个线程来执行，与notifyAll 不同的是，调用notifyAll会唤醒所有等待队列中的线程，让他们竞争锁，获取到锁的线程才能继续执行（wait&notify&nofityAll 必须在sychronized块中）
  简单的例子

private static final ForkJoinPool POOL = new ForkJoinPool(3);

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

        String lock = "";
        for (int i = 0;i <= 2; i++){
            POOL.submit(()->{
               long threadId =  Thread.currentThread().getId();
                try {
                    // 开始调用 wait 方法进入等待状态
                    synchronized (lock){
                        // 获得锁进入
                        System.out.println("thread- "+ threadId + " call wait method");
                        // 执行完 wait方法后会释放锁，其他线程仍然可以获取到lock
                        lock.wait();
                        // notify 之后会从lock的等待队列选择一个线程来继续执行后面的逻辑，该线程需要先获得锁
                        System.out.println("thread- "+ threadId + " after wait to continue execute");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            });
        }
        Thread.sleep(2000L);
        System.out.println("start notify");
        synchronized (lock){
            System.out.println("main thread start to notify");
            lock.notify();

        }
        Thread.sleep(Integer.MAX_VALUE);
    }

代码执行结果

thread- 11 call wait method
thread- 10 call wait method
thread- 12 call wait method
start notify
main thread start to notify
thread- 11 after wait to continue execute

join&yield
join 是等待一个线程执行完成，yield让出当前线程的执行时间

• 守护线程
  守护线程是系统的守护者，会在后台完成一些系统性的服务，典型的应用比如垃圾回收器，JIT线程。与之对应的是用户线程，它会完成程序要完成的业务操作，当用户线程全部结束时，守护线程要守护的对象就已经不在了，java虚拟机就会退出。

        Thread t = new Thread(()->{
            System.out.println("do some work");
        });
        t.setDaemon(true);
        t.start();

守护线程必须在线程启动之前设置。

• 线程池
  jvm创建和销毁线程是需要花费很大代价的，因此为了提高线程的利用效率，采用线程池，即避免了线程频繁创建和销毁带来，又能方便管理线程。jdk已经为我们提供了很好的线程池工具类（这一块其他文章详细讲）
• 线程优先级
• 线程安全与synchronized
  线程安全就是一份代码在多线程环境下和单线程环境表现一致，并总能保持正确的运行结果和状态。通常一个类是有状态的，如果有多个线程访问共享这些有状态的变量时就需要采用一些手段来保证这些数据能被线程正确的操作。
  参考书籍《实战高并发程序设计》、《java 并发编程实战》