15. 线程同步-sychronized与Lock

java 多线程系列文章列表, 请查看目录: 《java 多线程学习笔记》

1. 线程安全问题

在多线程环境下, 如果使用线程不安全的类型, 可能会产生并发问题. 解决线程安全问题, 笔者总结有以下三种情况:

• 使用线程安全的变量: Automicxxx 等
• 使用隐形锁, 借助synchronized 关键字
• 使用显示锁, java5 新增的Lock 接口

1.1 模拟多线程并发问题

public class Product {

    private Integer total = 10;

    public void sale(){
        if(total > 1){
            total = total -1;
            System.out.println(Thread.currentThread().getName() + "-售一件商品, 剩余商品:" + total);
        }
    }

    public static void main(String[] args) {

        // 创建多线程共享变量
        Product product = new Product();

        // 开启3个线程
        for (int i = 0; i < 3; i++) {
            new Thread(){
                @Override
                public void run() {
                    while (true) {
                        // 休眠1秒
                        ThreadUtil.sleep(1);

                        product.sale();
                    }
                }
            }.start();
        }
    }
}

1.2 测试输出

从输出结果可以发现, 商品剩余数量紊乱. 这也便是线程安全问题

Thread-1-售一件商品, 剩余商品:7
Thread-2-售一件商品, 剩余商品:7
Thread-0-售一件商品, 剩余商品:7
Thread-1-售一件商品, 剩余商品:6
Thread-2-售一件商品, 剩余商品:5
Thread-0-售一件商品, 剩余商品:4
Thread-1-售一件商品, 剩余商品:3
Thread-2-售一件商品, 剩余商品:2
Thread-0-售一件商品, 剩余商品:1

1.3 死锁问题

当两个线程相互等待对方释放同步监视器时, 便会产生死锁. 对于死锁现象, java 虚拟机并没有监测, 也没有采取措施来处理死锁情况, 因此在多线程编程时, 一定要防范出现死锁的情况.

2. synchronized-隐式锁方式

同步方法和同步代码块儿方式也称为隐式锁方式, 这是在jdk5 之前的方式.

2.1 同步方法

synchronized public void sale(){
    if(total > 1){
        total = total -1;
        System.out.println(Thread.currentThread().getName() + "-售一件商品, 剩余商品:" + total);
    }
}

2.2 同步代码块儿

public void sale(){
    synchronized (total) {
        if(total > 1){
            total = total -1;
            System.out.println(Thread.currentThread().getName() + "-售一件商品, 剩余商品:" + total);
        }
    }
}

2.3 运行输出

从输出结果看, 会发现没有线程安全问题了.

Thread-0-售一件商品, 剩余商品:9
Thread-2-售一件商品, 剩余商品:7
Thread-1-售一件商品, 剩余商品:8
Thread-0-售一件商品, 剩余商品:6
Thread-2-售一件商品, 剩余商品:5
Thread-1-售一件商品, 剩余商品:4
Thread-0-售一件商品, 剩余商品:3
Thread-2-售一件商品, 剩余商品:2
Thread-1-售一件商品, 剩余商品:1

2.4 自动释放同步监视器的锁定

• 自动释放情况:
  • 当同步的方法/代码块儿执行结束(正常结束, 遇到break, return终止代码块儿或方法, 抛出未捕获异常Error/Exception)时, 会自动释放同步监视器
  • 当程序中执行了wait()方法时, 当前线程暂停, 并释放同步监视器
• 不自动释放情况:
  • 当同步代码块儿/同步方法中调用了Thread.sleep(), Thread.yield()方法时, 当前线程不会释放同步监视器.
  • 当同步代码块儿/同步方法中调用了Thread.suspend()时, 不会释放. 程序中应避免直接调用suspend()方法.

3. 显示锁方式

java5 之后, 新增了Lock 类, 用于显示控制加锁和释放锁的时机. java5 定义了两个顶级接口Lock 和 ReadWriteLock, 并分别为其提供了实现类:

• ReentrantLock: 可重入锁, 可重复加锁, 比较常用.
• ReentrantReadWriteLocak: 读写锁

3.1 ReentrantLock 用法

• 务必将释放锁的操作放入finally代码块儿中, 否则容易出现锁未释放问题.
• ReentrantLock 锁具有可重入性, 也就是说一个线程可以对已加锁的ReentrantLock 锁再次加锁. ReentrantLock 对象会维持一个计数器来追中lock()的嵌套调用. 线程在每次调用lock()加锁之后, 必须调用unlock()方法释放锁.

public class Product {

    private Integer total = 10;

    // 定义锁
    private Lock lock = new ReentrantLock();

    public void sale(){
        // 添加锁
        lock.lock();

        try {
            if(total > 1){
                total = total -1;
                System.out.println(Thread.currentThread().getName() + "-售一件商品, 剩余商品:" + total);
            }
        }finally {
            // 方法结束后必须释放锁
            lock.unlock();
        }
    }

}

3.2 ReentrantReadWriteLock 用法示例

• 对于读写锁, 笔者并没有找到一个合适的应用场景, 因此简单写一个使用示例吧.

public class Product {

    private Integer total = 10;

    private ReadWriteLock lock = new ReentrantReadWriteLock();

    public void sale(){
        // 添加锁
        lock.writeLock().lock();

        try {
            if(total > 1){
                total = total -1;
                System.out.println(Thread.currentThread().getName() + "-售一件商品, 剩余商品:" + total);
            }
        }finally {
            // 方法结束后必须释放锁
            lock.writeLock().unlock();
        }
    }

    public void queryLeft(){
        // 添加锁
        lock.readLock().lock();

        try {
            System.out.println(Thread.currentThread().getName() + "-当前剩余商品:" + total);
        }finally {
            // 方法结束后必须释放锁
            lock.readLock().unlock();
        }
    }
}