Java-10_2-并发编程

使用 Java 进行并发编程，最好的方案是尽量减少多个进程间的数据共享。如果一定需要共享数据，则推荐使用上一篇中介绍的 Java 类库中线程安全的类进行数据的处理。但为了了解这些 Java 类库中线程安全类的实现方案，也防止我们在极端的时候需要实现自己的线程安全的类，本篇中通过介绍锁，以及 thread 的概念，来了解线程安全的具体机制与底层实现方法。

A. 锁与条件

Java 中可以通过加锁来保证程序的线程安全，通过对 lock 原理机制的了解，我们可以更好的理解线程安全的数据结构，计数器的内部实现。

但由于 lock 的错误使用可能引发的重大程序风险（deadlock），在实际应用中，lock 应当被作为最后的备用选项。我们应当首先尝试避免在不同线程间分享数据，或者使用不可更改（immutable）的数据，或者通过数据的复制进行线程间值的传递。如果必须使用公用的数据，则优先考虑使用 Java 类库提供的线程安全对象和方法。

a. 同步锁的实现

首先通过下面的例子，解释锁的作用流程：

Lock countLock = new ReentrantLock();  // 该对象可以在不同线程中分享使用
int count;
...
countLock.lock();
try{
   count++;
} finally{
   countLock.unlock();
}

上述的程序中，我们声明了一个 Lock 类型的对象，在程序中，当其他的线程尝试调用这个 lock 的时候，系统会检查这个锁是否已经被占用，如果被占用，需要进行等待，直到占用锁的进行调用了 unlock() 方法后，才能获得锁并执行锁之后的程序。从而保证了线程的安全。

需要注意的是，unlock 方法一定要保证得到执行，否则程序会阻塞在 lock 调用的位置，造成危险。

在实际的使用中，我们并不显示的使用 lock 对象，而是使用 synchronized 关键字隐式的调用对象的固有锁，例子如下：

// 锁住一部分代码块
// 相当于调用 obj.intrinsicLock
// 并没有 obj.intrinsicLock 这一变量，这里仅是方便理解
synchronized (obj){
   Critical section;
}

// 锁住函数方法
// 相当于调用 this.intrinsicLock 
// 并没有 this.intrinsicLock 这一变量，这里仅是方便理解
public synchronized void method(){
   body...
}

b. 等待条件

wait(), notifyAll() 方法为 Object 类的方法，他们都用于带锁的线程程序。当程序调用 wait() 方法时，wait() 所在的线程会交出锁，然后被放置到一个等待集合中（wait set）， 并会一直处于等待状态，直到当其他线程中调用了 notifyAll() 方法，wait set中所有的线程会被唤醒，并有机会重新获得程序锁。当重新获得锁后，线程程序会从 wait() 所在的程序子句重新开始执行。 （还有 notify() 方法，只唤醒 wait set 中的一个线程。）

B. 线程

线程是系统任务并发任务执行的载体，通常，我们推荐使用 excutor 来管理 thread。当然，Java 也提供了让设计者自己控制 thread 的方法。

a. 线程的基本操作

通过下述代码，我们看线程的基础启动，睡眠，中断操作。

// 新建 and 启动线程
Runnable task = () -> {...};
Thread thread = new Thread(task);
thread.start();   

// 线程休眠
Runable task = () ->{
   ...
   Thread.sleep(millis); // 任务所在的线程休眠 millis 时间
   ...
};

// 等待线程执行结束
thread.join(milllis);

// 中断
thread.interrput();  // 设置中断标志位为 true
thread.isInterrupted(); // 检测线程的中断标志位
// 可以使用下述方法，实现程序的中断
Runnable task = () ->{
   while(more work to do){
      if(Thread.currentThread().isInterrupted()) return;
      do more work...
   }
};

线程的中断机制比较奇怪，实际上并不是真的暂停程序，而是仅去设置一下程序的中断标志位。 (参考) 具体的借助该中断标志位实现线程任务的终止的方法，参考上面的示例程序。

当线程触发中断时，线程正处于 sleep() or 等待 等情况时，线程会立即被重新激活，并且抛出一个 InterruptedException，但是，这种情况下，中断标志位并没有变化。

Thread 类的 stop(), suspend(), resume()方法，已经不推荐使用。

b. 线程的本地变量与其他性质

线程可以通过 ThreadLocal 辅助类来实现属于每个线程自己的实例变量，具体操作如下：

public static final ThreadLocal<NumberFormat> currencyFormat
   = ThreadLocal.withInitial(() -> NumberFormat.getCurrencyInstance());

// 在线程中
String amountDue = currencyFormat.get().format(total);

在线程中，当第一次调用 currencyFormat 的get() 方法，lambda 表达式中的方法会被调用，构造一个属于当前线程的实例对象。

线程其他特性

线程可以分组，通常使用 excutor 机制自动管理线程组。

线程可设定优先级，优先级与系统，实现平台有很大关系，可移植性不好，因此不建议使用。

线程有状态，new, running, blocked on input/output 等。

Daemon线程，是一个辅助线程，唯一的工作就是为其他线程提供服务。可以通过 thread.setDaemon(true) 启动该线程。

C. 进程

进程（process）是操作系统中用于运行每一个程序的承载单元，Java 可以通过 Process 类 和 ProcessBuilder 类来配置、构建进行。

下面简单介绍Java 处理进行的方案：

1. 构建进程（Build a Process）

// 新建进程，参数中必须要有可执行的指令用于处理后面的文件
ProcessBuilder builder = new ProcessBuilder("gcc", "myapp.c");

// 工作路径配置 - 每一个进程必须要有一个工作路径
// 由java 启动的进程默认工作路径与 JVM 相同
builder = builder.directory(path.toFile());

// 获取信息流，下面的 p 为process 的对象
// 需要注意：Java 程序中的输入流是 process 中的输出流，
// java 程序中的输出流是 process 程序中的 输入流
OutputStream processIn = p.getOutputStream();
InputStream processOut = p.getInputStream();
InputStream processErr = p.getErrorStream();

2. 启动、运行进程

// 启动进程
// 并将进程中的输出返回到 java 程序中进行输出
Process process = new ProcessBuilder("/bin/ls", "-l")
   .directory(Paths.get("/tmp").toFile())
   .start();
try(Scanner in = new Scanner(process.getInputStream())){
   while(in.hasNextLine()){
      System.out.println(in.nextLine());
   }
}

// 等待进程运行结束，得到返回值
int result = process.waitFor();

// 杀进程
process.destroyForcibly();

// 进程退出
process.onExit().thenAccept(
   p -> System.out.println("Exit value: " + p.exitValue()));

Java 可以通过 进程句柄（process handle）来获得进程信息。共有4中构建 handle 的方案，参考 10.9.3 节。具体的使用参考 ProcessHandle 接口中的方法。