Java并发编程:同步锁、读写锁

之前我们说过线程安全问题可以用锁机制来解决,即线程必要要先获得锁,之后才能进行其他操作。其实在 Java 的 API 中有这样一些锁类可以提供给我们使用,与其他对象作为锁相比,它们具有更强大的功能。

Java 中的锁有两种,分别是:1)同步锁 2)读写锁

一、同步锁

  同步锁(ReentrantLock)类似于 synchronize 代码块中传入的那个锁对象,可以用于进行线程同步。ReentrantLock.lock() 方法用于锁定对象,而 ReentrantLock.unlock 用于释放锁对象。

public class SynLockDemo {

    static final ReentrantLock lock = new ReentrantLock();   //同步锁

    public static void main(String args[]) {
        //线程1
        new Thread(){
            public void run() {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + " have the lock.");
                try {
                    System.out.println(Thread.currentThread().getName() + " sleep 3 Seconds.");
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.unlock();
                System.out.println(Thread.currentThread().getName() + " release the lock.");
            }
        }.start();
        //线程2
        new Thread(){
            public void run() {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + " have the lock.");
                lock.unlock();
                System.out.println(Thread.currentThread().getName() + " release the lock.");
            }
        }.start();
    }
}

  可以看到线程 1 即使休眠了 3 秒,线程 2 也还是会等到线程 1 执行完才会继续执行。

  ReentrantLock 除了可以实现基本的线程同步阻塞之外,还可以配合 Condition 类使用,实现线程通信。我们可以用 Condition 来实现生产者 - 消费者问题:

public class Test {
    private int queueSize = 10;
    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();
      
    public static void main(String[] args)  {
        Test test = new Test();
        Producer producer = test.new Producer();
        Consumer consumer = test.new Consumer();
           
        producer.start();
        consumer.start();
    }
       
    class Consumer extends Thread{
           
        @Override
        public void run() {
            consume();
        }
           
        private void consume() {
            while(true){
                lock.lock();
                try {
                    while(queue.size() == 0){
                        try {
                            System.out.println("队列空,等待数据");
                            notEmpty.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    queue.poll();                //每次移走队首元素
                    notFull.signal();
                    System.out.println("从队列取走一个元素,队列剩余"+queue.size()+"个元素");
                } finally{
                    lock.unlock();
                }
            }
        }
    }
       
    class Producer extends Thread{
           
        @Override
        public void run() {
            produce();
        }
           
        private void produce() {
            while(true){
                lock.lock();
                try {
                    while(queue.size() == queueSize){
                        try {
                            System.out.println("队列满,等待有空余空间");
                            notFull.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    queue.offer(1);        //每次插入一个元素
                    notEmpty.signal();
                    System.out.println("向队列取中插入一个元素,队列剩余空间:"+(queueSize-queue.size()));
                } finally{
                    lock.unlock();
                }
            }
        }
    }
}

二、读写锁

ReentrantReadWriteLock 是 Java 中用于控制读写的一个类。lock.readLock 方法用于获取一个读锁,而 lock.writeLock 方法用于获取一个写锁。读锁允许多个线程进行读取数据操作,但不允许修改操作。而写锁则不允许其他线程进行读和写操作。

我们改写下上面的 Demo,将 ReentrantLock 换成 ReentrantReadWriteLock,并锁上读锁

public class ReadWriteLockDemo {

    static final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();   //同步锁

    public static void main(String args[]) {
        //线程1
        new Thread(){
            public void run() {
//                rwl.readLock().lock();
                rwl.writeLock().lock();
                System.out.println(Thread.currentThread().getName() + " have the lock.");
                try {
                    System.out.println(Thread.currentThread().getName() + " sleep 3 Seconds.");
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                rwl.writeLock().unlock();
                System.out.println(Thread.currentThread().getName() + " release the lock.");
            }
        }.start();
        //线程2
        new Thread(){
            public void run() {
                rwl.writeLock().lock();
                System.out.println(Thread.currentThread().getName() + " have the lock.");
                rwl.writeLock().unlock();
                System.out.println(Thread.currentThread().getName() + " release the lock.");
            }
        }.start();
    }
}

运行结果:

Thread-0 have the lock.
Thread-0 sleep 3 Seconds.
Thread-1 have the lock.
Thread-1 release the lock.
Thread-0 release the lock.

从结果可以看出,线程0获取到锁并不会阻塞线程1获取锁,因此可以知道读锁其实是并发的。

如果我们把上面的 rwl.readLock() 换成 rwl.writeLock(),那么线程1就会等到线程0释放锁之后才会继续执行。

三、一个读写锁的例子

读写锁与一般的锁的不同之处就是它有两种锁,分别是读锁(ReadLock)和写锁(WriteLock)。当我们锁上读锁的时候,其他线程也可以读取对象的数据,但是不能修改。但当我们锁上写锁的时候,其他线程就无法进行读操作,也没办法进行写操作。这样就即保证了读取数据的高并发,又保证了线程的数据安全。下面我们来看一个例子:

package com.chanshuyi.class12;

import java.util.Random;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
 * 读写锁实现读写互斥又不影响并发读取
 * @author chenyr
 * @time 2014-12-18 下午09:41:14
 * All Rights Reserved.
 */
public class ReadWriteLock1 {
    
    public static void main(String args[]){
        final MyQueue queue = new MyQueue();
        for(int i = 0; i < 3; i++){
            new Thread(){
                public void run(){
                    while(true){    //不断读取数据
                        queue.get();
                    }
                }                 
            }.start();
        
            new Thread(){
                public void run(){
                    while(true){    //不断写入数据
                        queue.put(new Random().nextInt(10000));
                    }
                }                 
            }.start();
        }
    }

}

class MyQueue{
    private Object data = null;  //共享数据
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    
    //写
    public void put(Object obj){
        rwl.writeLock().lock();
        System.out.println(Thread.currentThread().getName() + " is ready to write !");        
        try{
            Thread.sleep((long)(Math.random() * 1000)); //因为是不断写入,所以必须让线程休眠,避免CPU耗尽
        }catch(Exception e){
            e.printStackTrace();
        }
        this.data = obj;
        System.out.println(Thread.currentThread().getName() + " has complte write :" + this.data);
        rwl.writeLock().unlock();
        try{
            Thread.sleep(1000);  //让写进程休眠长一点时间,否则会导致读取进程很久都无法读取数据。
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    //读
    public void get(){
        rwl.readLock().lock();
        System.out.println(Thread.currentThread().getName() + " is ready to read !");
        try{
            Thread.sleep((long)(Math.random() * 1000)); //因为是不断读取,所以必须让线程休眠,避免CPU耗尽
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "has read the value :" + this.data);
        rwl.readLock().unlock();
    }
}

在上面这个例子中,我们创建了3个读数据进程以及3个写数据进程,不断取出、写入MyQueue中的数据。在MyQueue调用读取数据get()方法时,锁上读锁,在调用写数据put()方法时,锁上写锁。下面是一部分的运行结果:

 1 Thread-1 is ready to read !
 2 Thread-3 is ready to read !
 3 Thread-5 is ready to read !
 4 Thread-1has read the value :null
 5 Thread-3has read the value :null
 6 Thread-5has read the value :null
 7 Thread-6 is ready to write !
 8 Thread-6 has complte write :4138
 9 Thread-4 is ready to write !
10 Thread-4 has complte write :6158
11 Thread-2 is ready to write !
12 Thread-2 has complte write :3333
13 Thread-1 is ready to read !
14 Thread-5 is ready to read !
15 Thread-3 is ready to read !
16 Thread-3has read the value :3333
17 Thread-3 is ready to read !
18 Thread-5has read the value :3333
19 Thread-5 is ready to read !
20 Thread-1has read the value :3333
21 Thread-1 is ready to read !
22 Thread-3has read the value :3333
23 Thread-1has read the value :3333
24 Thread-5has read the value :3333
25 Thread-6 is ready to write !
26 Thread-6 has complte write :6568
27 Thread-4 is ready to write !
28 Thread-4 has complte write :4189
29 Thread-3 is ready to read !
30 Thread-1 is ready to read !
31 Thread-3has read the value :4189
32 Thread-1has read the value :4189

从上面的运行结果我们可以看到:1-3行,13-15行出现了多个线程同时读取数据的情况。

观察输出结果,可以发现在写入数据的时候(如 7 - 12 行),即使有多次连续写入数据,但是都是等待一个线程写入结束后,另一个线程才开始写入数据的,没有出现同时多个线程写入的情况。这就说明写锁不允许多个线程同时写,也不允许读。

这就是读写锁的一个非常重要的应用,比起synchronized或lock锁,它允许多个线程同时读,但是同时有保证了写数据的时候不会有多个线程同时操作。也就是保证了程序读取的并发性能,又保证了线程的数据安全。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏海纳周报

synchronized关键字的语义

上一篇文章,我们讲到,如果发生了多个线程共同访问一个全局变量的时候,就会发生各种意料之外的情况。其实现实生活中有很多这样的例子。我举一个例子。 一群人都要过河,...

3787
来自专栏Jimoer

在Java的反射中,Class.forName和ClassLoader的区别

最近在面试过程中有被问到,在Java反射中Class.forName()加载类和使用ClassLoader加载类的区别。当时没有想出来后来自己研究了一下就写下来...

1512
来自专栏swag code

XML中节点类型

该 Node 接口是整个文档对象模型的主要数据类型。它表示该文档树中的单个节点。当实现 Node 接口的所有对象公开处理子节点的方法时,不是实现 Node 接口...

1276
来自专栏飞雪无情的博客

从Java到Golang快速入门

Golang从09年发布,中间经历了多个版本的演进,已经渐渐趋于成熟,并且出现了很多优秀的开源项目,比如我们熟知的docker,etcd,kubernetes等...

1023
来自专栏前端黑板报

(转)ES6新特性概览

ES6(ECMAScript 6)是即将到来的新版本JavaScript语言的标准,代号harmony(和谐之意,显然没有跟上我国的步伐,我们已经进入中国梦版本...

2125
来自专栏技术专栏

彻底搞懂jdk动态代理并自己动手写一个动态代理

我们都知道牛逼轰轰的Spring AOP的实现的一种方式是使用JDK的动态代理(另一种是cglib,后面会介绍),大部分人也会用jdk的动态代理,不过没有研究过...

2432
来自专栏JackieZheng

并发和多线程-八面玲珑的synchronized

上篇《并发和多线程-说说面试常考平时少用的volatile》主要介绍的是volatile的可见性、原子性等特性,同时也通过一些实例简单与synchronized...

1123
来自专栏ios 技术积累

聊聊Objective-C内存管理

内存管理的文章网上太多了,本文只是简单的聊聊内存管理 让你加深内存管理的理解。 了解内存管理首先你需要思考几个问题 1.为什么需要进行内存管理? 2.内管...

884
来自专栏绿巨人专栏

TypeScript中的怪语法

1173
来自专栏Jackson0714

PHP内核之旅-3.变量

1444

扫码关注云+社区

领取腾讯云代金券