JUC--Lock锁和Condition条件

浅谈Synchronized:

　　synchronized是Java的一个关键字,也就是Java语言内置的特性,如果一个代码块被synchronized修饰了,当一个线程获取了对应的锁,执行代码块时,其他线程

便只能一直等待,等待获取锁的线程释放锁,而获取锁的线程释放锁会有三种情况：

　　1).获取锁的线程执行完该代码块,然后线程释放对锁的占有;

　　2).线程执行发生异常,此时JVM会让线程自动释放锁;

　　3).调用wait方法,在等待的时候立即释放锁,方便其他的线程使用锁.

Lock的特性:

　　1).Lock不是Java语言内置的;

　　2).synchronized是在JVM层面上实现的,如果代码执行出现异常,JVM会自动释放锁,但是Lock不行,要保证锁一定会被释放,就必须将unLock放到finally{}中(手动释放);

　　3).在资源竞争不是很激烈的情况下,synchronized的性能要优于ReetarntLock,但是在很激烈的情况下,synchronized的性能会下降几十倍;

　　4).ReentrantLock增加了锁:

　　　　a. void lock(); // 无条件的锁;

　　　　b. void lockInterruptibly throws InterruptedException;//可中断的锁;

　　　　　解释:使用ReentrantLock如果获取了锁立即返回,如果没有获取锁,当前线程处于休眠状态,直到获得锁或者当前线程可以被别的线程中断去做其他的事情;但是如果是                                 synchronized的话,如果没有获取到锁,则会一直等待下去;

　　　　c. boolean tryLock();//如果获取了锁立即返回true,如果别的线程正持有,立即返回false,不会等待;

　　　　d. boolean tryLock(long timeout,TimeUnit unit);//如果获取了锁立即返回true,如果别的线程正持有锁,会等待参数给的时间,在等待的过程中,如果获取锁,则返回true,如果                      等待超时,返回false;

Condition的特性:

　　1.Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。不同的是，Object中的这些方法是和同步锁捆绑使用的；而Condition是需要与互斥锁/共享锁捆绑使用的。

　　2.Condition它更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。
　　　　例如，假如多线程读/写同一个缓冲区：当向缓冲区中写入数据之后，唤醒"读线程"；当从缓冲区读出数据之后，唤醒"写线程"；并且当缓冲区满的时候，"写线程"需要等待；当缓冲区为空时，"读线程"需要等待。      

　　　　 如果采用Object类中的wait(), notify(), notifyAll()实现该缓冲区，当向缓冲区写入数据之后需要唤醒"读线程"时，不可能通过notify()或notifyAll()明确的指定唤醒"读线程"，而只能通过notifyAll唤醒所有线程(但是notifyAll无法区分唤醒的线程是读线程，还是写线程)。  但是，通过Condition，就能明确的指定唤醒读线程。

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class AddSubTask {

    private final Lock lock = new ReentrantLock();

    private final Condition addCondition = lock.newCondition();

    private final Condition subCondition = lock.newCondition();


    private static int num = 0;
    private List<String> lists = new LinkedList<String>();

    public void add() {
        lock.lock();
        try {
            while (lists.size() == 10) {//当集合已满,则"添加"线程等待
                System.out.println(Thread.currentThread().getName()+" list is full,await...");
                addCondition.await();
            }
            num++;
            lists.add("add num " + num);
            System.out.println(Thread.currentThread().getName()+" add num:"+num);

            this.subCondition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {//释放锁
            lock.unlock();
        }
    }

    public void sub() {
        lock.lock();
        try {
            while (lists.size() == 0) {//当集合为空时,"减少"线程等待
                System.out.println(Thread.currentThread().getName()+" list is empty,await...");
                subCondition.await();
            }
            String str = lists.get(0);
            lists.remove(0);
            System.out.println(Thread.currentThread().getName()+" sub num:"+num);
            num--;
            addCondition.signal();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

import lombok.SneakyThrows;

import java.util.Random;

public class Test {

    public static void main(String[] args) {
        AddSubTask task = new AddSubTask();
        Thread t1 = new Thread(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                while (true) {
                    Thread.sleep(new Random().nextInt(1000));
                    task.add();
                }
            }
        });
        t1.setName("P1");
        Thread t2 = new Thread(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                while (true) {
                    Thread.sleep(new Random().nextInt(1000));
                    task.add();
                }
            }
        });
        t2.setName("P2");
        Thread t3 = new Thread(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                while (true) {
                    Thread.sleep(new Random().nextInt(1000));
                    task.sub();
                }
            }
        });
        t3.setName("C1");

        t1.start();
        t2.start();
        t3.start();

    }

}