线程同步Lock

最新推荐文章于 2022-03-17 14:58:52 发布

IT界的吉祥物

最新推荐文章于 2022-03-17 14:58:52 发布

阅读量2.5w

点赞数 4

分类专栏： java Java学习之旅文章标签： Lock 同步线程 java 锁机制

本文链接：https://blog.csdn.net/hai_qing_xu_kong/article/details/70768583

版权

java 同时被 2 个专栏收录

49 篇文章 0 订阅

订阅专栏

Java学习之旅

39 篇文章 7 订阅

订阅专栏

转载请标明出处:
http://blog.csdn.net/hai_qing_xu_kong/article/details/70768583
本文出自：【顾林海的博客】

前言

除了上一篇文章的synchronized，Java还提供了同步代码块的另一种机制，这种机制基于Lock接口及其实现类。相比与synchronized来说更强大也更灵活。

关于线程相关知识可以查看：

《有关线程的相关知识（1）》
《有关线程的相关知识（2）》

关于synchronized的相关知识可以查看：

《线程同步synchronized》

Lock的使用

使用Lock能支持更灵活的同步代码块结构，也就是控制的获取和释放不出现在同一个块结构中。Lock接口提供了很多的功能，可以通过tryLock()方法来试图获取锁，如果锁已经被其他线程获取，它将返回false并继续往下执行代码。Lock接口允许分离读和写操作，允许多个读线程和只有一个写线程。

下面编写一个使用Lock接口和它的实现类ReentrantLock类来创建一个临界区：

public class Queue {

    // 声明一个锁对象，并且用ReentrantLock类初始化
    private final Lock queueLock = new ReentrantLock();

    /**
     * 打印信息 通过调用lock()方法获取对锁对象的控制
     */
    public void printJob() {
        queueLock.lock();
        System.out.println("正在打印信息..."+new Date());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            queueLock.unlock();
        }
    }

}

public class Event implements Runnable{

    private Queue queue;

    public Event(Queue queue){
        this.queue=queue;
    }

    @Override
    public void run() {
        queue.printJob();
    }

}

public class Client {
    public static void main(String[] args) {
        Queue queue=new Queue();

        Event event=new Event(queue);

        Thread[] thread=new Thread[10];

        for(int i=0,length=thread.length;i<length;i++){
            thread[i]=new Thread(event);
        }

        for(int i=0,length=thread.length;i<length;i++){
            thread[i].start();
        }

    }
}

上面Queue类中，定义来printJob()方法，通过lock()方法获取对锁对象的控制，最后通过unlock()方法释放对锁对象的控制。在主类中创建了10个线程，并启动这10个线程，运行程序，会在控制台上每隔1秒打印信息。

运行程序：
正在打印信息...Tue Apr 25 22:02:31 CST 2017
正在打印信息...Tue Apr 25 22:02:32 CST 2017
正在打印信息...Tue Apr 25 22:02:33 CST 2017
正在打印信息...Tue Apr 25 22:02:34 CST 2017
正在打印信息...Tue Apr 25 22:02:35 CST 2017
正在打印信息...Tue Apr 25 22:02:36 CST 2017
正在打印信息...Tue Apr 25 22:02:37 CST 2017
正在打印信息...Tue Apr 25 22:02:38 CST 2017
正在打印信息...Tue Apr 25 22:02:39 CST 2017
正在打印信息...Tue Apr 25 22:02:40 CST 2017

通过运行结果可以看出，对临界区的访问通过锁，来实现同一时间只有一个执行线程访问这个临界区，这里通过lock()方法获取对锁的控制，当某个线程访问这个方法时，如果没有其他线程获取对这个锁的控制，lock()方法将得到并且允许它立刻执行临界区。在线程离开临界区的时候，我们必须使用unlock()方法来释放它持有的锁，以让其他线程访问临界区，如果在离开临界区没有调用unlock()方法释放它持有的锁，其他线程将永远等待，从而导致死锁。

除了使用lock()方法来获取锁之外，Lock接口还提供了另一个方法来获取锁，即tryLock()方法。与lock()方法不同之处在于线程使用tryLock()不能够获取锁，tryLock()会立即返回，它不会将线程置入休眠，返回true表示线程获取了锁，false表示没有获取锁。

使用读写锁实现同步数据访问

ReadWriteLock接口和它唯一实现类ReentrantReadWriteLock，一个是读操作锁，另一个是写操作锁。使用读操作锁时可以允许多个线程同时访问，使用写操作锁时只允许一个线程进行。在一个线程执行写操作时，其他线程不能够执行读操作。

接下来通过ReadWriteLock接口来编写对某个对象的访问。

public class Product {

    private int number1;
    private int number2;

    private ReadWriteLock lock;

    public Product() {
        number1 = 10;
        number2 = 20;
        lock = new ReentrantReadWriteLock();
    }

    /**
     * 通过读锁获取对这个属性的访问
     * 
     * @return number1
     */
    public int getNumber1() {
        lock.readLock().lock();
        int number = number1;
        lock.readLock().unlock();
        return number;
    }

    /**
     * 通过读锁获取对这个属性的访问
     * 
     * @return number2
     */
    public int getNumber2() {
        lock.readLock().lock();
        int number = number2;
        lock.readLock().unlock();
        return number;
    }

    /**
     * 使用写锁来控制对这两个属性的访问
     * 
     * @param number1
     * @param number2
     */
    public void setNumber(int number1, int number2) {
        lock.writeLock().lock();
        System.out.println("写入number1:"+number1+"和number2:"+number2);
        this.number1 = number1;
        this.number2 = number2;
        lock.writeLock().unlock();
    }

}

/**
 * 读取类，读取Product的number1和number2
 * 
 * @author gulinhai
 *
 */
public class Reader implements Runnable {

    private Product product;

    public Reader(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("number1=" + product.getNumber1() + ";number2=" + product.getNumber2());
        }
    }

}

/**
 * 写入类，修改number1和number2
 * @author gulinhai
 *
 */
public class Writer implements Runnable {

    private Product product;

    public Writer(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {

            product.setNumber(i, i * 2);
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

public class Client {
    public static void main(String[] args) {
        Product product = new Product();

        Reader[] reader = new Reader[5];
        Thread[] readerThread = new Thread[5];

        for (int i = 0, length = readerThread.length; i < length; i++) {
            reader[i] = new Reader(product);
            readerThread[i] = new Thread(reader[i]);
        }

        Writer writer = new Writer(product);
        Thread writerThread = new Thread(writer);

        for (int i = 0, length = readerThread.length; i < length; i++) {
            readerThread[i].start();
        }
        writerThread.start();

    }
}

运行结果：
写入number1:0和number2:0
写入number1:1和number2:2
number1=1;number2=2
number1=1;number2=2
number1=1;number2=2
number1=1;number2=2
number1=1;number2=2
写入number1:2和number2:4
number1=2;number2=4
number1=2;number2=4
number1=2;number2=4
number1=2;number2=4
number1=2;number2=4
写入number1:3和number2:6
number1=3;number2=6
number1=3;number2=6
number1=3;number2=6
写入number1:4和number2:8
number1=4;number2=8
number1=3;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8
number1=4;number2=8

通过输出结果可以看出合理的利用ReentrantReadWriteLock类的两种锁，可以有效的避免数据不一致的问题。

ReentrantLock和ReentrantReadWriteLock类的构造器都含有一个布尔参数，它允许你控制这个两个类的行为，默认值是false，称为非公平模式，在非公平模式下，当有很多线程在等待锁时，锁将选择他们中的一个来访问临界区，这个选择是没有任何约束的。当布尔值为true时，称为公平模式，在公平模式下，当有很多线程在等待锁时，锁将选择它们中的一个来访问临界区，而且选择的是等待时机最长的。

锁中使用多条件

一个锁可能关联一个或者多个条件，这些条件通过Condition接口声明，目的允许线程获取锁并且查看等待的某一个条件是否满足，如果不满足就挂起直到某个线程唤醒它们，Condition接口提供了挂起线程和唤起线程的机制。

编程程序，利用Condition来解决生产者－消费者问题。

/**
 * 创建数据存储类EventStorage，并保存一个最大值maxSize和数据集合 LinkedList<Date>来保存存入的日期。
 * 
 * @author gulinhai
 *
 */
public class EventStorage {

    private int maxSize;
    private LinkedList<Date> storage;

    private ReentrantLock lock;

    private Condition condition1;
    private Condition condition2;

    public EventStorage() {
        lock = new ReentrantLock();
        condition1 = lock.newCondition();
        condition2 = lock.newCondition();
        this.maxSize = 10;
        this.storage = new LinkedList<>();
    }

    public int size() {
        return storage.size();
    }

    /**
     * <pre>
     * 获取锁，检查这个缓冲区是否满了，如果缓冲区满了，
     * 就调用条件condition1的await()方法
     * 等待空位出现，当其他线程调用条件condition1的
     * signal()或者signalAll()方法时，这个线程
     * 将被唤醒，在有空位后，线程会将数据保存到缓冲区中，
     * 并调用条件condition2的signalAll()方法。
     * </pre>
     */
    public void set() {
        lock.lock();
        try {
            while (storage.size() == maxSize) {
                condition1.await();
            }
            storage.add(new Date());
            condition2.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    /**
     * <pre>
     * 获取锁，检查这个缓冲区是否为空，如果缓冲区为空，
     * 就调用条件condition2的await()方法
     * 等待数据出现，当其他线程调用条件condition2的
     * signal()或者signalAll()方法时，这个线程
     * 将被唤醒，在有数据后，线程会从缓冲区中取出数据，
     * 并调用条件condition1的signalAll()方法。
     * </pre>
     */
    public void get() {
        lock.lock();
        try {
            while (storage.size() == 0) {
                condition2.await();
            }
            storage.poll();
            condition1.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

}

/**
 * 生产者
 * @author gulinhai
 *
 */
public class Producer implements Runnable{

    private EventStorage storage;

    public Producer(EventStorage storage){
        this.storage=storage;
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            storage.set();
        }
    }

}

/**
 * 消费者
 * @author gulinhai
 *
 */
public class Consumber implements Runnable{

    private EventStorage storage;

    public Consumber(EventStorage storage){
        this.storage=storage;
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            storage.get();
        }
    }

}

public class Client {

    public static void main(String[] args) {
        EventStorage storage=new EventStorage();

        Producer producer=new Producer(storage);
        Thread producerThread=new Thread(producer);

        Consumber consumber=new Consumber(storage);
        Thread consumberThread=new Thread(consumber);

        producerThread.start();
        consumberThread.start();

        try {
            producerThread.join();
            consumberThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("缓冲区数据个数："+storage.size());

    }

}

输出结果：
缓冲区数据个数：0

与锁绑定的所有条件对象都是通过Lock接口声明的newCondition()方法创建的，在使用条件的时候，必须获取这个条件绑定的锁，所以带条件的代码必须在调用Lock对象的lock()方法和unlock()方法之间，当线程调用条件的await()方法时，它将自动释放这个条件绑定的锁，其他某个线程才可以获取这个锁并且执行相同的操作，或者执行这个锁保护的另一个临界区代码。