线程同步基础

两种基本的同步机制：synchronized与锁

1. 同步方法

每一个被synchronized方法就是一个关键代码段，在同一时间，Java只能执行某个对象的其中一个关键代码块。然而，静态方法的行为不同，只有一个执行线程能够访问所有synchronized的静态方法中的一个，但是另一个线程可以访问该类的某个对象的非静态方法。也就是说，如果有两个同步方法，一个是静态的，另一个是非静态的，则两个线程是可以同时分别访问两个方法的。这一原则有可能导致两个方法去修改同一数据。例如，

class Account {
    public static double balance;
    public static synchronized void addAmount(double amount) {
        balance += amount;
    }

    public synchronized void substractAmount(double amount) {
        balance -= amount;
    }
}

2. 不同属性用不同对象同步

通常地，this关键字会被用来作为同步代码块的控制变量，但是也可以用其他的对象引用作为同步代码块的关键字。例如，用两个对象类分别作为某个类的两个属性的同步控制变量，这样两个线程可以同时独立地访问两个属性。

class Cinema {
    private long vacanciesCinema1;
    private long vacanciesCinema2;

    private final Object controlCinema1;
    private final Object controlCinema2;

    public Cinema() {
        controlCinema1 = new Object();
        controlCinema2 = new Object();

        vacanciesCinema1 = 20;
        vacanciesCinema2 = 20;
    }

    public boolean sellTickets1(long number) {
        synchronized (controlCinema1) {
            if (number <= vacanciesCinema1) {
                vacanciesCinema1 -= number;
                return true;
            }
            else {
                return false;
            }
        }
    }

    public boolean sellTickets2(long number) {
        synchronized (controlCinema2) {
            if (number <= vacanciesCinema2) {
                vacanciesCinema2 -= number;
                return true;
            }
            else {
                return false;
            }
        }
    }

    public long getVacanciesCinema1() {
        return vacanciesCinema1;
    }

    public long getVacanciesCinema2() {
        return vacanciesCinema2;
    }
}

3. wait/notify/notifyAll

在生产者-消费者模型中，通常用一个buffer作为共享的数据结构，当buffer满的时候，生产者不能再放入数据；当buffer空的时候，消费者不能取数据。对于以上两种情况，java在Object类中提供了wait notify notifyAll方法。wait方法需要在同步代码块中被调用，否则，将会抛出IllegalMonitorStateException。 当被调用时，JVM将会使当前线程sleep，同时释放控制同步代码块的对象锁，必须使用nofity或者notifyAll来唤醒该线程。

class EventStorage {
    int maxSize;
    LinkedList<Date> storage;
    
    public EventStorage() {
        maxSize = 10;
        storage = new LinkedList<>();
    }
    
    public synchronized void set() {
        while (storage.size() == maxSize) {
            try {
                wait();
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        storage.offer(new Date());
        System.out.printf("Set: %d\n", storage.size());
        notifyAll();
    }
    
    public synchronized void get() {
        while (storage.size() == 0) {
            try {
                wait();
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        storage.poll();
        System.out.printf("Get: %d\n", storage.size());
        notifyAll();
    }
}

4. Lock

Java提供了另一种同步代码块的机制，它是基于Lock接口和它的实现类（例如ReentrantLock）来实现的，这种机制更加强大和灵活，主要的优点表现在：
1）Lock接口允许更加复杂的结构，synchronized关键字必须要用结构化的方法来获取或者释放同步代码块；
2）Lock接口提供了一些额外的功能。例如tryLock()方法。
3）当只有一个写和多个读的线程时，Lock接口允许读写操作的分离
4）Lock接口的性能更高

class PrintQueue {
    private final Lock queueLock = new ReentrantLock();
    
    public void printJob(Object document) {
        queueLock.lock();

        try {
            long duration = (long)(Math.random()*10000);
            System.out.println(Thread.currentThread().getName() + ": PrintQueue: Printing a Job during " + (duration/1000) + " seconds");
            Thread.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            queueLock.unlock();
        }
    }
}

class Job implements Runnable {
    private PrintQueue printQueue;
    
    public Job(PrintQueue printQueue) {
        this.printQueue = printQueue;
    }

    @Override
    public void run() {
        System.out.printf("%s: Going to print a document\n", Thread.currentThread().getName());
        printQueue.printJob(new Object());
        System.out.printf("%s: The document has been printed\n", Thread.currentThread().getName()); 
    }
}

5. 读写锁

ReadWriteLock是所有Lock接口中最重要的接口之一，ReentrentReadWriteLock是它的唯一实现类。该类有两个锁，一个是读操作另一个是写操作。它能够同时包括多个读操作，但是只能有一个写操作。当某个线程执行写操作时，其他任何线程都不能执行读操作。

class PricesInfo {
    private double price1;
    private double price2;

    private ReadWriteLock lock;

    public PricesInfo() {
        price1 = 1.0;
        price2 = 2.0;
        lock = new ReentrantReadWriteLock();
    }

    public double getPrice1() {
        lock.readLock().lock();
        double value = price1;
        lock.readLock().unlock();
        return value;
    }

    public double getPrice2() {
        lock.readLock().lock();
        double value = price2;
        lock.readLock().unlock();
        return value;
    }

    public void setPrices(double price1, double price2) {
        lock.writeLock().lock();
        this.price1 = price1;
        this.price2 = price2;
        lock.writeLock().unlock();
    }
}

6. 公平锁

ReentrantLock和ReentrantReadWriteLock的构造函数可以传入一个boolean型的参数fair，该参数默认为false，如果设置为true，则在多个线程等待同一个锁时，选择等待时间最长的线程优先执行。

class MessageQueue implements MyQueue {
    private Lock queueLock = new ReentrantLock(true);

    public void printJob(Object document) {
        queueLock.lock();
        try {
            long duration = (long)(Math.random()*10000);
            System.out.println(Thread.currentThread().getName() + ": PrintQueue: Printing a Job during " + (duration/1000) + " seconds");
            Thread.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            queueLock.unlock();
        }

        queueLock.lock();
        try {
            long duration = (long)(Math.random()*10000);
            System.out.println(Thread.currentThread().getName() + ": PrintQueue: Printing a Job during " + (duration/1000) + " seconds");
            Thread.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            queueLock.unlock();
        }
    }
}

7. 一个锁的多个condition

class Buffer {
    private LinkedList<String> buffer;
    private int maxSize;
    private ReentrantLock lock;
    private Condition lines;
    private Condition space;
    private boolean pendingLines;

    public Buffer(int maxSize) {
        this.maxSize = maxSize;
        buffer = new LinkedList<>();
        lock = new ReentrantLock();
        lines = lock.newCondition();
        space = lock.newCondition();
        pendingLines = true; //是否还会有lines insert到Buffer中
    }

    public void insert(String line) {
        lock.lock();
        try {
            while(buffer.size() == maxSize) {
                space.wait();
            }
            buffer.offer(line);
            System.out.printf("%s: Inserted Line: %d\n", Thread.currentThread().getName(), buffer.size());
            lines.signalAll();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public String get() {
        String line = null;
        lock.lock();
        try {
            while ((buffer.size() == 0) && hasPendingLines()) {
                lines.await();
            }

            if(hasPendingLines()) {
                line = buffer.poll();
                System.out.printf("%s: Line Readed: %d\n", Thread.currentThread().getName(), buffer.size());
                space.signalAll();
            }
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }

        return line;
    }

    public boolean hasPendingLines() {
        return pendingLines || buffer.size() > 0;
    }

    public void setPendingLines(boolean pendingLines) {
        this.pendingLines = pendingLines;
    }
}