实现线程安全的对比：有锁、无锁

红太狼 2022-12-06 01:25 140阅读 0赞

### 1、引出 ###

问题提出：编写代码，实现account.withdraw取款方法的线程安全

### 2、代码实现 ###

import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class TestAccount {
        
        public static void main(String[] args) {
        
            AccountUnsafe accountUnsafe = new AccountUnsafe(10000);
            Account.demo(accountUnsafe);
    
            AccountCas accountCas = new AccountCas(10000);
            Account.demo(accountCas);
        }
    }
    
    /**
     * 无锁实现
     */
    class AccountCas implements Account{
        
        private AtomicInteger balance;
    
        public AccountCas(Integer balance) {
        
            this.balance = new AtomicInteger(balance);
        }
    
        @Override
        public Integer getBalance() {
        
            return balance.get();
        }
    
        @Override
        public void withdraw(Integer amount) {
        
            while(true){
        
                //获取余额的最新值
                int prev = balance.get();
                //要修改的值
                int next = prev - amount;
                //真正的修改
                if(balance.compareAndSet(prev,next)){
        
                    break;
                }
            }
        }
    }
    
    /**
     * 有锁实现
     */
    class AccountUnsafe implements Account{
        
        private Integer balance;
    
        public AccountUnsafe(Integer balance) {
        
            this.balance = balance;
        }
    
        @Override
        public Integer getBalance() {
        
            synchronized (this){
        
                return balance;
            }
        }
    
        @Override
        public void withdraw(Integer amount) {
        
            synchronized (this){
        
                balance -= amount;
            }
        }
    }
    
    interface Account{
        
        //获取余额
        Integer getBalance();
    
        //取款
        void withdraw(Integer amount);
    
        /**
         * 方法会自动启动1000个线程，每个线程做-10元的操作
         * 如果初始余额为10000，那么结果应该为0
         * @param account
         */
        static void demo(Account account){
        
            List<Thread> ts = new ArrayList<>();
            for (int i = 0; i < 1000; i++) {
        
                ts.add(new Thread(() -> {
        
                    account.withdraw(10);
                }));
            }
            long start = System.nanoTime();
            ts.forEach(Thread :: start);
            ts.forEach(t -> {
        
                try {
        
                    t.join();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
            long end = System.nanoTime();
            System.out.println(account.getBalance() + " cost: " + (end - start)/1000000 + "ms");
        }
    }

结果输出：

0 cost: 136ms
    0 cost: 114ms	//无锁实现，会提升效率