java通过缓存实现同步锁

 

  //极验注册分值>=90,跳到错误页面，提示语：该手机号暂时无法在线注册，请联系客服。

        String mobile = request.getMobile();
        // 加锁的KEY
        String lockKey = LvtuClientMemCacheConstants.USUAL_CACHEKEY_CONSTANTS.MYLVMM_LVTU_LOGIN_REGISTER_LOCK.getCacheKey() + mobile;
        try {
            // 时候锁定成功，true-锁定成功；false-锁定失败
            boolean isLock = LvtuMemcachedUtil.getInstance().tryLock(lockKey, LOCK_SECCONDS, TRYLOCK_TIMEOUT_SECONDS);
            // 加锁失败，则直接报错
            if(!isLock) {
                UserRegisterSSOResponse response = new UserRegisterSSOResponse();
                response.setMessage("正在处理..");
                response.setErrorMessage("表单重复提交，手机号：" + mobile);
                logger.error("表单重复提交，手机号：" + mobile);
                return response;
            }

            long rainScore = getRainScores(mobile);

。。。。。。。。。。。。。。。。

public boolean tryLock(String lockKey) {
        return tryLock(lockKey, DBConfig.DEFAULT_LOCK_SECCONDS, DBConfig.DEFAULT_TRYLOCK_TIMEOUT_SECONDS);
    }

    public boolean tryLock(String lockKey, int lockSec, int timeOutSec) {
        MemCachedClient client = getMemCachedClient(false);

        long start = System.currentTimeMillis();
        while (true) {
            boolean locked = client.add(lockKey, "", getDateAfter(lockSec));
            if (locked) {
                return true;
            } else {
                long now = System.currentTimeMillis();
                long costed = now - start;
                if (costed >= timeOutSec * 1000) {
                    return false;
                }
            }
        }
    }

/**
     * 该锁是否已被持有 false:未被持有，true：已被持有
     *
     * @param lockKey
     * @param lockSec
     * @return
     */
    public boolean isHoldLock(String lockKey, int lockSec) {
        boolean isHoldLock = false;
        MemCachedClient client = getMemCachedClient(false);
        boolean locked = client.add(lockKey, "holded", getDateAfter(lockSec));
        if (!locked) {
            isHoldLock = true;
        }
        return isHoldLock;
    }

    public boolean releaseLock(String lockKey) {
        MemCachedClient client = getMemCachedClient(false);
        return client.delete(lockKey);
    }
}

package test;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 设计一个缓存系统
 * 读写锁的应用。
 * JDK1.5自带的读写锁特性，读与读不互斥，读与写互斥，写与写互斥。
 * 为什么要使用读写锁？一句话概括那就是提高系统性能，如何提高呢？
 * 试想，对于所有对读的操作是不需要线程互斥的，而如果方法内
 * 使用了synchronized关键字同步以达到线程安全，对于所有的线程不管是读还是写的操作都要同步。
 * 这时如果有大量的读操作时就会又性能瓶颈。
 *
 * 所以，当一个方法内有多个线程访问，并且方法内有读和写读操作时，
 * 提升性能最好的线程安全办法时采用读写锁的机制对读写互斥、写写互斥。这样对于读读就没有性能问题了
 * @author zhurudong
 *
 */
public class CacheTest {

    // 缓存的map
    private Map map = new HashMap();
    // 读写锁对象
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    /**
     * 从缓存中获取数据的方法
     * @param key
     * @return
     */
    public Object getData(String key) {
        readWriteLock.readLock().lock();//读锁，只对写的线程互斥
        Object value = null;
        try {
            // 尝试从缓存中获取数据
            value = map.get(key);
            if (value == null) {
                readWriteLock.readLock().unlock();//发现目标值为null,释放掉读锁
                readWriteLock.writeLock().lock();//发现目标值为null,需要取值操作,上写锁
                try {
                    value = map.get(key);// 很严谨这一步。再次取目标值
                    if (value == null) {//很严谨这一步。再次判断目标值,防止写锁释放后，后面获得写锁的线程再次进行取值操作
                        // 模拟DB操作
                        value = new Random().nextInt(10000) + "test";
                        map.put(key, value);

                        System.out.println("db completed!");
                    }
                    readWriteLock.readLock().lock();//再次对读进行锁住，以防止写的操作，造成数据错乱
                } finally {
                    /*
                     * 先加读锁再释放写锁读作用：
                     * 防止在43行出多个线程获得写锁进行写的操作，所以在写锁还没有释放前要上读锁
                     */
                    readWriteLock.writeLock().unlock();
                }
            }

        } finally {
            readWriteLock.readLock().unlock();
        }
        return value;
    }

    /**
     *  test main
     * @param args
     */
    public static void main(String[] args) {
        final CacheTest cache = new CacheTest();
        final String key = "user";
        for (int i = 0; i < 1000; i++) {
            new Thread(){
                public void run() {
                    System.out.println(cache.getData(key));
                };
            }.start();
        }
    }
}

Java中的读写锁：

多个读锁不互斥， 读锁与写锁互斥， 写锁与写锁互斥， 这是由JVM自行控制的，我们只要上好相应的锁即可。

package com.cn.gbx;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class CacheDesign {
    private Map cache = new HashMap();
    //对象锁的设计
//  public synchronized Object getData(String key){
//      Object value = null;
//      value = cache.get(key);
//      if (value == null) {
//          value = "queryDao";
//          cache.put(key, value);
//      }
//      return value;
//  }
    //可重入锁的设计
    static ReadWriteLock rwl = new ReentrantReadWriteLock();
    public synchronized Object getData(String key){
        Object value = null ;
        rwl.readLock().lock();
        try {
            value = cache.get(key);
            if (value == null ) {
                rwl.readLock().unlock();
                rwl.writeLock().lock();
                try {
                    if (value == null ) {  //确保后边的线程不会重读写
                        value = "queryDao" ;
                        cache.put(key, value);
                    }
                } finally {
                    rwl.writeLock().unlock();
                }
                rwl.readLock().lock();
            }
        } finally {
            rwl.readLock().unlock();
        }
        return value;
    }

    public static void main(String[] args) {

    }
}