线程锁Lock
Lock 相当于 当前对象的 Synchronized
- import java.util.concurrent.locks.Lock;
- import java.util.concurrent.locks.ReentrantLock;
- /*
- * Lock lock = new ReentrantLock();
- * lock.lock(); lock.unLock();
- * 类似于 synchronized，但不能与synchronized 混用
- */
- public class LockTest {
- public static void main(String[] args) {
- final Outer outer = new LockTest().new Outer();
- new Thread(new Runnable() {
-
- @Override
- public void run() {
- // TODO Auto-generated method stub
- while (true) {
- outer.out1("zhangxiaoxiao");
- outer.out2("lihuoming");
- }
- }
-
- }).start();
- new Thread(new Runnable() {
-
- @Override
- public void run() {
- // TODO Auto-generated method stub
- while (true) {
- outer.out1("zhangxiaoxiao");
- outer.out2("lihuoming");
- }
- }
-
- }).start();
-
- }
- class Outer {
- Lock lock = new ReentrantLock();
- void out1(String name) {
- lock.lock();
- int len = name.length();
- for (int i = 0; i < len; i++) {
- System.out.print(name.charAt(i));
- }
- System.out.println();
- lock.unlock();
- }
- void out2(String name) {
- lock.lock();
- int len = name.length();
- for (int i = 0; i < len; i++) {
- System.out.print(name.charAt(i));
- }
- System.out.println();
- lock.unlock();
- }
- }
- }
读写锁 ReentrantReadWriteLock
读写锁：允许多条线程同时读；不能读中有写；不能写中有读；不能写中有写
- import java.util.HashMap;
- import java.util.Map;
- import java.util.concurrent.locks.ReadWriteLock;
- import java.util.concurrent.locks.ReentrantReadWriteLock;
- /*
- * 问题：设计一个 缓存机制 的 伪代码
- * 从集合中读取数据，读取不到，就写入，再考虑多线程并发的情况
- */
- public class ReadWriteLockTest2 {
- private Map<String, Object> data = new HashMap<String, Object>();
- private ReadWriteLock lock = new ReentrantReadWriteLock();
- //读写锁
- public Object getInstance1(String key, Object obj) {
- lock.readLock().lock();
- Object value = null;
- try {
- value = data.get(key);
- if (value == null) {//一条线程进入这里，
- lock.readLock().unlock();//读锁解了，其他线程就可能也到这了
- lock.writeLock().lock();//只能有一条线程到这，写锁开启，要写入数据了
- if (data.get(key) == null) {
- value = obj;
- /*先判断数据，如果不存在，才写入，，因为 界时当写锁解除后，其他
- 线程，再想写入时， 判断到数据存在 ，就跳过了。就不会发生同时写入的情况
- */
- data.put(key, value);
- }
- lock.writeLock().unlock();//写完了，解锁
- lock.readLock().lock();
- }
- } finally {
- lock.readLock().unlock();
- }
- return value;
- }
| 
