2.同步控制

一、重入锁ReentrantLock

1. 常用方法

public static ReentrantLock lock = new ReentrantLock();
lock.lock();//获得锁,如果锁已被占用,则等待
lock.lockInterruptibly();//获得锁,但优先响应中断
lock.tryLock();//尝试获得锁,若成功则返回true,若当前锁被其他线程占用，申请锁失败，则返回false,该方法不等待,因此也不会产生死锁
lock.tryLock(long time, TimeUnit unit);//在给定时间内尝试获得锁
lock.unlock();//释放锁

2. 简单的重入锁使用案例

public class Create implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();
    public static int i = 0;
    @Override
    public void run() {
        for (int j = 0; j < 10000000; ++j) {
            lock.lock();
            try {
                i++;
            } finally {
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException { }
}

3. 和synchronized的对比

和synchronized相比，重入锁有明显的操作过程，开发人员必须手动指定何时加锁，何时释放，因此，重入锁对逻辑控制的灵活性高于synchronized。
对于synchronized来说，若一个线程在等待锁，那么只会有两种情况
	1.获得这把锁继续运行
	2.保持等待
但是使用重入锁lockInterruptibly，线程则可以在等待过程中被中断

4. 重入的含义

锁可以反复使用，一个线程可以连续两次获得同一把锁,但需要注意的是，如果同一个线程多次获得锁，那么也必须释放相同次数
    若释放次数多了，就会得到一个java.lang.IllegalMonitorStateException异常
    若释放次数少了，那么相当于线程还持有这个锁，其他线程无法进入临界区

//重入锁实例
lock.lock();
lock.lock();
try{
     i++;
}finally {
    lock.unlock();
    lock.unlock();
}

5. 中断响应 lockInterruptibly

//demo
public class IntLock implements Runnable {
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;
    public IntLock(int lock) {
        this.lock = lock;
    }
    @Override
    public void run() {
        try {
            if (lock == 1) {
                lock1.lockInterruptibly();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock2.lockInterruptibly();
            } else {
                lock2.lockInterruptibly();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock1.lockInterruptibly();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock1.isHeldByCurrentThread())
                lock1.unlock();
            if (lock2.isHeldByCurrentThread())
                lock2.unlock();
            System.out.println(Thread.currentThread().getId() + "线程退出");
        }
    }
    public static void main(String[] args) throws InterruptedException {
        IntLock r1 = new IntLock(1);
        IntLock r2 = new IntLock(2);
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        Thread.sleep(1000);
        t2.interrupt();
    }
}
//线程t1和t2启动后,t1先占用lock1,再占用lock2,t2先占用lock2,再占用lock1.因此两者很容易形成相互等待
//而使用lockInterruptibly，在main函数中对t2进行中断，此时t2会放弃lock1的申请，同时释放已获得的lock2,然后t1就可以获得lock2继续执行下去

6.锁申请等待限时tryLock

  //demo
public class IntLock implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();
    private static int i = 1;
    @Override
    public void run() {
        try {
            while (lock.isLocked()) {
                System.out.println(Thread.currentThread().getId() + " 线程被阻塞，等待中，第" + i++ + "次尝试");
                Thread.sleep(1000);
            }
            if (lock.tryLock(5, TimeUnit.SECONDS)) {
                System.out.println(Thread.currentThread().getId() + " 获得线程，开始休眠");
                Thread.sleep(6000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getId() + " 释放");
            if (lock.isHeldByCurrentThread()) lock.unlock();
        }
        System.out.println(Thread.currentThread().getId() + " 结束");
    }
    public static void main(String[] args) throws InterruptedException {
        IntLock r1 = new IntLock();
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r1);
        t1.start();
        Thread.sleep(1000);
        t2.start();
        t2.join();
        System.out.println("MISSION　COMPLETE");
    }
}

7. 公平锁

public static ReentrantLock lock = new ReentrantLock(boolean fair);
public static ReentrantLock lock = new ReentrantLock(true);//公平锁

在多数情况下，锁都是非公平的，例如线程1请求了锁A，然后线程2也请求获得锁A，非公平锁是随机分配给1或者2的，但是公平锁则是按照先到先得的理念分配锁，也就是先分配给1然后给2,

公平锁的一大特点是不会产生饥饿，只要你排队就一定能获得资源。虽然公平锁看起来很优美，但是公平锁实现内部必然要维持一个有序队列，因而效率很低，因此若没有特别需求则不需要使用公平锁

二、Condition

ReentrantLock lock = new ReentrantLock()；
Condition condition = lock.newCondition();
通过lock接口获得一个Condition对象，就可以让线程在合适的时间等待，或在某特定时刻得到通知，继续执行。
当线程使用 await()方法时,要求线程持有相关的重入锁,在 await()方法调用后，这个线程会释放这个锁，同理， signal()方法调用时，也要求线程先获得相关的锁，在调用完后，一定要释放锁，否则程序无法继续执行

1.基本方法

await();
await(long time, TimeUnit unit);
awaitNanos(long nanoTimeout);
awaitUninterruptibly();
awaitUntil(Date deadline);
signal();//唤醒一个等待中的进程
signalAll();//唤醒所有等待中的进程

2.和wait()、notify()方法的异同

wait()和notify()方法是与synchronized配合使用的，而Condition是与重入锁相关联的

3.demo

public class ReenterLockCondition implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();
    public static Condition condition = lock.newCondition();
    @Override
    public void run() {
        try {
            lock.lock();//当线程使用await()方法时,要求线程持有相关的重入锁
            condition.await();//await()方法调用后，这个线程会释放这个锁
            System.out.println("Thread is going on");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ReenterLockCondition r1 = new ReenterLockCondition();
        Thread t1 = new Thread(r1);
        t1.start();
        Thread.sleep(2000);
        lock.lock();//Condition.signal()方法调用时，要求线程先获得相关的锁
        condition.signal();
        lock.unlock();//在调用完后，一定要释放锁，否则t1无法继续执行
    }
}

三、信号量Semaphore

信号量是对锁的扩展，无论是内部锁synchronized或重入锁ReentrantLock，一次都只允许一个线程访问资源，而信号量则可以指定多个线程同时访问某一个资源

1.构造函数

public Semaphore(int permits);
public Semaphore(int permits, boolean fair);//第二个参数指定是否公平

2.基本方法

semp.acquire();//尝试获得准入许可，若无法获得则等待
semp.acquireUninterruptibly();//和acquire相同，但是不响应中断
semp.tryAcquire();//尝试获得,成功返回true，反之返回false，不阻塞
semp.tryAcquire(long timeout,TimeUnit unit);
public void release();//释放一个许可

四、读写锁ReadWriteLock

读不会修改文档，所以所有读线程之间不需要阻塞，而写线程会对文档进行修改，所以读写线程，写写线程之间需要进行阻塞。

1.demo

public class ReadWriteDemo {
    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = readWriteLock.readLock();
    private static Lock writeLock = readWriteLock.writeLock();
    private int value;
    public Object handleRead(Lock lock) throws InterruptedException {
        try {
            lock.lock();
            Thread.sleep(1000);
            return value;
        } finally {
            lock.unlock();
        }
    }
    public void handleWrite(Lock lock, int index) throws InterruptedException {
        try {
            lock.lock();
            Thread.sleep(1000);
            value = index;
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        final ReadWriteDemo demo = new ReadWriteDemo();
        Runnable readRunnale = new Runnable() {
            @Override
            public void run() {
                try {
                    demo.handleRead(readLock);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Runnable writeRunnale = new Runnable() {
            @Override
            public void run() {
                try {
                    demo.handleWrite(writeLock, new Random().nextInt());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 18; i++)
            new Thread(readRunnale).start();
        for (int i = 18; i < 20; i++)
            new Thread(writeRunnale).start();
    }
}

五、倒计数器CountDownLatch

CountDownLatch的构造函数接受一个int作为参数，既这个计数器的计数个数 

public class test implements Runnable {
    static final CountDownLatch latch = new CountDownLatch(10);
    static final test t = new test();
    @Override
    public void run() {
        try {
            Thread.sleep(new Random().nextInt(10) * 1000);
            latch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++)
            exec.submit(t);
        latch.await();
        System.out.println("Fire");
        exec.shutdown();
    }
}

六、循环栅栏CyclicBarrier

基础功能和倒计数器相似，可以实现线程间的计数等待，但是功能更加强大

public CyclicBarrier(int parties,Runnable barrierAction);
//parties：计数器个数
//barrierAction：每次计数完成后，系统会执行的动作

实例

public class test {
    public static class Worker implements Runnable {
        private final CyclicBarrier cyclicBarrier;
        private final String id;
        Worker(CyclicBarrier cyclicBarrier, String id) {
            this.cyclicBarrier = cyclicBarrier;
            this.id = id;
        }
        @Override
        public void run() {
            try {
                cyclicBarrier.await();
                command();
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
        void command() {
            try {
                Thread.sleep(new Random().nextInt(10) * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(id + " 号完成任务");
        }
    }
    public static class BarrierRun implements Runnable {
        private final int N;
        private boolean flag;

        public BarrierRun(boolean flag, int N) {
            this.N = N;
            this.flag = flag;
        }
        @Override
        public void run() {
            if (flag) {
                flag = false;
                System.out.println(N + "个工人，集合完毕");
            } else
                System.out.println(N + "个工人，任务完成");
        }
    }
    public static void main(String[] args) {
        final int N = 5;
        Thread[] workers = new Thread[N];
        CyclicBarrier cyclic = new CyclicBarrier(N, new BarrierRun(true, N));
        for (int x = 0; x < N; x++) {
            System.out.println("工人" + x + "报道");
            workers[x] = new Thread(new Worker(cyclic, Integer.toString(x)));
            workers[x].start();
        }
    }
}

七、线程阻塞工具LockSupport

LockSupport是一个线程阻塞工具，可以在线程内任意位置让线程阻塞。
和Thread.suspend()方法相比，他弥补了由于resume()方法执行位置错误引发的异常
和Object.wait()方法相比,他不需要先获得某个对象的锁,也不会抛出InterruptedException异常

1.suspend、resume引发的异常

//案例
public class test {
    public static final Object u = new Object();
    public static class Change extends Thread {
        @Override
        public void run() {
            synchronized (u) {
                System.out.println("first");
                Thread.currentThread().suspend();
            }
        }
    }
    public static void main(String[] args) {
        Change change = new Change();
        change.start();
        change.resume();
    }
}
//当我们执行这段代码时，程序会输出first，但是程序不会退出，而是会挂起，这是因为时间顺序的缘故，resume发生在了suspend的前面，导致resume方法未起效。

当我们用LockSupport改写上述程序，虽然我们仍然无法保证unpark发生在park前，但程序将可以正常运转退出。
这是因为LockSupport使用了类似信号量的机制，他为每一个线程准备了一个许可证，默认状况下许可证为false，park为消费许可证，而unpark为使许可证可用，但是与信号量不同，许可证不能累加

//改写后的程序
public class test {
    public static final Object u = new Object();
    public static class Change extends Thread {
        @Override
        public void run() {
            synchronized (u) {
                System.out.println("first");
                LockSupport.park();
            }
        }
    }
    public static void main(String[] args) {
        Change change = new Change();
        change.start();
        LockSupport.unpark(change);
    }
}

2.中断

与其他支持中断函数不同,LockSupport.park()方法不会抛出InterruptedException异常，但是可以从Thread.interrupted()获得中断标记。

八、限流算法

1.漏桶算法

基本思想
	利用一个缓存区，当有请求进入系统，无论请求速率如何，都先在缓存区中保存，然后以固定的流速流出缓存区
特点
	无论外部压力如何，漏桶算法总是以固定的流速处理数据

2.令牌桶算法

基本思想
	在令牌桶中,存放的将不是请求,而是令牌,处理程序只有拿到令牌，才能对请求进行处理，如果没有令牌，处理程序就要丢弃请求或者等待可用令牌，为了限制流速，该算法在每个单位时间内产生一定量的令牌存入桶中。