java并发包学习笔记1-各种各样的锁

java.util.concurrent 是java5开始引入的高级的处理高并发多线程的包。

ReentrantLock

ReentrantLock是可重入锁，一个线程可以多次获取同一个锁。synchronized在获取锁的时候必须一直等待，ReentrantLock更加灵活。

public Counter {
   private int count;
   public void add(int num) {
      synchronized(this) {
         count+=num;
      }
   }
   ...
}

使用ReentrantLock改为：

public Counter {
   private final Lock lock = new ReentrantLock();
   private int count;
   public void add(int num) {
      lock.lock();
      try {
         count+=num;
      } finally {
         lock.unlock();
      }
   }
   ...
}

还可以更灵活使用lock.tryLock(1, TimeUnit.SECONDS)来尝试获取锁，表示等待1秒；1秒后还获取不到锁则tryLock()方法回返回false这样程序可以在获取不到锁的时候做额外处理，防止死锁。

Condition
synchronized配合wait()和notify()来实现线程协调，而ReentrantLock则配合Condition对象来实现线程协调。

class TaskQueue {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private Queue<String> queue = new LinkedList<>();

    public void addTask(String s) {
        try {
           lock.lock();
           this.queue.add(s);
           condition.signal();//唤醒等待线程          
        } finally {
           lock.unlock();
        }

    }

    public String getTask() {
        try {
           lock.lock()
           while (queue.isEmpty()) {
              condition.await();//释放锁，进入等待状态
           }
           return queue.remove();
        } finally {
           lock.unlock();
        }

    }
}

Condition对象通过ReentrantLock对象的newCondition()方法获取。

Condition的await()、signal()、signalAll()和synchronized锁对象的wait()、notify()、notifyAll()是一致的。

类似lock.tryLock(1, TimeUnit.SECONDS)，condition.await(1, TimeUnit.SECOND)也可以等待1秒；如果1秒内没有被唤醒，则线程自己醒过来。

ReadWriteLock
ReentrantLock只允许一个线程进入临界区，但是有些场景我们希望可以多个线程进入临界区，如文件的读写，写锁只有一个线程可以获取，读锁可以多个线程获取。此时可以使用ReadWriteLock来实现这个功能。

public class Counter {
    private final ReadWriteLock rwlock = new ReentrantReadWriteLock();
    private final Lock rlock = rwlock.readLock();
    private final Lock wlock = rwlock.writeLock();
    private int[] counts = new int[10];

    public void inc(int index) {
        wlock.lock(); // 加写锁
        try {
            counts[index] += 1;
        } finally {
            wlock.unlock(); // 释放写锁
        }
    }

    public int[] get() {
        rlock.lock(); // 加读锁
        try {
            return Arrays.copyOf(counts, counts.length);
        } finally {
            rlock.unlock(); // 释放读锁
        }
    }
}

StampedLock
对于ReenTrantLock和ReadWriteLock都是属于悲观锁，写锁需要等所有读锁释放才能获取，即有线程在读的时候不能写，主要是为了防止读写不一致。

考虑如下场景：如果有k个线程在读，突然插入第k+1个线程在写，后面k+2到k+i个线程在读。那么此时，k+2到k+i个线程会被写线程堵塞，需要等待写线程释放写锁。

StampedLock提供了乐观锁，提升了并发的效率。实际上乐观锁不加锁，只是校验版本号，其解决读写不一致的思路很简单：如果读写不一致就再读一次好了，没必要加上锁。

package com.oy.example.multithread.sychronization.lockcase.optimrwlock;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.StampedLock;

/**
 * StampedLock可以提供乐观锁和悲观锁
 * 乐观锁的意思就是乐观地估计读的过程中大概率不会有写入，因此被称为乐观锁。
 * 反过来，悲观锁则是读的过程中拒绝有写入，也就是写入必须等待。
 * 显然乐观锁的并发效率更高，但一旦有小概率的写入导致读取的数据不一致，需要能检测出来，再读一遍就行。
 * @author Administrator
 *
 */
public class StampedLockTest {

	public static void main(String[] args) throws InterruptedException {
		Point point = new Point();
		
		/**
		 * 测试多线程读写
		 */
		List<WriteThread> list = new ArrayList<>();
		for (int i = 0; i < 5; i++) {
			WriteThread thread = new WriteThread(point);
			thread.start();
			list.add(thread);			
		}
		
		new ReadThread(point).start();
		
		Thread.sleep(1);
		
		new ReadThread(point).start();
		
		for(WriteThread t:list) {
			t.join();
		}
		
		Map<String, Integer> map = point.optimisticGet();
		System.out.println("x = " + map.get("x") + ", y = " + map.get("y"));
		
	}

}

class WriteThread extends Thread {
	private Point point;
	
	public WriteThread(Point point) {
		this.point = point;
	}
	
	@Override
	public void run() {
		try {
			for (int i = 0; i < 10; i++) {
				point.move(1, 1);
				Thread.sleep(1);
			}
		} catch (InterruptedException e) {
			return;
		}
	}
}

class ReadThread extends Thread {
	private Point point;
	
	public ReadThread(Point point) {
		this.point = point;
	}
	
	@Override
	public void run() {
		Map<String, Integer> map = point.optimisticGet();
		System.out.println("x = " + map.get("x") + ", y = " + map.get("y"));
	}
}

class Point {
	private final StampedLock stampedLock = new StampedLock();
	
	private int x = 0;
	private int y = 0;
	
	public void move(int deltaX, int deltaY) {
		long stamp = stampedLock.writeLock();//获取写锁
		try {			
			x += deltaX;
			y += deltaY;
		} finally {
			stampedLock.unlockWrite(stamp);//释放写锁
		}
	}
	
	/**
	 * 乐观读
	 * @return
	 */
	public Map<String, Integer> optimisticGet() {
		long stamp = stampedLock.tryOptimisticRead();//获取读锁乐观锁
		Map<String, Integer> point = new HashMap<>();
		//获取坐标的操作不是原子操作
		point.put("x", x);
		point.put("y", y);
		if(!stampedLock.validate(stamp)) {
			try {
				stamp = stampedLock.readLock();//验证不通过，说明获取两个坐标期间值被修改过，获取读锁悲观锁
				point.put("x", x);
				point.put("y", y);					
			} finally {
				stampedLock.unlockRead(stamp);//释放读锁
			}
		}
		return point;
	}
	
	/**
	 * 悲观读
	 * @return
	 */
	public Map<String, Integer> pessimisticGet() {
		long stamp = stampedLock.readLock();//获取读锁乐观锁
		try {
			Map<String, Integer> point = new HashMap<>();
			point.put("x", x);
			point.put("y", y);	
			return point;
		} finally {
			stampedLock.unlockRead(stamp);//释放读锁
		}		
	}
}