【简记】Operating System——process synchronization in Java

This memo is based on the course of Dr.Li with Operating System as the reference book.

本章内容：
- 总结之前提到的各种实现同步的方法，并和Java中的对应实现结合起来

---

6.8.1 有限缓冲区

6.8.1.1 忙等

类似忙等的逻辑。

Thread.yield()，主动允许JVM选择另一个可运行线程运行。但此时该线程仍是可运行状态。

但使用yield方法有可能导致活锁（即当线程持续试图做一个动作但总是失败时，就产生活锁）。发生的可能情况是一个线程的优先级高于另一线程，所以高优先级的线程让出使用权，然后因为优先级较高，又重新得到使用权，则产生活锁。

===
6.8.1.2 竞争条件

synchronized关键字，像之前提到的信号量。

在java中，每个对象可以关联一个单独的锁。对象锁有一个进入集合（entry set），如果一个线程想获得该对象锁，但锁被其他线程占用，则进入该集合。当锁可用时，虚拟机会负责调用集合中的等待线程，一般是FIFO，但也有竞争锁的设计。

===
6.8.1.3 死锁

===
6.8.1.4 等待和通知

wait()和notify()

wait()操作：可以让线程主动释放锁，并将自己设置为阻塞状态，进入对象的等待集合（注意不是进入集合！）。

notify()操作：从等待集合中的线程中任一选择一个线程T，将T从等待集合移动到进入集合，设置T的状态由阻塞到可运行。

---

6.8.2 多重通知

采用notify和wait的配合，还是很容易会出现死锁的情况。

因为notify是随机唤醒一个线程，假设唤醒的线程的编号与turn不相等，则会继续调用wait，导致所有线程都在等待集合中。

所以出现了notifyAll()方法。

---

6.8.3 读者-写者问题
（待）

---

6.8.4 块同步

Object mutexLock = new Object();
public void someMethod(){

    synchronized(mutexLock){

    }
}

---

6.8.5 同步规则

1. 拥有对象锁的线程可以进入同一对象的其他synchronized方法
2. 线程可以嵌套不同对象的synchronized方法调用，即可同时拥有多个对象的锁
3. wait(), notify(), notifyAll()只能被synchronized方法或块调用
4. 将static方法声明为synchronized方法，得到的是类锁，类锁只有一个。

---

6.8.6 处理InterruptedException

wait方法可能会抛异常，需要用try-catch或事先声明调用wait方法的方法为抛出异常的方法。

---

6.8.7 Java并发特性

简介下Concurrent包里的内容。

6.8.7.1 ReentrantLock

很多情况下，其作用类似于synchronized方法，但是它提供了几个另外的特性，比如设置一个公平参数，保证把锁交给等待时间最长线程。

Lock key = new ReentrantLock();

key.lock();
try{
    //临界区
}
fianlly{
    key.unlock();
}

===
6.8.7.2 信号量
Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。在数据结构中链表可以保存“无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁 ReentrantLock 也可以实现该功能，但实现上要复杂些。

下面的Demo中申明了一个只有5个许可的Semaphore，而有20个线程要访问这个资源，通过acquire()和release()获取和释放访问许可。

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Semaphore;

public class TestSemaphore {

    public static void main(String[] args) {

// 线程池

        ExecutorService exec = Executors.newCachedThreadPool();

// 只能5个线程同时访问

        final Semaphore semp = new Semaphore(5);

// 模拟20个客户端访问

        for (int index = 0; index < 20; index++) {

            final int NO = index;

            Runnable run = new Runnable() {

                public void run() {

                    try {

// 获取许可

                        semp.acquire();

                        System.out.println("Accessing: " + NO);

                        Thread.sleep((long) (Math.random() * 10000));

// 访问完后，释放

                        semp.release();

                        System.out.println("-----------------"+semp.availablePermits());

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            };

            exec.execute(run);

        }

// 退出线程池

        exec.shutdown();

    }

} 

===
6.8.7.3 条件变量

Lock key = new ReentrantLock();
Condition condVar = key.newCondition();

一旦获得条件变量，可调用await和signal方法。
Concurrent包中允许定义多个条件变量，搭配使用。

不需要使用notifyAll()，利用conditon解决之前可能出现的死锁问题。