多线程的相关关键词理解 volatile,atomic,synchronized,lock

末蓝、 2022-07-16 13:46 94阅读 0赞

## 多线程的相关关键词理解 volatile,atomic,synchronized,lock ##

\*\*

1.  **造成线程不安全的原因： 多线程操作一个变量的时候，每个线程会保存有自己的副本，线程的内部当进行操作的时候实际用的是副本，而不是主线程本身。 创建副本的时候（其他线程创建的时候），会去到当前主线程本身的值，不会去拿到其他线程副本里面的值，拿到的值可能是 其他线程操作过后的值，所以这个值不一定是最新的值。 当副本赋值完成之后会把自己当前变量的值赋值到主线程本身去，不管别线程有没有赋值过，所以抹杀了别人的劳动成果造成线程不安全。**

========================================================================

\*\*

**1. volatile**

1.  先看代码

public class BankCard4 {
        
         Account account;
        public BankCard4() {
            account = new Account();
            //默认有100块
            account.setMoney(100);
        }
        /**
         * 存款
         *
         * @param money
         */
        public  void deposit(long money) {
            long old = account.getMoney();
            account.setMoney(old + money);
            System.out.println(Thread.currentThread().getName() + "充值成功" + account.getMoney());
        }
    
        /**
         * 取款
         */
        public  void withdraw(long money) {
            long old = account.getMoney();
            if (old < money ) {
                System.out.println(Thread.currentThread().getName() + " 余额不足！ 余额：" + old);
            }
            if (old - money >= 0) {
                account.setMoney(old - money);
                System.out.println(Thread.currentThread().getName() + " 取款成功 ： " + money + " 余额 ：  " + account.getMoney());
            }
        }
    
    }

public class Test {
      //volatile 修饰
        static volatile BankCard4 bankCard = new BankCard4();
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new Thread(() -> {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    bankCard.deposit(10);
                    // bankCard.withdraw(10);
                }).start();
            }
        }
    //开了十个线程 去对同一个变量操作，经过 volatile 修饰。理论上我们充值完成后
    //应该有200 ， 原来有100 ， 10个线程 每个线程 充值10块。
    }

结果：

Thread-2充值成功130
    Thread-8充值成功180
    Thread-7充值成功170
    Thread-6充值成功160
    Thread-4充值成功160
    Thread-5充值成功140
    Thread-3充值成功140
    Thread-0充值成功130
    Thread-1充值成功130
    Thread-9充值成功190
    
    Process finished with exit code 0

1.  结果我们发现 充值过后 最大是 190，没有得到想要的 结果，而且多次充值结果一样。如果是真的银行卡，那太可怕了。
2.  事实证明了volatile并不是线程安全的 。
3.  经过volatile修饰，只是保证在创建副本的时候去取其他副本里面的最新的值。
4.  后面副本赋值到主线程的时候，会拿自己的值去覆盖其他线程赋值的值，所以造成了线程不安全的原因。

**结论： *\*volatile修饰不能保证线程安全，只能保证线程建立的时候副本的值是最新的。\****保证此变量对所有线程的可见性(当一条线程修改这个变量值时，新值其他线程立即得知，不能保证在并发条件下是线程安全)

## 2.atomic类 ##

1.  原子包：java.util.concurrent.atomic  
    原理： 提供了一组原子类。其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入，这只是一种逻辑上的理解。  
    i++ 这就是一个原子操作，就是必须等这个线程的这个操作完成后才能进行其他操作。  
    这就是原子操作。

package bank;
    
    import java.util.concurrent.atomic.AtomicLong;
    import java.util.concurrent.atomic.AtomicReference;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * Created by linving on 2016/11/15.
     */
    public class BankCard3 {
        
       // private AtomicReference<Long> moneny;
        private AtomicLong moneny = new AtomicLong(); //用原子包下面的 AtomicLong 进行操作
    
        public BankCard3() {
           // moneny = new AtomicReference<>();
            moneny.set(100L);
        }
    
    
        /**
         * 存款
         *
         * @param
         */
        public void deposit(long m) {
            Long tmp = moneny.get();
           if(moneny.compareAndSet(tmp, tmp + m)) ;
            System.out.println(Thread.currentThread().getName() + "充值成功" + moneny.get());
        }
    
        /**
         * 取款
         */
        public void withdraw(long m) {
            long old = moneny.get();
    
            if (old < m) {
                System.out.println(Thread.currentThread().getName() + " 余额不足！ 余额：" + old);
            }
    
            if (moneny.compareAndSet(old, old - m)) {
                System.out.println(Thread.currentThread().getName() + " 取款成功 ： " + m + " 余额 ：  " + moneny.get());
            }
        }
    
    }

Thread-1充值成功110
    Thread-0充值成功110
    Thread-2充值成功110
    Thread-3充值成功120
    Thread-4充值成功130
    Thread-5充值成功140
    Thread-6充值成功150
    Thread-7充值成功160
    Thread-8充值成功170
    Thread-9充值成功180
    
    Process finished with exit code 0

从结果看：是线程不安全的。  
也只能保证原子操作，也就是取钱，存钱的操作是不会被打断。  
也就是防止加到一半了变量变成其他的其他线程进来，不能保证线程安全。

**3. synchronized**

1.  同步锁的使用  
    可以锁定对象或者方法
2.  synchronized（obj）  
    锁定对象的时候 该对象只能被当前获得锁的线程使用，其他线程需要等待。  
    锁定范围是整个对象。
3.  public synchronized void method()  
    锁定函数，锁定的改函数只能被获取到锁定线程使用，其他线程需要等待。  
    锁定范围只是加锁的函数。 其他没有加锁的函数可以被其他线程使用。

package bank;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * Created by linving on 2016/11/15.
     */
    public class BankCard2 {
        
        // private AtomicReference<Account> atomicReference;
        Account account;
    
        public BankCard2() {
            account = new Account();
            account.setMoney(100);
        }
    
    
        /**
         * 存款
         *
         * @param money
         */
        public synchronized void deposit(long money) {
            long old = account.getMoney();
            account.setMoney(old + money);
            System.out.println(Thread.currentThread().getName() + "充值成功" + account.getMoney());
        }
    
        /**
         * 取款
         */
        public synchronized void withdraw(long money) {
            long old = account.getMoney();
    
            if (old < money ) {
                System.out.println(Thread.currentThread().getName() + " 余额不足！ 余额：" + old);
            }
    
            if (old - money >= 0) {
                account.setMoney(old - money);
                System.out.println(Thread.currentThread().getName() + " 取款成功 ： " + money + " 余额 ：  " + account.getMoney());
            }
        }
    
    }

结果：

Thread-9充值成功110
    Thread-8充值成功120
    Thread-6充值成功130
    Thread-5充值成功140
    Thread-4充值成功150
    Thread-7充值成功160
    Thread-3充值成功170
    Thread-0充值成功180
    Thread-1充值成功190
    Thread-2充值成功200
    
    Process finished with exit code 0

结果和我们预期的一样。

4.Lock

1.  Lock 和 synchronized 同样可以保证线程安全性。
2.  使用比 synchronized 要灵活，但是复杂了一点：
3.  可以把锁锁在所需要加锁的代码块上面。
4.  灵活，但是要只注意 死锁问题。锁需要自己释放，synchronized 的锁执行完代码后会自己释放，不存在死锁问题。lock 则要自己释放，忘记释放很容易造成死锁。

package bank;
    
    import bank.Account;
    
    import java.util.concurrent.atomic.AtomicReference;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * Created by linving on 2016/11/15.
     */
    public class BankCard {
        
        // private AtomicReference<Account> atomicReference;
        Account account;
        Lock lock;
    
        public BankCard() {
            account = new Account();
            account.setMoney(100);
            lock = new ReentrantLock();
        }
    
    
        /**
         * 存款
         *
         * @param money
         */
        public void deposit(long money) {
            lock.lock();
            long old = account.getMoney();
            account.setMoney(old + money);
            System.out.println(Thread.currentThread().getName() + "充值成功" + account.getMoney());
            lock.unlock();
        }
    
        /**
         * 取款
         */
        public void withdraw(long money) {
            lock.lock();
            long old = account.getMoney();
    
            if (old < money ) {
                System.out.println(Thread.currentThread().getName() + " 余额不足！ 余额：" + old);
            }
    
            if (old - money >= 0) {
                account.setMoney(old - money);
                System.out.println(Thread.currentThread().getName() + " 取款成功 ： " + money + " 余额 ：  " + account.getMoney());
            }
            lock.unlock();
        }
    
    }

结果：

Thread-0充值成功110
    Thread-2充值成功120
    Thread-3充值成功130
    Thread-1充值成功140
    Thread-4充值成功150
    Thread-5充值成功160
    Thread-6充值成功170
    Thread-7充值成功180
    Thread-9充值成功190
    Thread-8充值成功200

结果和我们想要的一样。