20200428 Java中Lock和synchronized的比较和应用

synchronized在语法上已经足够简单了，在JDK 5之前只能借助此实现，但是由于是独占锁，性能却不高，因此JDK 5以后就开始借助于JNI来完成更高级的锁实现。

JDK 5中的锁是接口java.util.concurrent.locks.Lock。

另外java.util.concurrent.locks.ReadWriteLock提供了一对可供读写并发的锁。

线程获取锁和释放锁的方法。

java.util.concurrent.locks.Lock类，既然是锁，肯定有用于线程获取锁和释放锁的方法存在，这两个方法为：

1、void lock();

函数功能：获取锁。如果锁不可用，由于线程调度目的，将禁用此线程，并且在获得锁之前，该线程将一直处于休眠状态。

2、unlock();

函数功能：释放锁。对应于所有的获取锁，例如lock()、tryLock()、tryLock(xx)、lockInterruptibly()等操作，如果成功的话应该对应着一个unlock()，这样可以避免死锁或者资源浪费。

 

join() 在实际使用过程中，我们可以通过join方法来等待线程执行的结果，其实有点类似future/callable的功能。

出现了数据重复问题，明显可见存在线程安全问题；

add()方法中 a++; 并不是一个原子性操作，我们使用原子类把int a变成一个原子类。我们对数值的一些非原子性操作，都可以使用原子类转化为原子性操作。

 

1、使用Lock同步来模拟AtomicInteger类

public class AtomicIntegerLock {

    private volatile int value;

    //获取一个锁实例
    private Lock lock = new ReentrantLock();

    public AtomicIntegerLock(int value) {
        this.value = value;
    }

    //同一时刻只能有一个线程修改值
    public void set(int newValue) {
        lock.lock();
        try {
            this.value = newValue;
        } finally {
            lock.unlock();
        }
    }

    //获取值
    public final int get() {
        lock.lock();
        try {
            return value;
        } finally {
            lock.unlock();
        }
    }

    public final int getAndSet(int newValue) {
        lock.lock();
        try {
            int oldValue = value;
            value = newValue;
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 返回旧值并增加
     *
     * @param delta
     * @return
     */
    public final int getAndAdd(int delta) {
        lock.lock();
        try {
            int oldValue = value;
            value += delta;
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 先增加再返回新值
     *
     * @param delta
     * @return
     */
    public final int addAndGet(int delta) {
        lock.lock();
        try {
            value += delta;
            return value;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 比较是否可预期值相同
     *
     * @param expect
     * @param newValue
     * @return
     */
    public final boolean getAndCompare(int expect, int newValue) {
        lock.lock();
        try {
            if (this.value == expect) {
                value = newValue;
                return true;
            } else {
                return false;
            }
        } finally {
            lock.unlock();
        }
    }

    /**
     * 先获取value的值，在递增1；
     * @return
     */
    public final int getAndIncrement(){
        lock.lock();
        try {
            return value++;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 先获取value的值，然后减1
     * @return
     */
    public final int getAndDecrement(){
        lock.lock();
        try {
            return value--;
        } finally {
            lock.unlock();
        }
    }


    /**
     * 先自增1，在返回新值
     * @return
     */
    public final int incrementAndGet(){
        lock.lock();
        try {
            return ++value;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 先递减1，在返回值
     * @return
     */
    public final int decrementAndGet(){
        lock.lock();
        try {
            return --value;
        } finally {
            lock.unlock();
        }
    }

    public final String toString(){
        lock.lock();
        return  Integer.toString(get());
    }
}

2、Lock同步和synchronized同步两种锁的性能:使用lock的性能要好。与其说ReentrantLock性能好，还不如说synchronized还有很大优化的余地。

3、用Lock来进行同步计数和使用AtomicInteger类计数的性能比较；使用CAS指令确实更要快的多。

/**
 * Created on 2020/4/28 16:30
 * author:crs
 * Description:测试两种同步性能的差别
 */
public class TestAtomicIntegerLock {

    private static int synValue = 0;

    public static void main(String[] args) {
        int threadNum = 10;
        int maxValue = 1000000;

        Thread[] t = new Thread[threadNum];
        //返回的是纳秒 //System.nanoTime();
        Long begin = System.currentTimeMillis();
        for (int i = 0; i <threadNum ; i++) {
            AtomicIntegerLock aIL = new AtomicIntegerLock(0);
            //创建了十个线程，每个线程的任务确定
            t[i]=new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int j=0;j<maxValue;j++){
                        aIL.getAndIncrement();
                    }
                }
            });
        }
        for(int i=0;i<threadNum;i++){
            t[i].start();
        }

        //main线程等待前面开启的所有线程结束
        for(int i=0;i<threadNum;i++){
            try {
                t[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("使用lock所花费的时间为："+(System.currentTimeMillis()-begin));

        int[] lock = new int[0];
        begin = System.currentTimeMillis();
        for(int i=0;i<threadNum;i++){
            synValue = 0;
            t[i]=new Thread(new Runnable(){

                @Override
                public void run() {
                    for(int j=0;j<maxValue;j++){
                        synchronized(lock){
                            ++synValue;
                        }
                    }
                }
            });
        }
        for(int i=0;i<threadNum;i++){
            t[i].start();
        }
        //main线程等待前面开启的所有线程结束
        for(int i=0;i<threadNum;i++){
            try {
                t[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(synValue);
        System.out.println("使用synchronized所花费的时间为："+(System.currentTimeMillis()-begin));
        
        
        begin = System.currentTimeMillis();
        for(int i=0;i<threadNum;i++){
            AtomicInteger ai = new AtomicInteger(0);
            t[i]=new Thread(new Runnable(){

                @Override
                public void run() {
                    for(int j=0;j<maxValue;j++){
                        ai.incrementAndGet();
                    }
                }

            });
        }
        for(int i=0;i<threadNum;i++){
            t[i].start();
        }
        //main线程等待前面开启的所有线程结束
        for(int i=0;i<threadNum;i++){
            try {
                t[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("使用原子操作类AtomicInteger所花费的时间为："+(System.currentTimeMillis()-begin));
    }
}