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

一、什么时候数据在多线程并发的环境下会存在安全问题？

三个条件：

• 条件1：多线程并发。
• 条件2：有共享数据。
• 条件3：共享数据有修改的行为。

满足以上3个条件之后，就会存在线程安全问题。

二、怎么解决线程安全问题？

        线程排队执行。（不能并发）。用排队执行解决线程安全问题。这种机制被称为：线程同步机制。

三、银行 取钱/存钱 案例

account 类

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);
    }
}

accountthread 类

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());
    }
}

test 类

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();
    }
}

 运行问题

 解决方法  修改 account 类  中的 withdraw 方法

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);
        }
    }
}

为什么会出现线程安全问题

计算机系统资源分配的单位为进程，同一个进程中允许多个线程并发执行，并且多个线程会共享进程范围内的资源：例如内存地址。当多个线程并发访问同一个内存地址并且内存地址保存的值是可变的时候可能会发生线程安全问题，因此需要内存数据共享机制来保证线程安全问题。

对应到java服务来说，在虚拟中的共享内存地址是java的堆内存,比如以下程序中线程安全问题：

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");
        }

    }
}

创建100个task，每个task对map中的元素累加100此，程序执行结果为：

{count=9846}

而预期的正确结果为：

{count=10000}

至于出现这种问题的原因，下面会具体分析。

判断是否有线程安全性的一个原则是：

是否有多线程访问可变的共享变量

四、总结

• 一个对象一把锁
• 线程拿到锁才能执行同步代码块代码

到此这篇关于java中线程安全问题的文章就介绍到这了,更多相关ava线程安全问题内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！