JUC详解6——读写锁

傷城~ 2022-12-18 00:45 181阅读 0赞

### JUC详解6 ###

*  ReadWriteLock（读写锁）
 *  阻塞队列：BlockingQueue
 *   *  四组api
     *  SynchronousQueue

# ReadWriteLock（读写锁） #

多读一写  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center]

/** * 读-读：可共存；读锁：共享锁：一次可以被多个线程占有 * 读-写：不可共存 * 写-写：不可共存；写锁：独占锁：一次只能被一个线程占有 */
    public class ReadWriteLockTest { 
        public static void main(String[] args) { 
            MyCache myCache = new MyCache();
            //写操作线程
            for (int i=1;i<=6;i++){ 
                final String temp=i+"";
                new Thread(()->{ 
                 myCache.put(temp,Thread.currentThread().getName());
                },String.valueOf(i)).start();
            }
            //读操作线程
            for (int i=1;i<=10;i++){ 
                final String temp=i+"";
                new Thread(()->{ 
                    myCache.get(temp);
                },String.valueOf(i)).start();
            }
        }
    }
    
    /** * 加锁 */
    class MyCacheLock{ 
        private volatile Map<String,Object> map = new HashMap<>();
        private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    
        //加锁存，写
        public void put(String key,Object value){ 
            readWriteLock.writeLock().lock();
            try { 
                System.out.println(Thread.currentThread().getName()+"写入"+key);
                map.put(key,value);
                System.out.println(Thread.currentThread().getName()+"写入结束！");
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                readWriteLock.writeLock().unlock();
            }
    
        }
        //取，读
        public Object get(String key) { 
            readWriteLock.readLock().lock();
            try { 
                System.out.println(Thread.currentThread().getName() + "读取" + key);
                Object o = map.get(key);
                System.out.println(Thread.currentThread().getName() + "读取结束！");
                return o;
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                readWriteLock.readLock().unlock();
            }
            return null;
        }
    }
    
    
    /** * 普通自定义未加锁 * 读写有些乱，在多线程环境下 */
    class MyCache{ 
        private volatile Map<String,Object> map = new HashMap<>();
    
        //存，写
        public void put(String key,Object value){ 
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入结束！");
        }
        //取，读
        public Object get(String key){ 
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取结束！");
            return o;
        }
    }

# 阻塞队列：BlockingQueue #

阻塞：

*  当队列为空时，出队列阻塞
 *  当队列满了时，入队列阻塞
 *  即只有生产者生产了，消费者才能取到；只有消费者消费完了，生产者才继续生产

队列：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 1]  
什么时候使用阻塞队列：多线程并发处理，线程池；

## 四组api ##

<table> 
 <thead> 
  <tr> 
   <th>方式</th> 
   <th>抛出异常</th> 
   <th>有返回值，不抛出异常</th> 
   <th>阻塞等待</th> 
   <th>超时等待</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>添加</td> 
   <td>add</td> 
   <td>offer()</td> 
   <td>put</td> 
   <td>offer(带参数)</td> 
  </tr> 
  <tr> 
   <td>移除</td> 
   <td>remove</td> 
   <td>poll()</td> 
   <td>take</td> 
   <td>poll(带参数)</td> 
  </tr> 
  <tr> 
   <td>判断队列首</td> 
   <td>element</td> 
   <td>peek()</td> 
   <td>-</td> 
   <td>-</td> 
  </tr> 
 </tbody> 
</table>

//抛出异常
        public static void test1(){ 
            ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
            System.out.println( blockingQueue.add("AA"));
            System.out.println( blockingQueue.add("BB"));
            System.out.println( blockingQueue.add("CC"));
            //System.out.println( blockingQueue.add("DD"));
            System.out.println("======================");
            System.out.println(blockingQueue.element());
            System.out.println(blockingQueue.remove());
            System.out.println(blockingQueue.remove());
            System.out.println(blockingQueue.remove());
            //System.out.println(blockingQueue.remove());
        }
    
        //有返回值，不抛出异常
        public static void test2(){ 
            ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
            System.out.println(blockingQueue.offer("aa"));
            System.out.println(blockingQueue.offer("bb"));
            System.out.println(blockingQueue.offer("cc"));
            System.out.println(blockingQueue.offer("dd"));
            System.out.println("============================");
            System.out.println(blockingQueue.peek());
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll());
        }
    
        //等待,阻塞，一直阻塞
        public static void test3() throws InterruptedException { 
            ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
            blockingQueue.put("AA");
            blockingQueue.put("SS");
            blockingQueue.put("sa");
            //blockingQueue.put("VV"); //队列没有位置，一直阻塞
    
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
            //队列没有元素，一直阻塞
            System.out.println(blockingQueue.take());
    
    
        }
    
        //等待，超时等待
        public static void test4() throws InterruptedException { 
            ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
            System.out.println(blockingQueue.offer("aa"));
            System.out.println(blockingQueue.offer("bb"));
            System.out.println(blockingQueue.offer("cc"));
            System.out.println(blockingQueue.offer("dd",2, TimeUnit.SECONDS));
            System.out.println("============================");
            System.out.println(blockingQueue.peek());
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll(2,TimeUnit.SECONDS));
        }

## SynchronousQueue ##

package com.fly.juc.blockingqueue;
    
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.SynchronousQueue;
    
    /** * 同步队列，不能存储值，只能存一个取一个，如果取不到，会等待存入值，在取 * put了一个元素，必须将它（take）取出，否则不能存其他值 */
    public class SynchronousQueueTest { 
        public static void main(String[] args) { 
            //SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>();
            BlockingQueue<String> blockingQueue = new SynchronousQueue<>();
            new Thread(()->{ 
                try { 
                    System.out.println(Thread.currentThread().getName()+"put 1");
                    blockingQueue.put("12");
                    System.out.println(Thread.currentThread().getName()+"put 2");
                    blockingQueue.put("22");
                    System.out.println(Thread.currentThread().getName()+"put 3");
                    blockingQueue.put("32");
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }).start();
    
            new Thread(()->{ 
                try { 
                    System.out.println(Thread.currentThread().getName()+"take 1===>");
                    System.out.println(blockingQueue.take());
                    System.out.println(Thread.currentThread().getName()+"take 2===>");
                    System.out.println(blockingQueue.take());
                    System.out.println(Thread.currentThread().getName()+"take 3===>");
                    System.out.println(blockingQueue.take());
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }).start();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 2]

原因：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 3]  
**上一篇：**[JUC详解5][JUC_5]

**下一篇：**[JUC详解7——线程池][JUC_7]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221122/136f3765a95c4db0a0e068c83abc86d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221122/f4845e3b20f8476aa718dc0d6609e13b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221122/2da0cce2b246411fa086c37c90c77308.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221122/5820d83c837a4b83af9a126ddc110da6.png
[JUC_5]: https://blog.csdn.net/qq_41510551/article/details/109256966
[JUC_7]: https://blog.csdn.net/qq_41510551/article/details/109262718