Java多线程07——JUC并发包03

￡神魔★判官ぃ 2024-03-26 07:37 40阅读 0赞

### 1 线程的锁的synchronized、Lock、volatile区别 ###

#### 1.1 synchronized 和 volatile 区别 ####

**用法：**

*  volatile 关键字解决的是变量在多个线程之间的可见性；
 *  synchronized 关键字解决的是多个线程之间访问共享资源的同步性；
 *  多线程访问 volatile 时，程序不会发生阻塞；在访问 synchronized 修饰的方法或代码块时，会出现阻塞；
 *  volatile 能保证变量在多个线程之间的可见性，但无法保证原子性；synchronized 可以保证数据操作的原子性，也可以间接保证数据的可见性，会将线程中私有内存和公有内存的数据进行同步。

比如我们使用信用卡消费，在消费中如果银行对卡片进行了冻结，那么扣款就应该会被拒绝。

此时就需要所有线程都能看到这个卡片状态的变化才行，否则就会造成用户损失。

要让这个状态被有线程看到，就需要使用 `volatile` 来修饰该变量。

扣款就更好理解了，如果不对账户的扣款动作进行加锁，账户相同的一笔钱可以被重复消费，将会造成银行的损失。加上锁之后，所有扣款行为将在这里**串行**进行，消费一笔扣减一笔，避免账户透支或者重复支付。

![793dadcb87bb4eeffdfdfd7bccb0ad5e.png][]

**使用场景：**

*  volatile关键字只能用于修饰变量；
 *  synchronized 关键字可以修饰方法，代码块。

#### 1.2 synchronized 和 Lock 区别 ####

**实现**

Lock 是一个接口，而 `synchronized` 是 Java 中的关键字，由内置语言实现。

**异常处理机制**

synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁发生；

Lock 在发生异常时，如果没有主动通过 unlock() 方法去释放锁，则很可能造成死锁，因此使用 Lock 时需要在 finally 块中增加手动释放锁的语句。

synchronized{
         语句块;
    }
    
    Lock lock = new ReentrantLock()
    lock.lock();
    lock.unLock();

lock() 和 unlock() 必须成对存在。

**效率**

Lock 可以提高多个线程进行读操作的效率（读写锁）。

### 2 线程的读写分离机制 ###

`ReadWriteLock` 是读写锁：

*  维护了一对相关的锁“读取锁”和“写入锁”，一个用于读取操作，另一个用于写入操作。
 *  读取锁，用于只读操作，它是共享锁，能同时被多个线程获取。
 *  写入锁，用于写入操作，它是独占锁，写入锁只能被一个线程锁获取。
 *  不能同时存在读取锁和写入锁，可以同时进行读/读操作，但不能同时读/写、写/写操作。

#### 2.1 创建账号类 ####

public class MyCount {
        private String id;//账号
        private int cash;//账户余额
    
        public MyCount(String id, int cash) {
            this.id = id;
            this.cash = cash;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        //读取操作
        public int getCash() {
            System.out.println(Thread.currentThread().getName() + " getcash, cash=" + cash);
            return cash;
        }
    
        //写入操作
        public void setCash(int cash) {
            System.out.println(Thread.currentThread().getName() + " setcash, cash=" + cash);
            this.cash = cash;
        }
    }

#### 2.2 创建用户信息类 ####

在用户信息类中声明了读写锁，

并在读取方法中创建读取锁，

在写入方法中创建写入锁，

所有锁在使用完后，均需要手动关闭锁。

import java.util.concurrent.locks.ReadWriteLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class User {
        private String name;
        private MyCount myCount;
        //声明读写锁
        private ReadWriteLock readWriteLock;
    
        public User(String name, MyCount myCount) {
            this.name = name;
            this.myCount = myCount;
            this.readWriteLock = new ReentrantReadWriteLock();
        }
    
        //查询余额
        public void getCash(){
            new Thread(){
                @Override
                public void run() {
                    //创建读取锁
                    readWriteLock.readLock().lock();
                    try {
                        System.out.println(Thread.currentThread().getName() + " getCash start");
                        myCount.getCash();
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName() + " getCash end");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        //手动关闭锁
                        readWriteLock.readLock().unlock();
                    }
                }
            }.start();
        }
    
        //设置余额
        public void setCash(final int cash){
            new Thread(){
                @Override
                public void run() {
                    //创建写入锁
                    readWriteLock.writeLock().lock();
                    try {
                        System.out.println(Thread.currentThread().getName() + " setCash start");
                        myCount.setCash(cash);
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName() + " setCash end");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        //手动关闭锁
                        readWriteLock.writeLock().unlock();
                    }
                }
            }.start();
        }
    }

#### 2.3 创建测试类 ####

在测试类中创建用户及账户，并对账户信息使用多线程进行读取和写入操作。

public class Test {
    
        public static void main(String[] args) {
            //创建账户
            MyCount myCount = new MyCount("abcd12", 5000);
            //创建用户，并指定账户
            User user = new User("小张", myCount);
    
            for (int i = 0; i < 3; i++) {
                user.getCash();
                user.setCash((i + 1) * 1000);
            }
        }
    }

#### 2.4 输出结果 ####

> Thread-0 getCash start
> 
> Thread-0 getcash, cash=5000
> 
> Thread-2 getCash start
> 
> Thread-2 getcash, cash=5000
> 
> Thread-2 getCash end
> 
> Thread-0 getCash end
> 
> Thread-1 setCash start
> 
> Thread-1 setcash, cash=1000
> 
> Thread-1 setCash end
> 
> Thread-4 getCash start
> 
> Thread-4 getcash, cash=1000
> 
> Thread-4 getCash end
> 
> Thread-5 setCash start
> 
> Thread-5 setcash, cash=3000
> 
> Thread-5 setCash end
> 
> Thread-3 setCash start
> 
> Thread-3 setcash, cash=2000
> 
> Thread-3 setCash end

**在输出的结果中，可以看到：**

读取操作 getCash ，在 Thread-0 执行时，但未执行完，Thread-2 也同时进入到了读取操作，它们正在**并行执行**；

![e57f08d4e738446ef02179a73bd17021.png][]

写入操作 setCash ，所有线程均从 start 到 end，中间并未有其他线程进入，属于**独占执行**。

![4279b2f80eff2f035ddb7ca772796403.png][]

[793dadcb87bb4eeffdfdfd7bccb0ad5e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/7a782534f8a94c21880623cf1f6d6cb9.png
[e57f08d4e738446ef02179a73bd17021.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c7f42867e18c40cc88f711d8a0ddcf8a.png
[4279b2f80eff2f035ddb7ca772796403.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/6149395ea25d41fbaaf7f9992e406e34.png