5.3 线程安全问题解决方案

最新推荐文章于 2023-06-13 09:45:00 发布

蟑螂恶霸不是恶霸

最新推荐文章于 2023-06-13 09:45:00 发布

阅读量521

点赞数

分类专栏：零基础入门到就业--JAVA篇文章标签： java 开发语言

本文链接：https://blog.csdn.net/whatfuswd/article/details/127698229

版权

零基础入门到就业--JAVA篇专栏收录该内容

224 篇文章 5 订阅

订阅专栏

1.概述

经过前面多线程编程的学习,我们遇到了线程安全的相关问题,比如多线程售票情景下的超卖/重卖现象.
我们如何判断程序有没有可能出现线程安全问题,主要有以下三个条件:

在多线程程序中 + 有共享数据 + 多条语句操作共享数据

多线程的场景和共享数据的条件是改变不了的(就像4个窗口一起卖100张票,这个是业务)
所以思路可以从第3点"多条语句操作共享数据"入手,既然是在这多条语句操作数据过程中出现了问题
那我们可以把有可能出现问题的代码都包裹起来，一次只让一个线程来执行

2.同步和异步

那怎么"把有可能出现问题的代码都包裹起来"呢?我们可以使用synchronized关键字来实现同步效果；

也就是说,当多个对象操作共享数据时,可以使用同步锁解决线程安全问题,被锁住的代码就是同步的；

接下来介绍下同步与异步的概念:

- 同步：体现了排队的效果，同一时刻只能有一个线程独占资源，其他没有权利的线程排队。
- 坏处就是效率会降低，不过保证了安全。
- 异步：体现了多线程抢占资源的效果，线程间互相不等待，互相抢占资源。
- 坏处就是有安全隐患,效率要高一些。

3.synchronized同步关键字

3.1 写法

synchronized (锁对象){
需要同步的代码(也就是可能出现问题的操作共享数据的多条语句);
}

3.2 前提

同步效果的使用有两个前提:

前提1：同步需要两个或者两个以上的线程(单线程无需考虑多线程安全问题)
前提2：多个线程间必须使用同一个锁(我上锁后其他人也能看到这个锁,不然我的锁锁不住其他人,就没有了上锁的效果)

3.3 特点

synchronized同步关键字可以用来修饰代码块,称为同步代码块,使用的锁对象类型任意，但注意：必须唯一！
synchronized同步关键字可以用来修饰方法,称为同步方法
同步的缺点是会降低程序的执行效率，但我们为了保证线程的安全,有些性能是必须要牺牲的
但是为了性能,加锁的范围需要控制好,比如我们不需要给整个商场加锁,试衣间加锁就可以了

为什么同步代码块的锁对象可以是任意的同一个对象,但是同步方法使用的是this呢?
因为同步代码块可以保证同一个时刻只有一个线程进入
但同步方法不可以保证同一时刻只能有一个线程调用,所以使用本类代指对象this来确保同步

在这里插入图片描述

4.练习-改造售票案例-继承Thread

4.1 代码实现

package partFour;
/*设计多线程编程模型，4个窗口购机售票100张
 * 本方案使用多线程编程方案1，继承Thread类的方式来完成*/
public class TestThreatv2 {
    public static void main(String[] args) {
        //5.创建多个线程对象
        TicketsThread2 t1 = new TicketsThread2();
        TicketsThread2 t2= new TicketsThread2();
        TicketsThread2 t3 = new TicketsThread2();
        TicketsThread2 t4 = new TicketsThread2();
        //6.以多线程的方式启动
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
/* 1.多线程中出现数据安全问题的原因：多线程程序+有共享数据+多条语句可操作共享数据*/
/* 2.同步锁：相当于给容易出现问题的代码加了一把锁，加锁以后，这些代码实现同步效果
 * 同步就是排队，需要考虑俩个问题：
 * 1）加锁的范围：不能太大，太大，效率太低，不能太小，太小，锁不住
 * 2）多个线程对象必须是同一把锁，锁对象只有一个，不然锁不住*/
//1.自定义多线程售票类，继承Thread
class TicketsThread2 extends Thread{
    //3.定义变量，保存要卖的票数,需要设置静态，不然4个线程对象每个线程对象都会有100张票
    //4个线程对象每个线程对象售票400张，原因是创建了4次对象，各自操作各自的成员变量
    // 解决：让所有对象共享同一个数据，票数需要设置为静态
    static int tickets = 100;
    /* 创建锁对象，锁对象的类型不做限制，但是得唯一*/
    //Object o = new Object();  //如果是继承，锁对象不要自定义
    //2.重新run方法
    @Override
    public void run(){
        //4.1循环卖票，使用while循环，方便后续演示容易出错的位置
        while (true) {
            /*当前类的字节码对象，这个是肯定唯一的*/
            synchronized (TicketsThread2.class) {
                if(tickets>0){//双重校验，解决超卖
                    //4.2打印当前正在卖票的线程名称，并且票数-1
                    System.out.println(getName() + "=" + tickets--);
                    //4.3做判断，如果没有票了，就退出死循环
                }

                if (tickets <= 0) break;//注意，死循环一定要设置出口
            }
        }
    }
}

4.2 注意事项

如果是继承的方式实现多线程，锁对象最好是“类名.class”
否则创建多个自定义类对象时，拥有多个锁对象，锁不住
可以使用双重校验，在有票的时候再卖票，解决超卖问题

5.练习-改造售票案例-实现Runnable接口

5.1 代码实现

package partFour;
/*需求：设计多线程编程模型，4个窗口共计售票100张
 * 本方案使用多线程编程方案2，实现Runnable接口的方式来完成*/
public class TestRunnablev2 {
    public static void main(String[] args) {
        //5.创建Runnable接口的实现类对象，作为目标业务对象
        TicketsRunnable2 target = new TicketsRunnable2();
        //6.创建多个Thread类线程对象，并将target业务交给多个线程对象来处理
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        //7.以多线程的方式启动多个线程对象
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//1.自定义多线程类实现Runnable接口
class TicketsRunnable2 implements Runnable {
    //3.定义一个成员变量，用来保存票数100
    //由于自定义类对象只创建了一次，所以票数被所有线程对象Thread共享
    //不需要添加static，只卖了100张票，不会卖400次*/
    int tickets = 100;
    Object o = new Object();

    //2.添加接口中未实现的方法，方法里是我们的业务
    @Override
    public void run() {
        //4.1循环卖票
        while (true) {
            //synchronized (TestRunnablev2.class) {//此方法也可以，只要保证唯一即可
            synchronized (o) {
                if (tickets > 0) {
                    //7.让每个线程经历休眠，增加线程状态切换频率与出错的概率
                    //问题1：产生重卖的现象，同一张票卖给多人
                    //问题2：产生了超卖的现象，超出了规定的票数100，出现了0，-1，-2
                    try {
                        Thread.sleep(10);//让当前线程休眠10ms
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //4.2打印当前正在售票的线程名称 & 票数-1
                    System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                    //4.3设置死循环的出口，没票了就停止卖票
                    if (tickets <= 0) break;
                }
            }
        }
    }
}

5.2 注意事项

如果是继承的方式的话,锁对象最好用"类名.class",否则创建自定义线程类多个对象时,无法保证锁的唯一

6.练习-改造售票案例-使用线程池

6.1 代码实现

在这里插入代码片package partFour;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/* 本类用于使用线程池改写售票案例*/
public class TestRunnablevPoolV2 {
    public static void main(String[] args) {
        //1.创建实现类也就是目标业务对象
        TicktRunnablePool2 target = new TicktRunnablePool2();
        //2.使用Excutors创建最多包含5个线程的线程池--ExcutorService
        /*Executors是用来辅助创建线程池的工具类
         * 常用的方法是：newFixedThreadPoo(int)这个方法可以帮我们创建指定书目线程的线程池*/
        ExecutorService pool = Executors.newFixedThreadPool(5);
        //3.使用循环，启动线程
        for(int i=0; i<5; i++){
            /*execute让线程池中的线程来执行业务
             * 每次调用这个方法，都会将一个线程加到就绪队列中
             * 这个方法的参数，就是我们要执行的具体业务，也就是目标业务类对象target*/
            pool.execute(target);
        }
    }
}

//1.创建接口实现类，作为目标业务量
class TicktRunnablePool2 implements Runnable{
    //3.1定义票数
    int tickets = 100;
    //8.注意在外部添加一个唯一的对象，
    Object o = new Object();
    //2.添加父接口中未实现的抽象方法，里面是业务
    @Override
    public void run() {
        //3.2循环卖票
        while (true) {
            /*
             * 8.同步代码块：synchronized(锁对象){会出现安全隐患的所有代码}
             * 同步代码块在同一时刻，同一资源只会被一个线程独享
             * synchronized (new Object()){ 这种写法不对，相当于每个线程进来的时候都会new一个锁对象，线程间使用的并不是同一把锁
             * 修改同步代码块的锁对象为成员变量o,因为锁对象必须唯一
             * synchronized (TicketRunnable2.class) { 这种写法也是可以的
             * */
            synchronized (o){
                //9.双重判断，有票的时候再卖票，解决超卖
                if (tickets>0){
                    //7.为了增加线程状态切换概率与出错频率，在售票前休眠10毫秒
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                System.out.println("窗口" + Thread.currentThread().getName() + "售票" + tickets--);
                if (tickets <= 0) break;
            }
            }
        }
    }
}

6.2 代码分析

使用线程池与同步锁结合的方式，即保证了资源不被浪费，也保证了并发情况下的线程安全问题，在日常开发中，这也是经常被使用的方法；

7.线程锁

7.1 悲观锁和乐观锁

**悲观锁：**像它的名字一样，对于并发间操作产生的线程安全问题持悲观状态.
悲观锁认为竞争总是会发生，因此每次对某资源进行操作时，都会持有一个独占的锁,就像synchronized,不管三七二十一，直接上了锁就操作资源了。

**乐观锁：**还是像它的名字一样，对于并发间操作产生的线程安全问题持乐观状态.
乐观锁认为竞争不总是会发生，因此它不需要持有锁，将”比较-替换”这两个动作作为一个原子操作尝试去修改内存中的变量，如果失败则表示发生冲突，那么就应该有相应的重试逻辑。

7.2 两种常见的锁

7.2.1 synchronized 互斥锁（悲观锁，有罪假设）

采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。
每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。

7.2.2 ReentrantLock 排他锁（悲观锁，有罪假设）

ReentrantLock是排他锁，排他锁在同一时刻仅有一个线程可以进行访问，实际上独占锁是一种相对比较保守的锁策略，在这种情况下任何“读/读”、“读/写”、“写/写”操作都不能同时发生，这在一定程度上降低了吞吐量。然而读操作之间不存在数据竞争问题，如果”读/读”操作能够以共享锁的方式进行，那会进一步提升性能。

7.2.3 ReentrantReadWriteLock 读写锁（乐观锁，无罪假设）

因此引入了ReentrantReadWriteLock，顾名思义，ReentrantReadWriteLock是Reentrant（可重入）Read（读）Write（写）Lock（锁），我们下面称它为读写锁。
读写锁内部又分为读锁和写锁，读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的。
读锁和写锁分离从而提升程序性能，读写锁主要应用于读多写少的场景。

8.使用读写锁改造售票案例

8.1 代码实现

package partFour;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 本类用于改造售票案例,使用可重入读写锁
 * ReentrantReadWriteLock
 * */
public class TestSaleTicketsV3 {
    public static void main(String[] args) {
        SaleTicketsV3 target = new SaleTicketsV3();
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
class SaleTicketsV3 implements Runnable{
    static int tickets = 100;
    //1.定义可重入读写锁对象,静态保证全局唯一
    static ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
    @Override
    public void run() {
        while(true) {
            //2.在操作共享资源前上锁
            lock.writeLock().lock();
            try {
                if(tickets > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                }
                if(tickets <= 0) break;
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                //3.finally{}中释放锁,注意一定要手动释放,防止死锁,否则就独占报错了
                lock.writeLock().unlock();
            }
        }
    }
}

8.2 两种方式的区别

需要注意的是，用sychronized修饰的方法或者语句块在代码执行完之后锁会自动释放，而是用Lock需要我们手动释放锁，所以为了保证锁最终被释放(发生异常情况)，要把互斥区放在try内，释放锁放在finally内！

与互斥锁相比，读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（writer 线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（reader 线程）从理论上讲，与互斥锁定相比，使用读-写锁允许的并发性增强将带来更大的性能提高。

蟑螂恶霸不是恶霸

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
5.3 线程安全问题解决方案

经过前面多线程编程的学习,我们遇到了线程安全的相关问题,比如多线程售票情景下的超卖/重卖现象.在多线程程序中 + 有共享数据 + 多条语句操作共享数据多线程的场景和共享数据的条件是改变不了的(就像4个窗口一起卖100张票,这个是业务)所以思路可以从第3点"多条语句操作共享数据"入手,既然是在这多条语句操作数据过程中出现了问题那我们可以把有可能出现问题的代码都包裹起来，一次只让一个线程来执行。
复制链接

扫一扫