多线程下的数据安全

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

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

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进来执行，获取到的余额还是最初的！所以这种并发的程序有一定的风险

例如：这样

我们明明调用了两个线程去执行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是线程安全的