多线程下的数据安全

多线程下的数据安全

​ 再以后的开发中,我们的项目都是运行在服务器中,而服务器已经将线程的定义,线程对象的创建,线程的启动等,都已经实现完了。我们需要做的就是把编写的程序放到一个多线程的环境下运行!确保这些数据在运行时都是安全的

一、线程存在安全的三个条件

  1. 多线程并发
  2. 有共享数据
  3. 共享数据有修改的行为

只要满足上面三个条件,线程就会存在安全问题

二、线程同步机制

怎么去解决线程安全问题,我们采取线程排队执行来让它不能并发来解决!

这种机制被称为:线程同步机制

线程同步会牺牲一部分效率来保证数据安全,因为数据安全比效率更为重要

三、编程模型

1.同步编程模型

​ 线程t1和线程t2,在t1执行的时候,必须等待t2线程执行结束。或者在t2执行的时候,必须等待t1线程执行结束。两个线程发生了等待关系,这就是同步编程模型,效率较低,同步就是排队执行!

2.异步编程模型

​ 线程t1和线程t2,各自执行,t1不干涉t2,t2不干涉t1。两者互不干扰,不需要进行等待,这种编程模型叫做:异步编程模型,效率较高。异步就是并发

四、线程安全代码示例

模拟两个线程同时对一个账户进行存取款操作

代码示例:

/*
银行账户
 */
public class Account {
    //账户
    private String snoid;
    //余额
    private double balance;

    public Account(String snoid, double balance) {
        this.snoid = snoid;
        this.balance = balance;
    }

    public String getSnoid() {
        return snoid;
    }

    public void setSnoid(String snoid) {
        this.snoid = snoid;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public Account() {
    }
    //取款的构造方法
    public void withdraw(Double money){
        //取款之前的余额
        double before=this.getBalance();
        //取款之后的余额
        double after=before-money;
        //更新余额
        this.setBalance(after);

    }
}

创建一个线程:线程中run方法,一次取5000块钱

public class AccountThread extends Thread{
    //两个线程必须共享一个账户对象
    private Account act;
    //通过构造方法传递过来账户对象
   public AccountThread(Account act){
        this.act=act;
    }

    public void run() {
        //run方法的执行表示取款操作
        double money=5000;
        act.withdraw(money);
        System.out.println(Thread.currentThread().getName()+"账户"+act.getSnoid()+"取款成功,您的当前余额为"+act.getBalance());
        }
    }

测试一下:

public class AccountTest {
    public static void main(String[] args) {
        Account act=new Account("act-1",10000);
        //创建连个线程
        Thread t1=new AccountThread(act);
        Thread t2=new AccountThread(act);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
}
    //如果一个线程执行,但是执行过取款操作,没有执行更新操作
    //这时候,t2进来执行,获取到的余额还是最初的!所以这种并发的程序有一定的风险

例如:这样

idea64_L3uRT3a9a9

我们明明调用了两个线程去执行run方法,应该是一次取5000,第二次应该是0才对。那么现在出现这种情况!说明数据是不安全的

但是这也是有概率,现在我们放大这个概率,让余额在执行更新操作前睡1s,那么就相当于低于个执行的线程,执行完取款操作之后,等了一下第二个线程。那么第二个先读取余额的时候还是读取到的10000,现在无论执行多少次,无论是哪个先执行都是上图中的结果!

五、synchronize同步代码块

​ 那么为了解决上述问题,怎么去实现多个线程执行同步操作呢。只能使用我们上面说的排队了,这里就需要使用到synchronize同步代码块。
** synchronized (){
//线程同步代码块
}**

​ 小括号中的数据必须是线程共享的数据,才能达到多线程排队
​ 需要那几个线程同步就写哪几个线程的共享对象
​ 例如,在这,我们t1对象和t2对象的共享对象就是this

在java中,任何一个对象都有一把锁,其实这把锁就是标记。100个对象100把锁,一个对象一把锁!

代码的执行原理:

​ 1.假设t1和t2线程并发,开始执行一下代码的时候,有一个先后顺序
​ 2.假设t1先执行,遇到了synchronized,这个时候自动找“后面共享对象”的对象锁,
​ 找到之后,并占有这把锁,然后执行同步代码块中的程序,在程序执行过程中是一直占有
​ 这把锁的。指代同步代码块改变,这把锁才会释放
​ 3.假设t1已经占有这把锁,此时t2也遇到synchronized关键字,也会去占用后面共享对象的这把锁。
​ 结果这把锁被t1占有,t2只能在同步代码块中等待t1的结束,直到t1把同步代码块执行结束,t1会归还
​ 这把锁此时t2终于等到这把锁,然后t2占有这把锁,进入同步代码块执行程序

注意:
    共享对象一定选择好,这个共享对象一定是你需要排队执行的这些线程对象所共享的

代码示例:

/*
银行账户
 */
public class Account {
    //账户
    private String snoid;
    //余额
    private double balance;
    public Account(String snoid, double balance) {
        this.snoid = snoid;
        this.balance = balance;
    }
    public String getSnoid() {
        return snoid;
    }
    public void setSnoid(String snoid) {
        this.snoid = snoid;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    public Account() {
    }
    //取款的构造方法
    public void withdraw(Double money){
        //取款之前的余额
        synchronized (this){
        double before=this.getBalance();
        //取款之后的余额
        double after=before-money;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //更新余额
        //如果一个线程执行,但是执行过取款操作,没有执行下面这样的更新
        //这时候,t2进来执行,获取到的余额还是最初的!所以这种并发的程序有一定的风险
        this.setBalance(after);
    }
    }
}

输出:

t1账户act-2取款成功,您的当前余额为5000.0
t2账户act-2取款成功,您的当前余额为0.0

七、存在线程安全的变量

​ java中有三大变量!

  • 实例变量:在堆中
  • 静态变量:在方法区中
  • 局部变量:在栈中

局部变量永远不会存在线程安全问题,因为局部变量在栈中,永远不会共享!

实例变量在堆中,堆只有一个,静态变量在方法区中,方法区也只有一个

堆和方法区都是共享的,所以可能存在线程安全问题!

局部变量以及常量都不会存在线程安全问题,成员变量可能会存在线程安全问题!

如果使用局部变量
建议使用StringBuilder,因为局部变量不存在线程安全问题,选择StringBuilder效率比StringBuffer效率更高!

ArrayList是非线程安全的

Vector是线程安全的

HashMap HashSet是非线程安全的

Hashtable是线程安全的

posted @ 2022-08-03 16:09  星余明  阅读(246)  评论(0编辑  收藏  举报