Java并发编程基础知识

[TOC]

Java并发编程基础知识

进程和线程

在并行程序中 进程 和 线程 是两个基本的运行单元，在 Java 并发编程中，并发主要核心在于 线程

1. 进程

2. 线程

线程生命周期

一个线程的生命周期包含了一下几种状态

1. 新建状态

   该状态线程已经被创建，但未进入运行状态，我们可以通过 start() 方法来调用线程使其进入可执行状态。

2. 可执行状态/就绪状态

   在该状态下，线程在排队等待任务调度器对其进行调度执行。

3. 运行状态

   在该状态下，线程获得了 CPU 的使用权并在 CPU 中运行，在这种状态下我们可以通过 yield() 方法来使得该线程让出时间片给自己或者其他线程执行，若让出了时间片，则进入就绪队列等待调度。

4. 阻塞状态

   在阻塞状态下，线程不可运行，并且被异除出等待队列，没有机会进行 CPU 执行，在以下情况出现时线程会进入阻塞状态

   suspend()
   sleep()
   wait()
   IO
   

   线程可以从阻塞状态重回就绪状态等待调度，如IO操作完毕后。

5. 终止状态

   当线程执行完毕或被终止执行后便会进入终止状态，进入终止状态后线程将无法再被调度执行，彻底丧失被调度的机会。

线程对象

Thread
 executor 

1. 定义和开始一条线程

在创建一个线程实例时需要提供在线程中执行的代码，有两种方式可以实现。

• 提供一个 Runnable 对象， Runnable 接口定义了一个 run 方法，我们将要在线程中执行的方法放到 run 方法内部，再将 Runnable 对象传递给一个 Thread 构造器，代码如下。

  public class ThreadObject {
      public static void main(String args[]) {
          new Thread(new HelloRunnable()).start();
      }
  }
  // 实现Runnable接口
  class HelloRunnable implements Runnable {
      @Override
      public void run() {
          System.out.println("Say hello to world!!!");
      }
  }

• 继承 Thread ，Thread类自身实现了 Runnable 接口，但是其 run 方法什么都没做，由我们自己根据需求去扩展。

  public class ThreadObject {
      public static void main(String args[]) {
          new HelloThread().start();
      }
  }
  // 继承Thread，扩展run方法
  class HelloThread extends Thread {
      public void run() {
          System.out.println("Say hello to world!!!");
      }
  }

两种实现方式的选取根据业务场景和 Java 中 单继承，多实现 的特性来综合考量。

2. 利用Sleep暂停线程执行

sleep() 方法会使线程进入阻塞队列，进入阻塞队列后，线程会将 CPU时间片 让给其他线程执行， sleep() 有两个重载方法 sleep(long millis)和sleep(long millis, int nanos) 当到了指定的休眠时间后，线程将会重新进入就绪队列等待调度管理器进行调度

public static void main(String args[]) throws InterruptedException {
    for (int i = 0; i < 4; i++) {
        System.out.println("print number "+ i);
        // 将主线程暂停4秒后执行,4秒后重新获得调度执行的机会
        Thread.sleep(4*1000);
    }
}

3. 中断

当一个线程被中断后就代表这个线程再无法继续执行，将放弃所有在执行的任务，程序可以自己决定如何处理中断请求，但通常都是终止执行。

在 Java 中与中断相关的有 Thread.interrupt()、Thread.isInterrupted()、Thread.interrupted() 三个方法

Thread.interrupt() 为设置中断的方法，该方法会将线程状态设置为 确认中断 状态，但程序并不会立马中断执行只是设置了状态，而 Thread.isInterrupted()、Thread.interrupted() 这两个方法可以用于捕获中断状态，区别在于 Thread.interrupted() 会重置中断状态。

4. Join

join 方法允许一条线程等待另一条线程执行完毕，例如 t 是一条线程，若调用 t.join() 方法，则当前线程会等待 t 线程执行完毕后再执行。

线程同步 Synchronization

各线通信方式

• 共享对象的访问权限 如. A和B线程都有访问和操作某一个对象的权限
• 共享 对象的引用对象 的访问权限 如. A和B线程都能访问C对象，C对象引用了D对象，则A和B能通过C访问D对象

这种通信方式使得线程通讯变得高效，但是也带来一些列的问题例如 线程干扰和内存一致性错误 。那些用于防止出现这些类型的错误出现的工具或者策略就叫做同步。

1. 线程干扰 Thread Interference

public class ThreadInterference{
    public static void main(String args[]) throws InterruptedException {
        Counter ctr = new Counter();
        // 累加线程
        Thread incrementThread = new Thread(()->{
            for(int i = 0; i<10000;i++) {
                ctr.increment();
            }
        }); 
        // 累减线程
        Thread decrementThread = new Thread(()->{
            for(int i = 0; i<10000;i++) {
                ctr.decrement();
            }
        }); 
        incrementThread.start();
        decrementThread.start();
        incrementThread.join();
        decrementThread.join();
        System.out.println(String.format("最终执行结果：%d", ctr.get()));
    }
}
class Counter{
    private int count = 0;
    // 自增
    public void increment() {
        ++this.count;
    }
    // 自减
    public void decrement() {
        --this.count;
    }
    public int get() {
        return this.count;
    }
}

count
count

2. 内存一致性错误 Memory Consistency Errors

当不同的线程对应相同数据具有不一致的视图时，会发生内存一致性错误，详细信息参见 JVM内存模型

3. 同步方法

Java 提供了两种同步的惯用方法：同步方法 synchronized methods 、同步语句 synchronized statements 。要使方法变成同步方法只需要在方法声明时加入 synchronized 关键字，如

class Counter{
    private int count = 0;
    // 自增
    public synchronized void increment() {
        ++this.count;
    }
    // 自减
    public synchronized void decrement() {
        --this.count;
    }
    public synchronized  int get() {
        return this.count;
    }
}

声明为同步方法之后将会使得对象产生如下所述的影响

• 首先，不可以在同一对象上多次调用同步方法来交错执行，同步声明使得同一个时间只能有一条线程调用该对象的同步方法，当一条线程已经在调用同步方法时，其他线程会被阻塞 block ，无法调用该对象的所有同步方法。
• 其次，当同步方法调用结束时，会自动与同一对象的任何后续调用方法建立一个 happens-before 关联，这保证对对象状态的更改对所有线程可见。

4. 内部锁和同步

同步是围绕对象内部实体构建的， API 规范通常将此类实体称之为监视器，内部锁有两个至关重要的作用

happens-before

每个对象都有与其关联的固有锁，通常，需要对对象的字段进行独占且一致的访问前需要获取对象的内部锁，然后再使用完成时释放内部锁，线程在获取后释放前拥有该对象的内部锁。只要线程拥有了内部锁其他任何线程都无法获取相同的锁，其他线程在尝试获取锁时将被阻塞。在线程释放内部锁时，该操作将会在该对象的任何后续操作间建立 happens-before 关系。

4.1 同步方法中的锁

当线程调用同步方法时，线程会自动获得该方法所属对象得内部锁，并且在方法返回时自动释放，即使返回是由未捕获异常导致。静态同步方法的锁不同于实例方法的锁，静态方法是围绕该类进行控制而非该类的某一个实例。

4.2 同步语句

另外一个提供同步的方法是同步代语句，与同步方法不同的是，同步语句必须指定一个对象来提供内部锁。

public class IntrinsicLock {
    private List<String> nameList = new LinkedList<String>();
    private String lastName;
    private int nameCount;

    public void addName(String name) {
        // 当多条线程对同一个实例对象的addName()方法操作时将会是同步的，提供锁的对象为该实例对象本身
        synchronized(this) {
            lastName = name;
            nameCount++;
        }
        nameList.add(name);
    }
}

同步语句对细粒度同步提高并发性也很有用，比如我们需要对同一个对象的不同属性进行同步修改我们可以通过如下代码来提高细粒度同步控制下的并发。

public class IntrinsicLock {
    // 1. 该属性需要基于同步的修改
    private String lastName;
    // 1. 该属性也需要基于同步的修改
    private int count;
    
    // 该对象用于对lastName提供内部锁
    private Object nameLock = new Object();
    // 该对象用于对nameCount提供内部锁
    private Object countLock = new Object();
    
    public void addName(String name) {
        synchronized(nameLock) {
            lastName = name;
        }
    }
    public void increment() {
        synchronized(countLock) {
            count++;
        }
    }
}

这样，对 lastName 的操作不会阻塞 count 属性的自增操作，因为他们分别使用了不同的对象来提供锁。若像上一个例子中使用 this 来提供锁的话，则在调用 addName() 方法时 increment() 也被阻塞，反之亦然，这样将会增加不必要的阻塞。

4.3 可重入同步

线程无法获取另外一个线程已经拥有的锁，但是线程可以多次获取它已经拥有的锁，允许线程多次获取同一锁可以实现可重入的同步，即同步方法或者同步代码块中又调用了由同一个对象提供锁的其他同步方法时，该锁可以多次被获取

public class IntrinsicLock {
    private int count;
    public void decrement(String name) {
        synchronized(this) {
            count--;
            // 调用其他由同一个对象提供锁的同步方法时，锁可以重复获取
            // 但只能由当前有用锁的线程重复获取
            increment();
        }
    }
    public void increment() {
        synchronized(this) {
            count++;
        }
    }
}

4.4 原子访问

在编程中，原子操作指的是指所有操作一行性完成，原子操作不可能执行一半，要么全都执行，要么都不执行。在原子操作完成之前，其修改都是不可见的。在 Java 中以下操作是原子性的。

• 读写大部分原始变量（除了 long 和 double ）
• 读写所有使用 volatile 声明的变量

原子操作的特性使得我们不必担心线程干扰带来的同步问题，但是原子操作依然会发生内存一致性错误。需要使用 volatile 声明变量以有效防止内存一致性错误，因为写 volatile 标记的变量时会与读取该变量的后续操作建立 happens-before 关系，所以改变使用 volatile 标记变量时对其他线程总是可见的。也就是它不仅可以观测最新的改变，也能观测到尚未使其改变的操作。

5. 死锁

死锁是描述一种两条或多条线程相互等待（阻塞）的场景，如下例子所示

public class DeadLock {
    static class Friend {
        String name;
        public Friend(String name) {
            super();
            this.name = name;
        }
        public String getName() {
            return name;
        }
        public synchronized void call(Friend  friend) {
            System.out.println(String.format("%s被%s呼叫...", name,friend.getName()));
            friend.callBack(this);
        }
        public synchronized void callBack(Friend  friend) {
            System.out.println(String.format("%s呼叫%s...", friend.getName(),name));
        }
    }
    
    public static void main(String args[]) {
        final Friend zhangSan = new Friend("张三");
        final Friend liSi = new Friend("李四");
        new Thread(new Runnable() {
            public void run() { zhangSan.call(liSi); }
        }).start();
        new Thread(new Runnable() {
            public void run() { liSi.call(zhangSan); }
        }).start();
    }
}

如果张三呼叫李四的同时，李四呼叫张三，那么他们会永远等待对方，线程永远阻塞。

6. 饥饿和活锁

相对死锁而言，饥饿和活锁问题要少得多，但是也应注意。

6.1 饥饿

饥饿是一种描述线程无法定期访问共享资源，程序无法取得正常执行的一种场景，比如一个同步方法执行时间很长，但是多条线程争抢且频繁的执行，那么将会有大量线程无法在正常的情况下获得使用权，造成大量阻塞和积压，我们使用饥饿来描述这种并发场景。

6.2 活锁

活锁是一种描述线程在执行同步方法的过程中依赖其他外部资源，而该部分获取缓慢而无保障造成无法进一步执行的的场景，相对于死锁，活锁是有机会进一步执行的，只是执行过程缓慢，造成部分资源被 正在等待其他资源的线程占用。

7. 保护块/守护块

通常，线程会根据其需要来协调其操作。最常用的协调方式便是通过守护块的方式，用一个代码块来轮询一个一条件，只有到该条件满足时，程序才继续执行。要实现这个功能通常有几个要遵循的步骤，先给出一个并不是那么好的例子 请勿在生产代码使用以下示例

public void guardedJoy() {
    // 这是一个简单的轮询守护块，但是极其消耗资源
    // 请勿在生产环境中使用此类代码，这是一个不好的示例
    while(!joy) {}
    System.out.println("Joy has been achieved!");
}

这个例子中，只有当别的线程讲 joy 变量设置为 true 时，程序才会继续往下执行，在理论上该方法确实能实现守护的功能，利用简单的轮询，一直等待条件满足后，才继续往下执行，这是这种轮询方式是极其消耗资源的，因为轮询会一直占用 CPU 资源。别的线程便无法获得CPU进行处理。

一个更为有效的守护方式是调用 Object.wait 方法来暂停线程执行，暂停后线程会被阻塞，让出CPU时间片给其他线程使用，直到其他线程发出一个某些条件已经满足的通知事件后，该线程会被唤醒重新执行，即使其他线程完成的条件并非它等的哪一个条件。更改上面的代码

public synchronized  void guardedJoy() {
    // 正确的例子,该守护快每次被其他线程唤醒之后只会轮询一次，
    while(!joy) {
        try{
            wait();
        }catch(Exception e) {}
    }
    System.out.println("Joy has been achieved!");
}

为什么这个版本的守护块需要同步的？假设 d 是一个我们调用 wait 方法的对象，当线程调用 d.wait() 方法时线程必须拥有对象 d 的内部锁，否则将会抛出异常。在一个同步方法内部调用 wait() 方法是一个简单的获取对象内部锁的方式。当 wait() 方法被调用后，当前线程会释放内部锁并暂停执行，在将来的某一刻，其他线程将会获得 d 的内部锁，并调用 d.notifyAll() 方法，来唤醒由对象 d.wait() 方法暂停执行的线程。

public synchronized notifyJoy() {
    joy = true;
    // 唤醒所有被wait()方法暂停的线程
    notifyAll();
}