Day21-3.线程安全问题

1 线程安全问题

1. 其中一个线程在操作某一个数据的时候，这个数据可能也在被另外一条线程操作，就造 成多个线程同时在操操作同一个数据，碰到这种情况，此数据就有可能出现错误问题。
2. 出现问题原因：
   没有保证代码的完整性、一致性

1.1 同步代码块

1. 同步代码块：使用同步代码块括起来的代码，可以保证代码的完整性和一致性、原子性
2. 格式：

synchronized(锁对象){
    需要保证完整性的代码。
}

3. 原理：
   cpu执行带着锁的线程时，该线程需要先获取锁对象，获取到锁对象之后cpu才 能执行，保证同步的代码不执行结束，该线程就不会释放锁对象，同步代码执行完成之 后才会释放锁对象。
4. 问题：
   如何提供锁对象？
   如果两个线程需要互不影响，两个线程应该使用同一个锁对象
   因为一个类型只加载一次，所以类的字节码对象只有一个类名.class，所以使用类名.class能直接保证锁对象的唯一

代码

package demos3;

public class Demo02 {
    public static void main(String[] args) {

        Print p = new Print();
        Print p2 = new Print();

        Thread t1 = new Thread(){
            public void run(){
                while(true){
                    p.print1();
                }
            }
        };

        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    p2.print2();
                }
            }
        };

        t1.start();
        t2.start();
    }
}

class Print{
    //线程1执行
    public void print1(){
        //cpu执行线程1，需要先获取锁对象o
        //获取o对象之后，才可以往下执行后续的代码
        //当保证同步的代码执行结束之后，线程1会释放锁对象
        synchronized (Print.class){
            System.out.print("你");
            System.out.print("好");
            System.out.print("吗");
 
        }

    }
    //线程2
    public void print2(){
        //cpu开始执行线程2，需要先获取锁对象
        //如果cpu不能获取o对象，就不能往下执行
        //如果cpu能获取到o对象，可以往下执行代码
        synchronized (Print.class){
            System.out.print("不");
            System.out.print("是");
        }
    }
}

1.2 同步方法

1. 概念：如果一个方法中的所有内容都需要保持同步，可以使用同步方法来代替同步代码 块以达到简化代码的操作。
2. 格式：
   修饰符 synchronized 返回值类型 方法名称(){
   }
3. 如果定义的同步方法是一个非静态方法，那么该方法默认的锁对象就是：this
4. 如果定义的方法是一个静态方法，默认的锁对象为：该类的字节码对象：类名.class

代码

package demos3;

public class Demo03 {
    public static void main(String[] args) {
        Print2 p = new Print2();
        Print2 p2 = new Print2();
        Thread t1 = new Thread(){
            public void run(){
                while(true){
                    p.print1();
                }
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    p2.print2();
                }
            }
        };

        t1.start();
        t2.start();
    }
}
class Print2{
    //线程1执行
    //使用同步synchronized 关键字修饰的方法，默认是一个同步方法
    //如果方法是一个同步方法，方法中的所有内容默认保证同步
//    public  synchronized void print1(){//锁对象：this
    public static synchronized void print1(){//锁对象：Print2.class
             System.out.print("你");
            System.out.print("好");
            System.out.print("吗");

    }
    //线程2
//    public  synchronized void print2(){//锁对象：this
    public static synchronized void print2(){//锁对象：Print2.class
            System.out.print("不");
            System.out.print("是");
    }
}