java锁

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Created by ibm on 2017/5/24.
 * java中锁的机制三种：
 * 1.synchronized的关键字
 * <1.实现简单，<2.性能不是最佳，是串行而非并行
 * 2.重入锁ReentrantLock
 * <1.提供更强大的解锁功能，设置等待时间，优先相应终端，<2.性能不是最佳，是串行而非并行
 * 3.读写锁
 * <1.读写分离，<2.读绝对并行(经过测试，在查询过多或者缓慢的情况下，writeLock的效率是其他两者的10倍左右)
 */
public class LockExercise {

    private int value;

    private static Lock reentrantLock = new ReentrantLock();
    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = readWriteLock.readLock();
    private static Lock writeLock = readWriteLock.writeLock();

    @Test
    public void test(){
        long st = System.currentTimeMillis();
        List<CompletableFuture> cfs = new ArrayList<>();
        LockExercise lockExercise = new LockExercise();
        for(int i = 0 ; i < 20 ;i++){
            int j = i;
            cfs.add(CompletableFuture.runAsync(() -> {
                try {
                    lockExercise.handleRead4ReadWriteLock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }));
        }
        //等待所有线程执行完
        CompletableFuture.allOf(cfs.toArray(new CompletableFuture[cfs.size()])).join();
        System.out.println("value = " + lockExercise.value + " 耗时：" + (System.currentTimeMillis() - st) + " ms");
    }


    //value = 0 耗时：20731ms
    private synchronized Object handleRead() throws InterruptedException {
        Thread.sleep(1000);
        return value;
    }
    //value = 19 耗时：20644 ms
    private synchronized void  handleWrite(int value) throws InterruptedException {
        Thread.sleep(1000);
        this.value++;
    }

    //value = 0 耗时：20647 ms
    private Object handleRead4ReentrantLock() throws InterruptedException {

        try{
            //模拟读操作,读操作的耗时越多，读写锁的优势就越明显（因为，重入锁总是要排队等待锁，而读写锁可以绝对并行）
            reentrantLock.lock();
            Thread.sleep(1000);
            return value;
        }finally {
            //重入锁必须在finally中显示的释放锁
            reentrantLock.unlock();
        }
    }
    //value = 19 耗时：20667 ms
    private void handleWrite4ReentrantLock(int value) throws InterruptedException {

        try {
            reentrantLock.lock();
            Thread.sleep(1000);
            this.value++;
        }finally {
            reentrantLock.unlock();
        }
    }

    //value = 0 耗时：20667 ms
    private Object handleRead4ReadWriteLock() throws InterruptedException {

        try{
            readLock.lock();
            Thread.sleep(1000);
            return value;
        }finally {
            readLock.unlock();
        }
    }
    //value = 0 耗时：3609 ms
    private void handleWrite4ReadWriteLock(int value) throws InterruptedException {

        try {
            writeLock.lock();
            Thread.sleep(1000);
            this.value++;
        }finally {
            writeLock.unlock();
        }
    }
}