关于java中线程安全问题详解

目录

• 一、什么时候数据在多线程并发的环境下会存在安全问题？
• 二、怎么解决线程安全问题？
• 三、银行 取钱/存钱 案例
• 为什么会出现线程安全问题
• 四、总结

package ThreadSafa;
/*
银行账户
 */
public class Account {
    // 账号
    private String actno;
    // 余额
    private double balance;
    public Account() {
    }
    public Account(String actno, double balance) {
        this.actno = actno;
        this.balance = balance;
    }
    public String getActno() {
        return actno;
    }
    public void setActno(String actno) {
        this.actno = actno;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    //取款方法
    public void withdraw(double money) {
        // 取款之前的余额
        double before = this.getBalance();
        // 取款之后的余额
        double after = before - money;
        // 更新余额
        try {
            //模拟网络延时 更新余额不及时 百分百会出问题
            Thread.sleep(1 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setBalance(after);
    }
}

package ThreadSafa;
public class AccountThread extends Thread {
    // 两个线程必须共享同一个账户对象。
    private Account act;
    //通过构造方法传递过来账户对象
    public AccountThread(Account act) {
        this.act = act;
    }
    @Override
    public void run() {
        double money = 5000;
        //取款
        act.withdraw(5000);
        System.out.println(Thread.currentThread().getName() + "账户" + act.getActno() + "取款成功，余额" + act.getBalance());
    }
}

package ThreadSafa;
public class Test {
    public static void main(String[] args) {
        // 创建账户对象
        Account act = new Account("act-001", 10000);
        //创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);
        //设置name
        t1.setName("t1");
        t2.setName("t2");
        //启动线程
        t1.start();
        t2.start();
    }
}

package ThreadSafa;
/*
银行账户
 */
public class Account {
    // 账号
    private String actno;
    // 余额
    private double balance;
    public Account() {
    }
    public Account(String actno, double balance) {
        this.actno = actno;
        this.balance = balance;
    }
    public String getActno() {
        return actno;
    }
    public void setActno(String actno) {
        this.actno = actno;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    //取款方法
    public void withdraw(double money) {
        // 以下这几行代码必须是线程排队的，不能并发
        // 一个线程把这里的代码全部执行结束之后，另外一个线程才能进来
        /*
        线程同步机制的语法是：
            synchronized (){
                // 线程同步代码块
            }
            synchronized后面小括号中的这个“数据”是相当关键的。
            这个数据必须是多线程共享的数据。才能达到多线程排队
            ()中写什么？
                那要看你想让那些线程同步。
                假设t1、t2、t3、t4、t5，有5个线程，
                你只希望t1 t2 t3排队，t4 t5 不需要排队。怎么办？
                你一定要在()中写一个t1 t2 t3共享的对象。而这个
                对象对于t4 t5来说不是共享的。
             这里的共享对象是：账户对象
             账户对象是共享的，那么this就是账户对象吧！！！
             不一定是 this ，这里只要是多线程共享的那个对象就行。
         */
        synchronized (this) {
            // 取款之前的余额
            double before = this.getBalance();
            // 取款之后的余额
            double after = before - money;
            // 更新余额
            try {
                //模拟网络延时 更新余额不及时 百分百会出问题
                Thread.sleep(1 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }
    }
}

public class ThreadUnsafeDemo {
    private static final ExecutorService EXECUTOR_SERVICE;
    static {
        EXECUTOR_SERVICE = new ThreadPoolExecutor(100, 100, 1000 * 10,
                TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(100), new ThreadFactory() {
            private AtomicLong atomicLong = new AtomicLong(1);
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "Thread-Safe-Thread-" + atomicLong.getAndIncrement());
            }
        });
    }
    public static void main(String[] args) throws Exception {
        Map<String, Integer> params = new HashMap<>();
        List<Future> futureList = new ArrayList<>(100);
        for (int i = 0; i < 100; i++) {
            futureList.add(EXECUTOR_SERVICE.submit(new CacheOpTask(params)));
        }
        for (Future future : futureList) {
            System.out.println("Future result:" + future.get());
        }
        System.out.println(params);
    }
    private static class CacheOpTask implements Callable<Integer> {
        private Map<String, Integer> params;
        CacheOpTask(Map<String, Integer> params) {
            this.params = params;
        }
        @Override
        public Integer call() {
            for (int i = 0; i < 100; i++) {
                int count = params.getOrDefault("count", 0);
                params.put("count", ++count);
            }
            return params.get("count");
        }
    }
}

{count=9846}

{count=10000}