Java多线程 02：线程安全

一、线程安全

1. 在多线程并发的环境下数据存在安全问题的条件
   —— 多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题。

   • 满足以下三个条件之后，就会存在线程安全问题：
     1. 多线程并发
     2. 有共享数据
     3. 共享数据有修改的行为

   ---

2. 解决线程安全问题
   —— 使用线程同步机制：线程同步，实际上就是线程不能并发了，线程必须排队执行，会牺牲一部分效率，但数据安全了。

   • 线程同步涉及两个专业术语：
     1. 异步编程模型 —— 线程并发
        —— 线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。其实就是：多线程并发（效率较高。）
     2. 同步编程模型 —— 线程同步（排队）
        —— 线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型。（效率较低，线程排队执行。）
   • 开发中应该怎么解决线程安全问题
     1. 第一种方案：尽量使用局部变量代替“实例变量和静态变量”。
     2. 第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了。）
     3. 第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制，线程排队，效率较低。

   ---

3. Java中三大变量与线程安全
   —— 实例变量（堆）、 静态变量（方法区） ：可能存在线程安全问题。
   —— 局部变量（栈）、 常量 ：不会存在线程安全问题。

   • 以上三大变量中，局部变量永远不会存在线程安全问题。
     —— 局部变量在栈中，所以局部变量永远都不会共享，所以不存在线程安全问题。
     注：常量也不会有线程安全问题，因为常量带有final修饰，一旦赋值不可更改。
   • 以上三大变量中，实例变量和静态变量可能存在线程安全问题。
     ——堆和方法区都只有一个，而且都是多线程共享的，所以可能存在线程安全问题。

   ---

4. synchronized 关键字
   —— synchronized有三种写法

   • 第一种：同步代码块（灵活）

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

   • 第二种：在实例方法上使用synchronized
     —— 表示共享对象一定是this，并且同步代码块是整个方法体。
   • 第三种：在静态方法上使用synchronized
     —— 表示找类锁，类锁永远只有1把，就算创建了100个对象，那类锁也只有一把。
     注：
对象锁：1个对象1把锁，100个对象100把锁。
类锁：100个对象，也可能只是1把类锁。

5. 死锁
   —— synchronized在开发中最好不要嵌套使用，可能会发生死锁现象， 不会出现异常，不会出现错误，难调试。

   public class DeadLock {
       public static void main(String[] args) {
           Object o1 = new Object();
           Object o2 = new Object();
   
           // t1和t2两个线程共享o1,o2
           Thread t1 = new MyThread1(o1,o2);
           Thread t2 = new MyThread2(o1,o2);
   
           t1.start();
           t2.start();
       }
   }
   
   class MyThread1 extends Thread{
       Object o1;
       Object o2;
       public MyThread1(Object o1,Object o2){
           this.o1 = o1;
           this.o2 = o2;
       }
       public void run(){
           synchronized (o1){
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               synchronized (o2){
   
               }
           }
       }
   }
   
   class MyThread2 extends Thread {
       Object o1;
       Object o2;
       public MyThread2(Object o1,Object o2){
           this.o1 = o1;
           this.o2 = o2;
       }
       public void run(){
           synchronized (o2){
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               synchronized (o1){
   
               }
           }
       }
   }