【并发技术12】线程锁技术的使用

举报
Tom forever 发表于 2019/10/26 10:13:17 2019/10/26
【摘要】 线程锁好比传统线程模型中的 synchronized 技术,但是比 synchronized 方式更加面向对象,与生活中的锁类似,锁本身也应该是个对象。两个线程执行的代码片段如果要实现同步互斥的效果,它们必须用用一个锁对象。锁是上在代表要做操的资源的类的内部方法中,而不是线程代码中。这篇文章主要总结一下线程锁技术中 Lock锁、ReadWriteLock 锁的使用。1. Lock的简单使用有...

线程锁好比传统线程模型中的 synchronized 技术,但是比 synchronized 方式更加面向对象,与生活中的锁类似,锁本身也应该是个对象。两个线程执行的代码片段如果要实现同步互斥的效果,它们必须用用一个锁对象。锁是上在代表要做操的资源的类的内部方法中,而不是线程代码中。这篇文章主要总结一下线程锁技术中 Lock锁、ReadWriteLock 锁的使用。

1. Lock的简单使用

有了synchronized 的基础,Lock 就比较简单了,首先看一个实例: 


public class LockTest {

   public static void main(String[] args{

       new LockTest().init();
   }

   private void init({
       final Outputer outputer = new Outputer();
       // 线程1打印:duoxiancheng
       new Thread(new Runnable() {
           @Override
           public void run(
{
               while (true) {
                   try {
                       Thread.sleep(5);
                   } catch (InterruptedException e) {
                       // TODO Auto-generated catch block
                       e.printStackTrace();
                   }
                   outputer.output("duoxiancheng");
               }

           }
       }).start();
       ;

       // 线程2打印:eson15
       new Thread(new Runnable() {
           @Override
           public void run(
{
               while (true) {
                   try {
                       Thread.sleep(5);
                   } catch (InterruptedException e) {
                       // TODO Auto-generated catch block
                       e.printStackTrace();
                   }
                   outputer.output("eson15");
               }

           }
       }).start();
       ;
   }

   // 自定义一个类,保存锁和待执行的任务
   static class Outputer {
       Lock lock = new ReentrantLock(); //定义一个锁,Lock是个接口,需实例化一个具体的Lock
       //字符串打印方法,一个个字符的打印
       public void output(String name{

           int len = name.length();
           lock.lock();
           try {
               for (int i = 0; i < len; i++) {
                   System.out.print(name.charAt(i));
               }
               System.out.println("");
           } finally {
               lock.unlock(); //try起来的原因是万一一个线程进去了然后挂了或者抛异常了,那么这个锁根本没有释放
           }
       }
}



这个例子和前面介绍 synchronized 的例子差不多,区别在于将 synchronized 改成了 lock。从程序中可以看出,使用 Lock 的时候,需要先 new 一个 Lock 对象,然后在线程任务中需要同步的地方上锁,但是一定要记得放锁,所以使用 try 块去处理了一下,将放锁的动作放在 finally 块中了。

这是一个线程任务的情况,如果两个线程任务也不麻烦,还是在这个类中新建一个任务方法,因为 Lock 是这个类的成员变量,还是可以用这个 lock,而且必须用这个 lock,因为要实现同步互斥,必须使用同一把锁。

2. 读写锁的妙用

锁又分为读锁和写锁,读锁与读锁不互斥,读锁与写锁互斥,写锁与写锁互斥,这是由 jvm 自己控制的。这很好理解,读嘛,大家都能读,不会对数据造成修改,只要涉及到写,那就可能出问题。我们写代码的时候只要在挣钱的位置上相应的锁即可。读写锁有个接口叫 ReadWriteLock,我们可以创建具体的读写锁实例,通过读写锁也可以拿到读锁和写锁。下面看一下读写锁的例子。

2.1 读写锁的基本用法


public class ReadWriteLockTest {

   public static void main(String[] args{
       final Queue3 q3 = new Queue3(); //封装共享的数据、读写锁和待执行的任务的类

       for (int i = 0; i < 3; i++) {
           new Thread() { // 开启三个线程写数据
               public void run({
                   while (true) {
                       q3.put(new Random().nextInt(10000));
                   }
               }
           }.start();

           new Thread() { // 开启三个线程读数据
               public void run({
                   while (true) {
                       q3.get();
                   }
               }
           }.start();
       }
   }
}

class Queue3 {

   private Object data = null// 共享的数据
   private ReadWriteLock rwl = new ReentrantReadWriteLock();// 定义读写锁

   // 读取数据的任务方法
   public void get({
       rwl.readLock().lock(); // 上读锁
       try {
           System.out.println(Thread.currentThread().getName() 
                   + ":before read: " + data); // 读之前打印数据显示

           Thread.sleep((long) (Math.random() * 1000)); // 睡一会儿~

           System.out.println(Thread.currentThread().getName() 
                   + ":after read: " + data); // 读之后打印数据显示
       } catch (InterruptedException e) {
           e.printStackTrace();
       } finally {
           rwl.readLock().unlock();// 释放读锁
       }
   }

   // 写数据的任务方法
   public void put(Object data{
       rwl.writeLock().lock(); // 上写锁
       try {
           System.out.println(Thread.currentThread().getName() 
                   + ":before write: " + this.data); // 读之前打印数据显示

           Thread.sleep((long) (Math.random() * 1000)); // 睡一会儿~
           this.data = data; //写数据

           System.out.println(Thread.currentThread().getName() 
                   + ":after write: " + this.data); // 读之后打印数据显示
       } catch (InterruptedException e) {
           e.printStackTrace();
       } finally {
           rwl.writeLock().unlock();// 释放写锁        
       }
   }
}



为了说明读锁和写锁的特点(读锁和读锁不互斥,读锁与写锁互斥,写锁与写锁互斥),我先把上面两个任务方法中上锁和放锁的四行代码注释掉,来看一下运行结果。


640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1



其实不管是注释调读锁还是注释调写锁,还是全注释掉,都会出问题,写的时候会有线程去读。那么将读写锁加上后,再看一下运行结果。


640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1



可以看出,有了读写锁,各个线程运行有序,从结果来看,也印证了读锁和读锁不互斥,写锁与读锁、写锁都互斥的特点。

2.2 读写锁用于缓存数据

现在使用读写锁写一个模拟缓存数据的 demo,实现功能如下:现在有5个线程都需要拿数据,一开始是没有数据的,所以最先去拿数据的那个线程发现没数据,它就得去初始化一个数据,然后其他线程拿数据的时候就可以直接拿了。代码如下。


public class ReadWriteLockTest2 {

   public static void main(String[] args{

       CacheData cache = new CacheData();

       for(int i = 1; i <= 5; i ++) { //开启5个线程
           new Thread(new Runnable() {

               @Override
               public void run(
{
                   cache.processCache(); //都去拿数据
               }
           }).start();
       }
   }
}

class CacheData {

   private Object data = null// 需要缓存的数据
   private boolean cacheValid; //用来标记是否有缓存数据
   private ReadWriteLock rwl = new ReentrantReadWriteLock();// 定义读写锁

   public void processCache({
       rwl.readLock().lock(); //上读锁

       if(!cacheValid) { //如果没有缓存,那说明是第一次访问,需要给data赋个值
           rwl.readLock().unlock(); //先把读锁释放掉
           rwl.writeLock().lock(); //上写锁
           if(!cacheValid) {
               System.out.println(Thread.currentThread().getName() + ": no cache!");
               data = new Random().nextInt(1000); //赋值
               cacheValid = true//标记已经有缓存了
               System.out.println(Thread.currentThread().getName() + ": already cached!");
           }
           rwl.readLock().lock(); //再把读锁上上
           rwl.writeLock().unlock(); //把刚刚上的写锁释放掉
       }
       System.out.println(Thread.currentThread().getName() + " get data: " + data);
       rwl.readLock().unlock(); //释放读锁
   }
}



从代码中可以看出,在 processCache 方法中对读锁和写锁的交替使用。一开始进来都是读数据的,所以一开始都是上了读锁,但是当第一个线程进来发现没有缓存数据的时候,它得写数据,那么此时它得先把读锁给释放掉,换了把写锁,告诉其他线程:“哥们,这里面根本没数据啊,我们被坑了,让我先弄个数据来吧,你们等会儿~”,等该线程初始化好了数据后,其他线程就可以读了,于是它又把读锁装起来了,把写锁释放了,然后它出去了。这就模拟了拿缓存数据的一个 demo,可以看出,在一个方法中,同一个线程可以操作两个锁的。看一下运行结果。

Thread-1: no cache!
Thread-1: already cached!
Thread-1 get data: 893
Thread-0 get data: 893
Thread-2 get data: 893

这和 Hibernate 中的那个 load(id, Class.class) 方法有点类似,先拿到的是代理对象,要使用该对象的时候,如果发现没有,就新产生一个,如果有了就直接拿来用。

2.3 读写锁用于缓存系统

继续进阶,如果现在要缓存多个数据,即要写一个缓存系统,那该如何做呢?一个缓存系统无非就是一个容器,可以存储很多缓存数据,很自然的想到使用一个 Map,专门装缓存数据,然后供多个线程去使用。所以整个涉及思路,跟上面缓存单个数据是一样的,不过就是多考了一些东西而已,看下代码。


public class CacheDemo {

   public static void main(String[] args{

       Cache cac = new Cache();
       for(int i = 0; i < 3; i ++) { //开启三个线程去缓存中拿key为cache1的数据,
           new Thread(new Runnable() {

               @Override
               public void run(
{
                   String value = (String) cac.getData("cache1"); //第一个进入的线程要先写一个数据进去(相当于第一次从数据库中取)    
                   System.out.println(Thread.currentThread().getName() + ": " + value);    
               }
           }).start();
       }

       for(int i = 0; i < 3; i ++) { //开启三个线程去缓存中拿key为cacahe2的数据
           new Thread(new Runnable() {

               @Override
               public void run(
{
                   String value = (String) cac.getData("cache2");//第一个进入的线程要先写一个数据进去(相当于第一次从数据库中取)
                   System.out.println(Thread.currentThread().getName() + ": " + value);
               }
           }).start();
       }
   }
}

class Cache {
   //存储缓存数据的Map,注意HashMap是非线程安全的,也要进行同步操作
   private Map<String, Object> cache = Collections.synchronizedMap(new HashMap<String, Object>()); 
   private ReadWriteLock rwl = new ReentrantReadWriteLock(); //定义读写锁

   public synchronized Object getData(String key{
       rwl.readLock().lock(); //上读锁
       Object value = null
       try {
           value = cache.get(key); //根据key从缓存中拿数据
           if (value == null) { //如果第一次那该key对应的数据,拿不到
               rwl.readLock().unlock(); //释放读锁
               rwl.writeLock().lock(); //换成写锁
               try {
                   if (value == null) { //之所以再去判断,是为了防止几个线程同时进入了上面那个if,然后一个个都来重写赋值一遍
                       System.out.println(Thread.currentThread().getName() + " write cache for " + key);
                       value = "aaa" + System.currentTimeMillis(); // 实际中是去数据库中取,这里只是模拟
                       cache.put(key, value); //放到缓存中
                       System.out.println(Thread.currentThread().getName() + " has already written cache!");
                   }
               } finally {
                   rwl.writeLock().unlock(); //写完了释放写锁
               }
               rwl.readLock().lock(); //换读锁
           }
       } finally {
           rwl.readLock().unlock(); //最后呢释放读锁
       }
       return value//返回要取的数据
   }
}



整个代码的结构和上面的一样,理解了缓存单个数据后,这个代码也不难理解。这里只是个 demo,实际中可以是跟数据库打交道,第一次从缓存中拿肯定是没有的,那么就要去数据库中查,然后把取到的数据放到缓存中,下次别的线程来就能直接从缓存中取了。看一下运行结果。

Thread-0 write cache for cache1
Thread-0 has already written cache!
Thread-4 write cache for cache2
Thread-0: aaa1464782404722
Thread-4 has already written cache!
Thread-4: aaa1464782404723
Thread-3: aaa1464782404723
Thread-2: aaa1464782404722
Thread-1: aaa1464782404722
Thread-5: aaa1464782404723

从结果中可以看出,线程 0 首先去缓存中拿 key 为 cache1 的值,没拿到,往里面写了一个,然后线程 4 去缓存中拿 key 为 cache2 的值也没拿到,于是也写了一个,在此期间线程 0 把值拿了出来,后面几个线程也随后陆续的拿出来了。读写锁的应用还是很广泛的,而且很好用,就总结这么多吧。


转载声明:本文转载自公众号【程序员私房菜】。    

原文链接:https://mp.weixin.qq.com/s/GCggs8SERxf59-aQ8rRu3w

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。