Java 内存模型（三）—— 锁

2019年3月10日 235次阅读来源: java内存模型

什么是线程安全？

线程安全是指当一个对象被多个线程访问操作时，最终都能得到正确的结果，那这个对象是线程安全的。Java 中可以通过同步块和加锁保障线程安全。

锁

锁是 Java 并发编程中最重要的同步机制，它可以让等待在临界区的线程互斥执行。

关键字 synchronized

synchronized 也是一种锁，它通过字节码指令 monitorenter 和 monitorexist 隐式的来使用 lock 和 unlock 操作。synchronized 具有原子性和可见性。

synchronized 示例：

/** * @Project Name:test * @File Name:SynchronizedTest.java * @Package Name:com.pdh * @Date:2017年2月12日下午5:36:46 */

package com.pdh.test.thread;

/** * synchronized 具有原子性和可见性 * * @author pengdh * @date 2017/11/12 */
public class SynchronizedDemo {

    private int safeNum = 0;
    private int unsafeNum = 0;

    /** * 使用 synchronized 同步实现复合运算,线程安全的 */
    private synchronized void safeIncrease() {
        safeNum++;
    }

    /** * 普通复合运算，线程不安全的 */
    private void unsafeIncrease() {
        unsafeNum++;
    }

    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        for (int i = 0; i < 20000; i++) {
            new Thread(() -> {
                demo.unsafeIncrease();
                demo.safeIncrease();
            }).start();
        }

        while (Thread.activeCount() > 2) {
            Thread.yield();
        }

        System.out.println("unsafeNum: " + demo.unsafeNum);
        System.out.println("safeNum: " + demo.safeNum);
    }
}

在示例中，申明了两个方法，一个是使用了 synchronized 修饰的同步块方法 safeIncrease() 对共享变量 safeNum 的自增操作，由于该方法使用了 synchronized 同步块实现了线程对变量 safeNum 的互斥操作，是线程安全的，所以最终获取到了正确的结果 20000；而另一个方法 unsafeIncrease() 为使用任何手段保护全局变量 unsafeNum，是线程不安全的，所以最终获取到的结果大多数情况下是小于 20000 的。

重入锁（ReentrantLock）

从 JDK 5.0 开始，Java 并发包实现了高性能的支持重入的锁 ReentrantLock，属于一种排它锁。重入锁通过显示的请求获取和释放锁，为了避免获得锁后，没有释放锁，而造成其它线程无法获得锁而造成死锁，一般建议将释放锁操作放在finally块里。

重入锁示例：

package com.pdh.test.thread.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/** * ReentrantLock 实现线程同步 * * @author pengdh * @date 2017/11/12 */
public class ReentrantLockDemo implements Runnable {
    private int num = 0;
    private Lock lock = new ReentrantLock();

    /** * 利用重入锁实现变量累加操作 */
    private void increase() {
        lock.lock();
        try {
            num++;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockDemo demo = new ReentrantLockDemo();
        for (int i = 0; i < 2000; i++) {
            new Thread(() -> {
                demo.increase();
            }).start();
        }
        // 等待所有线程全部执行完
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(demo.num);
    }
}

重入锁提供以下几个主要方法

lock()：获得锁，如果锁已经被占用，则等待；
lockInterruptibly()：获取锁，若获取成功立即返回；若获取不成功则阻塞等待。与lock方法不同的是，在阻塞期间，如果当前线程被打断（interrupt）则该方法抛出InterruptedException。该方法可以有效避免死锁题。
tryLock()：该方法尝试获取锁，如果成功，返回 true ，若失败返回 false。该方法不等待，立即返回。
tryLock(long time, TimeUnit unit)：该方法尝试获取锁，若成功，则返回 true，若失败，则等待相应的时间，如果该时间内能获得锁，则返回 true，如果相应的时间内仍未获取到锁则返回 false，如果在等待期间当前线程被中断则抛出 InterruptedException；
unlock()：释放锁；

synchronized 与 ReentrantLock 的区别

所有使用 synchronized 的地方都可以使用 ReentrantLock ；
synchronized 是通过字节码指令 monitorenter 和 monitorexist 实现隐式加锁和解锁，而 ReentrantLock 是通过 lock 和 unlock 操作实现显示加锁和解锁；
ReentrantLock 可以实现公平和非公平两种锁，而 synchronized 只能实现非公平锁；
ReentrantLock 可以中断对锁的等待来避免 synchronized 可能带来的死锁问题；

Condition 条件锁

Condition 的用法与 wait() 和 notify() 作用类似，wait() 和 notify() 是和 synchronized 关键字搭配使用，而 Condition 是与重入锁搭配使用。利用 Condition 对象，就可以让线程在合适的时间等待，或者在某个特定的时刻得到通知，继续执行。

Condition 提供以下几个方法

await()：该方法会使当前线程等待，同时释放当前锁，当其它线程中使用 signal() 或者 singnalAll() 方法时，线程会重新获得锁并继续执行。或者当前线程被中断时，也能跳出等待。
awaitUninterruotibly()：该方法使用和 await() 基本相同，但是它不会再等待的过程中响应中断。
singal()：该方法用于唤醒一个在等待中的线程，而 singalAll() 方法会唤醒所有在等待的方法。

Condition 示例：

package com.pdh.test.thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/** * Condition 示例 * * @author pengdh * @date 2017/11/12 */
public class ConditionDemo {

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        new Thread(() -> {
            lock.lock();
            System.out.println("thread 1 is waiting");
            try {
                condition.await();
                System.out.println("thread 1 is wake up");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }).start();

        new Thread(() -> {
            lock.lock();
            try {
                System.out.println("thread 2 is running");
                Thread.sleep(3000);
                condition.signal();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }).start();
    }
}

信号量（Semaphore）

信号量为多线程协作提供了更为强大的控制方法，广义上说，信号量是对锁的扩展。无论是内部锁 synchronized 还是重入锁 ReentrantLock，一次都只允许一个线程访问一个资源，而信号量却可以指定多个线程，同时访问某一个资源。

信号量提供了以下方法

acquire()：该方法尝试获得一个许可。若无法获得，则线程会等待，直到有线程释放一个许可或者当前线程被中断。
acquire(int permits)：申请 permits（必须为非负数）个许可，若获取成功，则该方法返回并且当前可用许可数减permits；若当前可用许可数少于 permits 指定的个数，则继续等待可用许可数大于等于 permits；若等待过程中当前线程被中断，则抛出 InterruptedException。
acquireUninterruptibly() ：该方法和 acquire() 类似，但不响应中断。
tryAcquire()：尝试获得一个许可，如果成功则返回 true，如果失败则返回 false，它不会进行等待，立即返回。
release()：用于在线程访问资源结束后，释放一个许可，以使其它等待许可的线程可以进行资源访问。

Semaphore 示例：

package com.pdh.test.thread;

import java.util.concurrent.Semaphore;

/** * 信号量示例 * * @author pengdh * @date 2017/11/12 */
public class SemaphoreDemo {
    private static final Semaphore semaphoreToken = new Semaphore(5);

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                // 获取令牌
                try {
                    semaphoreToken.acquire();
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getId() + " finished");
                    // 归还令牌
                    semaphoreToken.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

读写锁（ReadWriteLock）

读写锁适用于多线程编程中读多写少的场景中，对于原子性而言，更多是关注写操作，读和读操作之间并不需要互斥操作，只需要保证读和写或者写和写之间是互斥操作即可。所以如果在某个场景下读操作次数远远大于写操作次数，则可以使用读写锁来提高效率。

读写锁示例

package com.pdh.test.thread;

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

/** * 读写锁示例 * * @author pengdh * @date 2017/11/13 */
public class ReadWriteLockDemo {

    public static void main(String[] args) {
        ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        new Thread(() -> {
            readWriteLock.readLock().lock();
            try {
                System.out.println("the first read lock begin");
                Thread.sleep(1000);
                System.out.println("the first read lock end");
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                readWriteLock.readLock().unlock();
            }
        }).start();

        new Thread(() -> {
            readWriteLock.readLock().lock();
            try {
                System.out.println("the second read lock begin");
                Thread.sleep(1000);
                System.out.println("the second read lock end");
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                readWriteLock.readLock().unlock();
            }
        }).start();

        new Thread(() -> {
            readWriteLock.writeLock().lock();
            try {
                System.out.println("the write lock begin");
                Thread.sleep(1000);
                System.out.println("the write read lock end");
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                readWriteLock.writeLock().unlock();
            }
        }).start();
    }
}

参考文献

深入理解 Java 虚拟机

《Java 内存模型（三）—— 锁》

欢迎扫一扫关注程序猿pdh 公众号！

    原文作者：java内存模型
    原文地址: https://blog.csdn.net/bhuds/article/details/78516578
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。