Java 线程安全

线程安全

　　什么时候数据在多线程并发的环境下会存在安全问题呢？
　　　　三个条件：
　　　　　　条件1：多线程并发。
　　　　　　条件2：有共享数据。
　　　　　　条件3：共享数据有修改的行为。

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

　　怎么解决线程安全问题呢？
　　　　当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？
　　　　　　线程排队执行。（不能并发）。
　　　　　　用排队执行解决线程安全问题。
　　　　　　这种机制被称为：线程同步机制。

　　　　专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。

　　怎么解决线程安全问题呀？
　　　　使用“线程同步机制”。

　　　　线程同步机制的语法是：
            synchronized(){
                // 线程同步代码块。
            }

　　　　线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全
　　　　第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

　　说到线程同步这块，涉及到这两个专业术语：

　　　　异步编程模型：
　　　　　　线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。其实就是：多线程并发（效率较高。）

　　　　　　异步就是并发。

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

　　　　　　同步就是排队。

 

使用线程同步机制，解决线程安全问题

package com.bjpowernode.java.threadsafe2;
/*
银行账户
    使用线程同步机制，解决线程安全问题。
 */
public class Account {
    // 账号
    private String actno;
    // 余额
    private double balance; //实例变量。

    //对象
    Object obj = new Object(); // 实例变量。（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。）

    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){

        //int i = 100;
        //i = 101;

        // 以下这几行代码必须是线程排队的，不能并发。
        // 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
        /*
        线程同步机制的语法是：
            synchronized(){
                // 线程同步代码块。
            }
            synchronized后面小括号中传的这个“数据”是相当关键的。
            这个数据必须是多线程共享的数据。才能达到多线程排队。

            ()中写什么？
                那要看你想让哪些线程同步。
                假设t1、t2、t3、t4、t5，有5个线程，
                你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办？
                你一定要在()中写一个t1 t2 t3共享的对象。而这个
                对象对于t4 t5来说不是共享的。

            这里的共享对象是：账户对象。
            账户对象是共享的，那么this就是账户对象吧！！！
            不一定是this，这里只要是多线程共享的那个对象就行。

            在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记。（只是把它叫做锁。）
            100个对象，100把锁。1个对象1把锁。

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

                这样就达到了线程排队执行。
                这里需要注意的是：这个共享对象一定要选好了。这个共享对象一定是你需要排队
                执行的这些线程对象所共享的。
         */
        //Object obj2 = new Object();
        synchronized (this){
        //synchronized (obj) {
        //synchronized ("abc") { // "abc"在字符串常量池当中。
        //synchronized (null) { // 报错：空指针。
        //synchronized (obj2) { // 这样编写就不安全了。因为obj2不是共享对象。
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        //}
    }
}

package com.bjpowernode.java.threadsafe2;

public class AccountThread extends Thread {

    // 两个线程必须共享同一个账户对象。
    private Account act;

    // 通过构造方法传递过来账户对象
    public AccountThread(Account act) {
        this.act = act;
    }

    public void run(){
        // run方法的执行表示取款操作。
        // 假设取款5000
        double money = 5000;
        // 取款
        // 多线程并发执行这个方法。
        //synchronized (this) { //这里的this是AccountThread对象，这个对象不共享！
        synchronized (act) { // 这种方式也可以，只不过扩大了同步的范围，效率更低了。
            act.withdraw(money);
        }

        System.out.println(Thread.currentThread().getName() + "对"+act.getActno()+"取款"+money+"成功，余额" + act.getBalance());
    }
}

package com.bjpowernode.java.threadsafe2;

public class Test {
    public static void main(String[] args) {
        // 创建账户对象（只创建1个）
        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();
    }
}

　　Java中有三大变量？【重要的内容。】

　　　　实例变量：在堆中。

　　　　静态变量：在方法区。

　　　　局部变量：在栈中。

　　　　以上三大变量中：
　　　　　　局部变量永远都不会存在线程安全问题。
　　　　　　因为局部变量不共享。（一个线程一个栈。）
　　　　　　局部变量在栈中。所以局部变量永远都不会共享。

　　　　　　实例变量在堆中，堆只有1个。
　　　　　　静态变量在方法区中，方法区只有1个。
　　　　　　堆和方法区都是多线程共享的，所以可能存在线程安全问题。

　　　　　　局部变量+常量：不会有线程安全问题。
　　　　　　成员变量：可能会有线程安全问题。

 

　　在实例方法上可以使用synchronized吗？可以的。
　　　　synchronized出现在实例方法上，一定锁的是this。
　　　　没得挑。只能是this。不能是其他的对象了。
　　　　所以这种方式不灵活。

　　　　另外还有一个缺点：synchronized出现在实例方法上，
　　　　　　表示整个方法体都需要同步，可能会无故扩大同步的
　　　　　　范围，导致程序的执行效率降低。所以这种方式不常用。

　　　　synchronized使用在实例方法上有什么优点？
　　　　　　代码写的少了。节俭了。

　　　　如果共享的对象就是this，并且需要同步的代码块是整个方法体，
　　　　建议使用这种方式。

 

总结：
　　synchronized有三种写法：

　　第一种：同步代码块
　　灵活
　　　　synchronized(线程共享对象){
　　　　　　同步代码块;
　　　　}

　　第二种：在实例方法上使用synchronized
　　　　表示共享对象一定是this
　　　　并且同步代码块是整个方法体。

　　第三种：在静态方法上使用synchronized
　　　　表示找类锁。
　　　　类锁永远只有1把。
　　　　就算创建了100个对象，那类锁也只有一把。

　　　　对象锁：1个对象1把锁，100个对象100把锁。
　　　　类锁：100个对象，也可能只是1把类锁。

 

我们以后开发中应该怎么解决线程安全问题？

　　是一上来就选择线程同步吗？synchronized
　　　　不是，synchronized会让程序的执行效率降低，用户体验不好。
　　　　系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择
　　　　线程同步机制。

　　第一种方案：尽量使用局部变量代替“实例变量和静态变量”。

　　第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样
　　　　实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，
　　　　对象不共享，就没有数据安全问题了。）

　　第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候
　　　　就只能选择synchronized了。线程同步机制。