多线程并发环境下，数据的安全发生的条件？

  • 三个条件：1：多线程并发。2：有共享数据。3：共享数据有修改的行为。满足以上3个条件之后，就会存在线程安全问题。
  • 在开发中项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码都不需要编写。
  • 最重要的是：编写的程序需要放到一个多线程的环境下运行，更需要关注的是这些数据在多线程并发的环境下是否是安全的。

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

  • 不能一上来就使用线程同步机制synchronized，会让程序的执行效率降低，用户体验不好。系统的用户吞吐量降低。在不得已的情况下再选择线程同步机制。
  • 1、尽量使用局部变量代替“实例变量和静态变量”。
  • 2、如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应1个对象，对象不共享，就没有数据安全问题了。）
  • 3、如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制。
  • 线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

异步编程模型：异步就是并发。

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

同步编程模型：同步就是排队。

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

Java中有三大变量线程安全：

  • 实例变量：在堆中，堆只有一个。有共享数据，有可能会有线程安全问题
  • 静态变量：在方法区，方法去只有一个，有共享数据，有可能会有线程安全问题
  • 局部变量：在栈中。一个线程一个栈，不会共享，永远不会有线程安全问题
  • 常量：也不会有线程安全问题

synchronized有三种写法：

第一种：同步代码块灵活:synchronized(){}------>synchronized(线程共享对象){同步代码块;    }
第二种：在实例方法上使用：synchronized 表示共享对象一定是this；并且同步代码块是整个方法体。对象锁：1个对象1把锁
第三种：在静态方法上使用synchronized static void： 表示找类锁。 类锁永远只有1把。就算创建了100个对象，那类锁也只有一把。

// 判断题：doOther方法执行的时候需要等待doSome方法的结束吗？
//不需要，因为doOther()方法没有synchronized
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc = new MyClass();

        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
        t2.start();
    }
}
//编写一个类继承Thread；实现多线程；重写run方法
public class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc){
        this.mc = mc;
    }
    public void run(){
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }
    }
}
public class MyClass {
    //这里有synchronized 线程同步对象锁
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    //这里没有synchronized
    public void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

判断题：

两个方法都有synchronized；

而且共享一个对象mc；对象只有一个，对象锁也只有一个

此时需要等待上一个方法结束，才能执行下一个方法

// 判断题：doOther方法执行的时候需要等待doSome方法的结束吗？
//需要；因为doOther方法上面有synchronized；并且两个方法共享一个对象；
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc = new MyClass();

        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
        t2.start();
    }
}
public class MyClass {
    
    //这里有synchronized;而且共享一个对象mc
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }
    
    //这里也有synchronized;而且共享一个对象mc
    public synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

判断题：

两个方法都有sychronized

但是对象创建两次，而且两个方法没有共享对象

此时不需要发生等待

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
//不需要，因为MyClass对象是两个，两把锁。这里MyClass 创建了两次对象对象不共享
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
        t2.start();
    }
}
public class MyClass {
    //这里有synchronized；但是在对象不共享mc1
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    //这里也有synchronized；但是在对象不共享，这里对象锁是mc2
    public synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

 

判断题：类锁！！！！！！

两个方法都是静态方法：public synchronized static void

属于类锁，无论创建多少对象都只有一个类锁

只有上一个方法执行结束下一个方法才能执行，此时发生等待

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
//需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把。
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
        t2.start();
    }
}
public class MyClass {
    // synchronized出现在静态方法上是找类锁。
    public synchronized static void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }
    public synchronized static void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}