详解线程的安全问题

一、问题的提出：
1.多个线程执行的不确定性引起执行结果的不稳定。
2。多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
二、线程安全问题举例：
1.在详解线程的创建一问中遗留的卖票问题。
（1）问题：卖票过程中，出现了重票、错票---->出现了线程的安全问题
（2）问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其它线程参与进来，也操作数据。
（3）解决方法：当一个线程在操作ticket的时候，其它线程不能参与进来。直到该线程操作完ticket时，其它线程才能操作ticket。这种情况即使该线程出现了阻塞，其它线程也不能参与进来。
（4）在Java中，通过同步机制，来解决线程的安全问题。
方法1.1：同步代码块实现Runnable的线程安全问题

synchronized(//同步监视器){
//需要被同步的代码
}
说明：1⃣️操作共享数据的代码即为需要被同步的代码。不能包含代码多了，也不能包含代码少了。
2⃣️共享数据：多个线程共同操作的变量。比如：本例子中的ticket
3⃣️同步监视器，俗称：锁。任何一个类的对象，都可以来充当锁。要求：多个线程必须要共用同一把锁。
4⃣️补充：在实现Runnable接口创建多线程的方式中，可以考虑使用this充当同步监视器。

public class WindowTest1 {
    public static void main(String[] args){
        Window1 w=new Window1();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        t1.start();
        t2.start();
        t3.start();
    }
}
class Window1 implements Runnable{
    private static int ticket=100;
    Object obj=new Object();
    @Override
    public void run() {
    //Object obj=new Object();不可以放在这里，因为此时每个线程不是共用一把锁的。
        while (true){
            synchronized (obj) {
                if (ticket>0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

方法1.2：同步代码块处理Thread类的线程安全问题
说明：在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。即当前类名.class

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

        Window t1=new Window();
        Window t2=new Window();
        Window t3=new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

class Window extends Thread{
    private static int ticket=100;

    static Object obj=new Object();//使得所有线程使用同一个对象

    @Override
    public void run() {
        while (true){
            synchronized (obj){//也可以写成synchronized (Window.class)
                if (ticket>0){
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName()+":卖票，票号为："+ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}

方法2.1:同步方法处理实现Runnable的线程安全问题
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

public class WindowTest2 {
    public static void main(String[] args){
        Window1 w=new Window1();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        t1.start();
        t2.start();
        t3.start();
    }
}
class Window1 implements Runnable{
    private static int ticket=100;

    @Override
    public void run() {
        while (true){
            show();
        }
    }

    private synchronized void show(){
        if (ticket>0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
    }
}

方法2.2:同步方法处理继承Thread类的线程安全问题

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

        Window t1=new Window();
        Window t2=new Window();
        Window t3=new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

class Window extends Thread{
    private static int ticket=100;

    @Override
    public void run() {
        while (true){
            show();
        }
    }

    private static synchronized void show(){
        if (ticket>0){
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
            ticket--;
        }
    }
}

方法三：Lock锁

Lock锁方式解决线程安全问题

（5）同步的方式，解决了线程的安全问题。—>好处。
操作同步代码时，只能有一个线程参与，其它线程等待，相当于是一个单线程的过程。—>局限性。
（6）关于同步方法的总结：
1⃣️同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2⃣️非静态的同步方法，同步监视器是：this
3⃣️静态的同步方法，同步监视器是：当前类本身