线程安全以及线程同步synchronized

系统管理员 2022-09-04 02:46 54阅读 0赞

项目放在服务器中，而服务器已经将线程的定义、线程对象的创建，线程的启动等都已经实现了，这些代码我们不需要编写。

**最重要的是：**编写的程序需要放到一个多线程的环境中，这些数据在多线程并发的环境下是否是安全的。

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

**要满足三个条件：**

**（1）多线程并发  
（2）有共享数据  
（3）共享数据有修改行为**

**满足上边条件会存在线程安全问题。**

# **2、如何解决** #

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

#    **3、两个术语** #

**（1）异步编程模型**

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

**（2）同步编程模型**

线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，两个线程发生等待关系，这就是同步编程模型。

# **4、线程同步机制** #

**如果不使用线程同步有可能带来的问题：**

一个银行取款的问题，假设有2个人a和b同时取一张银行卡中的1万块钱，两个操作是同步的，此时会有一定概率出现a和b同时取款，查询余额时都是1万元，a取完5000，此时需要把剩余金额更新到数据库，假设网络不太好，延时了，数据库金额还是1万元，这时b也取了5000，之后，会造成余额还有5000，因为a取完钱之后，更新剩余金额的操作延时了！

模拟下：

多个线程共享同一个对象，多个线程同时执行时，我用sleep模拟出现上边的问题

// ATM机
    public class Account {
        // 余额1万元
        private Integer draw = 10000;
        // 更新余额的方法
        public void update(Integer endBalance) {
            this.draw = endBalance;
        }
        // 取款+更新余额 功能
        public void withDraw(Integer money) {
            // 取款 - t1和t2线程会同时取款
            Integer endBalance = this.balance() - money;
            // 更新余额
            // 有可能更新余额有延时或者网络异常，下边使用sleep模拟延时
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.update(endBalance);
        }
        // 查看余额功能
        public Integer balance() {
            return this.draw;
        }
    }

public class Lv20210810 {
        public static void main(String[] args) {
            // 创建多个线程（相当于a和b同时在取款）
            MyTread t1 = new MyTread();
            MyTread t2 = new MyTread();
            // 创建Account对象
            Account account = new Account();
            t1.setAccount(account);
            t2.setAccount(account);
            // 线程设置名称
            t1.setName("t1");
            t2.setName("t2");
            t1.start();
            t2.start();
        }
    }
    class MyTread extends Thread {
        // 多个线程共享同一个对象
        public Account account;
        // 设置Account对象
        public void setAccount(Account ac) {
            this.account = ac;
        }
        // 取款操作
        @Override
        public void run() {
            Integer money = 5000;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 取款 - 假设每个线程都取5000元（多线程并发执行这个方法）
            this.account.withDraw(money);
            // 查询余额
            Integer seeBalance = this.account.balance();
            // 打印当前线程及余额
            System.out.println(Thread.currentThread().getName()+":线程取款5000，余额为"+seeBalance);
        }
    }

![2021081013203564.png][]

看到结果，银行要亏死！

# **5、解决上边问题，可以使用同步线程 - **synchronized #

**排它锁**

只能排队执行，不能并发执行（可以理解为阻塞状态）

**（1）synchronized** **语法**：

> synchronized() \{  
>         // 线程同步代码  
> \}

小括号传的是多线程共享的数据对象，假设t1、t2、t3、t4有四个线程，如果希望t1和t2需要排队执行，那么在小括号里就填写t1和t2线程的共享对象即可。

// ATM机
    public class Account {
        private Integer draw = 10000;
        public void update(Integer endBalance) {
            this.draw = endBalance;
        }
    
        // 取款+更新余额 功能
        public void withDraw(Integer money) {
            // this 就是的共享对象，小括号不一定是this，只要是共享对象就行
            synchronized (this) {
                // 取款 - t1和t2线程会同时取款
                Integer endBalance = this.balance() - money;
                // 更新余额
                this.update(endBalance);
            }
        }
        // 查看余额功能
        public Integer balance() {
            return this.draw;
        }
    }

（2）java语言中，任何一个对象都一把锁（就是一个标记而已，只是把它叫做锁），一百个对象100把锁，上边代码执行原理：

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

可以理解为洗手间只有一个蹲坑，2个人不能同时上厕所，一个人进去了，把门锁上了，下个人只能等到这个人结束之后才能进去。

这样就达到了线程排队执行。

这里注意的是：**共享对象**一定要选好了，这个**共享对象**一定是要需要排队执行的那些线程的**共享对象**！！！

# **6、\*\*\* 哪些对象有线程安全问题  \*\*\*** #

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*重要\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

java中三大变量

（1）实例变量：存在堆中，而多线程中方法区和堆是共享的！

（2）静态变量：存在方法区中。

（3）局部变量：存在栈中。

**以上变量只有局部变量是线程安全的，因为它存在于栈中，多线程时，一个线程一个栈。**

#  #

# **7、线程同步一般是来保护实例变量或者静态变量** #

局部变量和常量都不会有线程安全问题。

# **8、** #

如果synchronized出现在实例方法上，那么锁的是当前的this，也就是当前的对象，整个实例方法都需要同步，可能会无故扩大同步的范围，效率较低。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70][]

看下StringBuffer源码：

实例方法上都有 synchronized 关键字。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70 1][]

**如果当前方法中有局部变量，那么建议使用StringBuilder，因为局部变量不存在线程安全的问题，没必要使用StringBuffer！**

ArrayList是非线程安全的，Vector是线程安全的；HashMap、HashSet是非线程安全的，HashTable是线程安全的。

HashTable源码  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70 2][]

#    **9、总结** #

synchronized 三种写法：

**（1）同步代码块，灵活**

synchronized(线程共享对象) \{  
        // 同步代码块  
\}

**（2）在实例方法上使用synchronized**

表示共享的对象是this，并且同步的是整个实例方法。

**（3）在静态变量上使用 synchronized**

表示找类锁，类锁永远只有一把，就算创建100个对象，类锁也只有一把。

# **面试题** #

**（1）当执行doAny方法时，是否要等到doSome方法执行完（要等5秒钟才能够执行doAny方法）？**

先来屡下代码，很简单，刚开始先new了一个共享对象Obj，创建2个线程，然后给线程设置名称t1和t2，开始执行，执行顺序，在t1和t2中间加了sleep保证t1先执行，t2后执行。  
在MyThread类的run方法中判断当前线程名是否是t1，如果是会调用Obj类中的doSome方法执行，如果不是，才会调用Obj类中的doAny方法。  
在Obj类中的doSome实例方法上加上**synchronized** 关键字，doAny上没加。

理解**synchronized** 关键字的，都知道**synchronized** 在实例方法上，它锁的是this，也就是当前的对象，当执行doSome方法时，它会拿到当前对象锁，然后执行代码，一定会同步执行；但是执行doAny方法，不需要当前对象锁啊，因为方法上没有**synchronized** 关键字，所以，**doAny方法的执行是不需要等待的！！！**

public class Lv20210810 {
        public static void main(String[] args) {
            Obj obj = new Obj();
            MyTread t1 = new MyTread(obj);
            MyTread t2 = new MyTread(obj);
            t1.setName("t1");
            t2.setName("t2");
            // 下边为了保证t1先执行，加了一个sleep
            t1.start();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t2.start();
        }
    }
    class MyTread extends Thread {
        public Obj obj;
        public MyTread(Obj obj) {
            this.obj = obj;
        }
        @Override
        public void run() {
            if(Thread.currentThread().getName().equals("t1")) {
                obj.doSome();
            }else {
                obj.doAny();
            }
        }
    }
    // 共享对象Obj
    class Obj {
        // dosome方法加了synchronized
        public synchronized void doSome() {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("doSome执行了:"+i);
            }
        }
        // doAny方法没加synchronized
        public void doAny() {
            System.out.println("doAny方法执行了");
        }
    }

（2）

把doAny方法上加上了 **synchronized** 关键字，此时，执行doAny方法时，是需要等待doSome方法执行完后，才能执行的！因为 在执行doAny方法时，它要找线程共享对象的锁，但是，找不到，因为之前doSome方法没执行完，对象锁没有释放。

class Obj {
        // dosome方法加了synchronized
        public synchronized void doSome() {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("doSome执行了:"+i);
            }
        }
        // doAny方法没加synchronized
        public synchronized void doAny() {
            System.out.println("doAny方法执行了");
        }
    }

（3）在类上添加也同样的道理，类锁只有一个，所以需要等待。

[2021081013203564.png]: /images/20220829/89d4f228899148448b97ca3caf6dd7ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70]: /images/20220829/11ccc177ebe34372a7a204f936dcaaab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70 1]: /images/20220829/23db00493dc54f35af176460261b9b49.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70 2]: /images/20220829/1182f4f9ad2a4751a94bf2854d8a6d4e.png