329 - 线程安全问题

哆啦A梦的_梦

已于 2022-10-21 09:16:51 修改

阅读量301

点赞数

分类专栏： JavaSE 文章标签： java

于 2022-10-19 17:04:54 首次发布

本文链接：https://blog.csdn.net/zhoulizhengZ/article/details/127411046

版权

JavaSE 专栏收录该内容

56 篇文章 0 订阅

订阅专栏

线程安全问题 —— 解决方法

关于之前抢火车票的问题：

【1】出现问题：

（1）出现了两个10张票或者3个10张票：

（2）出现0，-1，-2可能：

上面的代码出现问题：出现了重票，错票 ---》 线程安全引起的问题

原因：多个线程，在争抢资源的过程中，导致共享的资源出现问题。一个线程还没执行完，另一个线程就参与进来了，开始争抢。

解决：

在我的程序中，加入“锁” / 加同步 / 同步监视器。

什么是同步代码块？

百度百科;

方法1：同步代码块

【1】同步代码块-演示1：对应 implements Runnable 接口

package test7_safe;

/**
 * @Auther: zhoulz
 * @Description: test7_safe
 * @version: 1.0
 */
public class BuyTicketThread implements Runnable {
    int ticketNum = 10;

    @Override
    public void run() {
        //此处有1000行代码
        for (int i = 1; i <= 100; i++) {
            //加锁
            synchronized (this){//把具有安全隐患的代码锁住即可,(不用把synchronized (this)放到for循环前面）
                         // 如果锁多了就会效率低 --》this就是这个锁
                if(ticketNum > 0){
                    System.out.println("我在"+ Thread.currentThread().getName()+"买到了从北京到哈尔滨的第" + ticketNum-- + "张车票");
                }
            }
        }
        //此处有1000行代码
    }
}

class Test1 {
    public static void main(String[] args) {
        //定义一个线程对象   (只定义一个线程对象即可)
        BuyTicketThread t = new BuyTicketThread();
        //窗口1买票：
        Thread t1 = new Thread(t,"窗口1");
        t1.start();
        //窗口2买票：
        Thread t2 = new Thread(t,"窗口2");
        t2.start();
        //窗口3买票：
        Thread t3 = new Thread(t,"窗口3");
        t3.start();
    }
}

结果：注意：车票都是按顺序10-1买的

【2】同步代码块-演示2：对应 extends Thread 线程类

package test8_safe_2;

/**
 * @Auther: zhoulz
 * @Description: test8_safe_2
 * @version: 1.0
 */
public class BuyTicketThread extends Thread{
    public BuyTicketThread(String name){
        super(name);
    }
    //一共10张票
    static int ticketNum = 10;//加上static：多个对象共享10张票。不然每个对象都有10张票，就是30张票了
    //每个窗口都是一个线程对象：每个对象执行的代码放入run方法中
    @Override
    public void run() {
        //super.run();
        //每个窗口后面有100个人在抢票：
        for (int i = 1; i <= 100 ; i++) {
            synchronized (BuyTicketThread.class){
                //锁必须多个线程用的是同一把锁！！！ 用“ "this" / "abc" ”也可以
                if (ticketNum > 0){
                    System.out.println("我在"+this.getName()+"买到了从北京到哈尔滨的第" + ticketNum-- + "张车票");
                }
            }
        }
    }
}

class Test1 {
    public static void main(String[] args) {
        //多个窗口抢票：三个窗口三个线程对象
        BuyTicketThread t1 = new BuyTicketThread("窗口1");
        t1.start();
        BuyTicketThread t2 = new BuyTicketThread("窗口2");
        t2.start();
        BuyTicketThread t3 = new BuyTicketThread("窗口3");
        t3.start();
    }
}

如果 “锁” 用的是：synchronized (this){}

结果如下： 发现并不是按顺序10-1

把 this 换成字符串 “abc” 或 “this” 等，即：synchronized ("abc"){}

结果如下：发现又正常上锁了

现分析：为什么在 “同步代码块-演示1：对应 implements Runnable 接口” 中用 this 可以正常上锁，而在 “同步代码块-演示2：对应 extends Thread 线程类” 中用 this 却不能够正常上锁？？？

解析如下：

首先，（锁）this 指的是当前这个对象，即：谁调用了这个run()方法，这个this指的就是谁。

然后我们看一下 “同步代码块-演示1：对应 implements Runnable 接口” 中的测试类：

        //定义一个线程对象   (只定义一个线程对象即可)
        BuyTicketThread t = new BuyTicketThread();
        //窗口1买票：
        Thread t1 = new Thread(t,"窗口1");
        t1.start();
        //窗口1买票：
        Thread t2 = new Thread(t,"窗口2");
        t2.start();
        //窗口1买票：
        Thread t3 = new Thread(t,"窗口3");
        t3.start();

在上面的代码中，虽然有线程对象t1、t2、t3，但是在创建他们的时候，用的都是同一个 t ，所以这里面线程对象 实际上就一个 BuyTicketThread t = new BuyTicketThread();，所以线程类下即使调用run()方法，实际上调的就是一个对象的run()方法，所以这个this也就相当于1个（因为：测试类中t1.start()、t2.start()、t2.start()表面上看是调用了3个run()方法）；

而在 “同步代码块-演示2：对应 extends Thread 线程类” 中为什么就不能用this了，因为this 指的是当前调用这个方法的那个对象，而在对应的测试类中：

        //多个窗口抢票：三个窗口三个线程对象
        BuyTicketThread t1 = new BuyTicketThread("窗口1");
        t1.start();
        BuyTicketThread t2 = new BuyTicketThread("窗口2");
        t2.start();
        BuyTicketThread t3 = new BuyTicketThread("窗口3");
        t3.start();

可以看出，分别调用了3次start()方法，其中的 t1、t2、t3 分别对应一个线程对象，即一共有3个线程对象。所以，有3个线程对象的话，用this去锁相当于分别锁住了 t1、t2、t3，即锁住的不是一把锁，故可以总结为：在进行锁的时候，这个锁要是一把。

所以：

在 “同步代码块-演示2：对应 extends Thread 线程类” 中，所有人都是一个锁，都是这个 t 对象，this 锁住的实际上就是 t 对象，锁住的是一把锁，即使后面即使多个线程（如：t1、t2、t3）来，我们看的也是那一把锁；

而在 “同步代码块-演示2：对应 extends Thread 线程类” 中，锁的时候，不同的对象要看不同的锁（如：t1、t2、t3），即this看他当前调的那个锁，所以其他线程来的时候，还是容易引起冲突，因为锁不是统一的。而把 this 换成字符串 “abc”，就又可以正常运行了，因为现在是把“abc”当成一把锁了，所以现在不同的线程只认“abc”，因为“abc”在内存中就一个（因为在字符串常量池中只有一个“abc”），即此时“abc”解决了一把锁的问题。

即明确一点：锁必须多个线程用的是同一把锁！！！ —— 重要

但一般情况下，不会放一个字符串在里面，而是会放它的字节码信息，如当前 线程类的名字是：BuyTicketThread，而对应的字节码信息就是BuyTicketThread.class（实际上用到了反射的东西，后面讲）。此时，放入了BuyTicketThread对应的字节码信息，而对于字节码信息来说，无论你有多少个对象，而类的字节码信息就这一个，所以相当于把这个锁 锁成一个了，即一把锁。

【3】同步监视器-总结：

总结1：认识同步监视器（锁子） ----- synchronized(同步监视器){ }

1) 必须是引用数据类型，不能是基本数据类型；

2) 也可以创建一个专门的同步监视器，没有任何业务含义；

比如：

专门创建：Object o = new Object(); ，然后就把 o 当成一把锁也是可以的。

但是，在直接传入 o 的时候要考虑：o 是一把锁？？？还是多把锁？？？

发现，在“同步代码块-演示2：对应 extends Thread 线程类” 中的测试类中，有t1、t2、t3 三个对象，则对应 o 的属性也有三个，即是有3个锁。

运行结果： 也发现并不是按顺序10-1

针对以上问题，应该怎么把 o 确定为一把锁？？？

解决：用static 修饰即可。（static修饰的属性，在内存中是唯一的，独一份）

此时的锁就变得有含义了，即对应一把锁。

3) 一般使用共享资源做同步监视器即可；

一般，我们不会瞎写一个没有意义的锁作为一个锁( 如上面的 static Object o = new Object(); )。

而是：

我们原来就有一个共享资源 ticketNum，可以用来当锁，但是直接传进去会报错，因为锁必须是引用数据类型，不能是基本数据类型，所以这里最好的就是放入BuyTicketThread.class 作为锁。

4) 在同步代码块中，不能改变同步监视器对象的引用；

如：创建一个字符串类型：String a = "abc"; 然后把 a 传入作为锁也是可以的，原因见上。

但是这里有一个问题：即这个字符串a的值是可以改变的。

如在锁下面进行改变： a = "def"; 这样也是可以的。

但是我们要求：这个锁的对应地址的引用是不可以改变的。而上面a = "def"就属于改变了a对应地址的指向，这样对于锁来说就比较不友好，相当于用的还不是一把锁。（运行结果也不是按10-1顺序的）

如果想用这种方法，怎么办？

想让这个锁能够锁住，或者说让这个地址不能够改变的话，可以在前面加一个final修饰，一旦加了final修饰，里面a的值就不能够更改了。

5) 尽量不要String和包装类Integer做同步监视器；（容易在内部被改变）

6) 建议使用final修饰同步监视器。

上面，为了不能够改变，直接加个final修饰就可以了，final可以锁住其对应的地址不能改变。

但是，其对应的属性值可以改变的：

举例：假如你在 Object o = new Object(); 前面加一个final修饰，则这个Object 对应o的地址就不能改了，但是o的对应的属性值还是可以更改的。即：final只是将地址值锁住了，值不能够更改。但是，地址值里面如果是个对象的话，对象里面的属性值还是可以更改的。

总结2：同步代码块的执行过程

1) 第一个线程来到同步代码块，发现同步监视器open状态，需要close，然后执行其中的代码；

2) 第一个线程执行过程中，发生了线程切换（阻塞就绪），第一个线程失去了cpu，但是没有开锁open；

3) 第二个线程获取了cpu，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态；

4) 第一个线程再次获取CPU，接着执行后续的代码；同步代码块执行完毕，释放锁open；

5) 第二个线程也再次获取cpu，来到了同步代码块，发现同步监视器open状态，拿到锁并且上锁，由阻塞状态进入就绪状态，再进入运行状态，重复第一个线程的处理过程（加锁）。

强调： 同步代码块中能发生CPU（/线程）的切换吗？能！！！

但是后续的被执行的线程也无法执行同步代码块（因为锁仍旧close）

总结3：其他

1) 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块；

即：第一个o锁被锁住，则第二个o锁也被锁住了。

2) 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块（同上），但是没有锁住使用其他同步监视器（锁）的代码块，其他线程有机会访问其他同步监视器（锁）的代码块。

即：o锁被锁住，不会让a锁也被锁住。

方法2：同步方法

【1】代码示例；

代码示例1： ——对应 implements Runnable 接口

package test9_safe_3;

/**
 * @Auther: zhoulz
 * @Description: test7_safe
 * @version: 1.0
 */
public class BuyTicketThread implements Runnable {
    int ticketNum = 10;

    @Override
    public void run() {
        //此处有1000行代码
        for (int i = 1; i <= 100; i++) {
            buyTicket();
        }
        //此处有1000行代码
    }

    //同步方法：
    public synchronized void buyTicket() { //锁住的是this
        if (ticketNum > 0) {
            System.out.println("我在" + Thread.currentThread().getName() + "买到了从北京到哈尔滨的第" + ticketNum-- + "张车票");
        }
    }
}

class Test1 {
    public static void main(String[] args) {
        //定义一个线程对象   (只定义一个线程对象即可)
        BuyTicketThread t = new BuyTicketThread();
        //窗口1买票：
        Thread t1 = new Thread(t,"窗口1");
        t1.start();
        //窗口2买票：
        Thread t2 = new Thread(t,"窗口2");
        t2.start();
        //窗口3买票：
        Thread t3 = new Thread(t,"窗口3");
        t3.start();
    }
}

运行结果 —— 正常。

示例代码2： —— 对应 extends Thread 线程类

package test10_safe2_2;

/**
 * @Auther: zhoulz
 * @Description: test8_safe_2
 * 解决线程安全的第一个方法 —— 同步代码块 ——extends Thread
 * @version: 1.0
 */
public class BuyTicketThread extends Thread{
    //final String a = "abc";
    //static Object o = new Object();
    public BuyTicketThread(String name){
        super(name);
    }
    //一共10张票
    static int ticketNum = 10;

    @Override
    public void run() {
        //super.run();
        //每个窗口后面有100个人在抢票：
        for (int i = 1; i <= 100 ; i++) {
            buyTicket();
            }
        }

    //同步方法：
    public synchronized void buyTicket(){
        if (ticketNum > 0){
            System.out.println("我在"+this.getName()+"买到了从北京到哈尔滨的第" + ticketNum-- + "张车票");
        }
    }

}

class Test1 {
    public static void main(String[] args) {
        //多个窗口抢票：三个窗口三个线程对象
        BuyTicketThread t1 = new BuyTicketThread("窗口1");
        t1.start();
        BuyTicketThread t2 = new BuyTicketThread("窗口2");
        t2.start();
        BuyTicketThread t3 = new BuyTicketThread("窗口3");
        t3.start();
    }
}

运行结果：发现并不是按顺序10-1

原因 ??? —— 实际上还是锁的问题

解析：

在对应 implements Runnable 接口中，测试类下，实际上只有线程对象 t 这一个对象，所以对应封装的方法 buyTicket() 只有一个。在这个封装方法中，synchronized 表面上锁住的是这个方法，而实际上锁住的是你当前调用方法的那个对象，即锁住的是this，所以现在控制的锁依然是一个锁。

而在对应 extends Thread 线程类中，同样的道理，虽然把这个方法锁住了，但对应的测试类下，有 t1、t2、t3 三个线程对象，所以这里锁的时候分别锁的是 t1、t2、t3，锁的其实也是你当前调用方法的那个对象，即锁住的是this，但是问题没有解决。

怎么办？我们想要它（封装的方法？）变成一个，变成统一的。

那就在 synchronized 前面加上一个 static 修饰。

static 修饰的话，那么当前的buyTicket()方法就相当于一个统一的、一个方法了，锁就控制为一个了。所以当前锁住的，其实就相当于把 同步监视器(锁)：BuyTicketThread.class字节码文件 锁住了。

（注：加static 修饰后，下面的代码 this 会报错）

原因：static 代码里，不能有this。

修改：获取线程名字的方法除了 this.getName()，还可以用 Thread.currentThread().getName()

再运行，就正常了。

【2】总结

总结1：

多线程在争抢资源，就要实现线程的同步；

（就要进行加锁，并且这个锁必须是共享的，必须是唯一的。）

咱们的锁一般都是引用数据类型的。

目的：解决了线程安全问题。

总结2：关于同步方法

1) 不要将run()定义为同步方法（这样锁住的东西就太多了，然后效率就太低了）；

2) 非静态同步方法的 同步监视器是 this，

静态同步方法的 同步监视器是类名.class 字节码信息对象；

3) 同步代码块的效率要高于同步方法；

原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却是方法的内部。（注：同步代码块——只将容易出现安全隐患的代码锁住；同步方法——还有可能锁住一些其他的逻辑代码，这样效率就低了）

4) 同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；

同步代码块只是锁住使用 该同步监视器 的代码块，而没有锁住使用其他监视器的代码块。

方法3：Lock锁

【1】Lock锁引入：

JDK1.5后新增新一代的线程同步方式：Lock锁

与采用 synchronized 相比，Lock可提供多种锁方案，更灵活。

synchronized是Java中的关键字，这个关键字的识别是靠JVM来识别完成的。是虚拟机级别的。

但是Lock锁是API级别的，提供了相应的接口和对应的实现类，这个方式更灵活，表现出来的性能优于之前的方式。

【2】代码演示：

package test11_safe3_1_Lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Auther: zhoulz
 * @Description: test7_safe\
 * 解决线程安全的第三个方法 —— Lock
 * @version: 1.0
 */
public class BuyTicketThread implements Runnable {
    int ticketNum = 10;
    //1、拿来一把锁
    //Lock lock = new Lock(); //接口不能直接创建对象
    //多态 ， 接口=实现类  可以使用不同的实现类
    Lock lock = new ReentrantLock(); //可重入锁

    @Override
    public void run() {
        //此处有1000行代码
        for (int i = 1; i <= 100; i++) {
            //2、打开锁;
            lock.lock();

            //为了防止 打开锁、关闭锁 之间的程序(这里是指if语句)出现异常
            //而导致锁无法正常关闭,所以将其中的程序放到try-catch-finally中：
            try {
                if (ticketNum > 0) {
                    System.out.println("我在" + Thread.currentThread().getName() + "买到了从北京到哈尔滨的第" + ticketNum-- + "张车票");
                }
            }catch (Exception ex){
                ex.printStackTrace();
            }finally {
                //3、关闭锁 —— 即使有异常，这个锁也可以得到释放
                lock.unlock();
            }

        }
        //此处有1000行代码
    }

}

class Test1 {
    public static void main(String[] args) {
        //定义一个线程对象   (只定义一个线程对象即可)
        BuyTicketThread t = new BuyTicketThread();
        //窗口1买票：
        Thread t1 = new Thread(t,"窗口1");
        t1.start();
        //窗口2买票：
        Thread t2 = new Thread(t,"窗口2");
        t2.start();
        //窗口3买票：
        Thread t3 = new Thread(t,"窗口3");
        t3.start();
    }
}

【3】 Lock和synchronized的区别

1、Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁；

2、Lock只有代码块锁，synchronized有代码块锁和方法锁；

3、使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）。

【4】优先使用顺序

（Lock 是优于 synchronized 的）

Lock----同步代码块（已经进入了方法体，分配了相应资源）----同步方法（在方法体之外）

线程同步的优缺点

【1】对比

线程安全，效率低；

线程不安全，效率高。

【2】可能造成死锁

死锁

>不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁；

>出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

【3】代码演示：

package test12_DeadLock;

/**
 * @Auther: zhoulz
 * @Description: test12_DeadLock
 * @version: 1.0
 */
public class TestDeadLock implements Runnable{
    public int flag = 1;
    static Object o1 = new Object(), o2 = new Object();

    @Override
    public void run() {
        System.out.println("flag = " + flag);
        //如果flag==1，锁住o1
        if(flag == 1){
            synchronized (o1){
                try {
                    Thread.sleep(2000);
                }catch (Exception ex){
                    ex.printStackTrace();
                }
                //只要锁住o2就完成
                synchronized (o2){
                    System.out.println("666")
                }
            }
        }
        //如果flag==0，锁住o2
        if (flag == 0){
            synchronized (o2){
                try {
                    Thread.sleep(1000);
                }catch (Exception ex){
                    ex.printStackTrace();
                }
                //只要锁住o1就完成
                synchronized (o1){
                    System.out.println("777");
                }
            }
        }
    }

    public static void main(String[] args) {
        //实例2个线程类
        TestDeadLock td1 = new TestDeadLock();
        TestDeadLock td2 = new TestDeadLock();
        td1.flag = 1;
        td1.flag = 0;

        //开启2个线程
        Thread t1 = new Thread(td1);
        Thread t2 = new Thread(td2);
        t1.start();
        t2.start();
    }
}

【4】解决方法：减少同步资源的定义，避免嵌套同步。