MENU

Java多线程安全问题

February 6, 2020 • Read: 122 • Note,JavaCore

线程的安全问题

案例

需求 :某电影院目前正在上映国产大片,共有100张票,而他有3个窗口卖票,请设计一个程序模拟该电影院卖票

思路

  1. 定义一个类Ticket实现Runnable接口,里面定义一个成员变量:
    private int ticketCount = 100;
  2. 在Ticket类中重写run()方法实现卖票,步骤如下:

    • 判断票数如果大于0,就卖票,并告知哪个窗口购买
    • 票数自动减一
    • 卖光之后,线程停止
  3. 定义一个测试类TicketDemo,步骤如下:

    • 创建Ticket类的对象
    • 创建三个Thread类的对象,把Ticket对象作为构造方法的参数,并给出对应的窗口名称
    • 启动线程

代码实现

public class Ticket implements Runnable {

    private int ticketCount = 100;

    @Override
    public void run() {
        while(true){
            if (ticketCount<=0){
                break;
            }else{
                this.ticketCount -= 1;
                System.out.println(Thread.currentThread().getName()+"正在卖票,还剩有"+this.ticketCount+"张");
            }
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        Thread t1 = new Thread(ticket,"一号窗口");
        Thread t2 = new Thread(ticket,"二号窗口");
        Thread t3 = new Thread(ticket,"三号窗口");
        t1.start();
        t2.start();
        t3.start();
    }
}

卖票案例的思考

看似这个案例没有什么问题,但是在实际生活中,售票时候出票是需要一定的时间的,所以在出售一张票的时候需要一点时间的延迟,接下来就修改卖票程序中的动作,每次出票时间为100毫秒,用sleep()方法实现。

此时出现了问题

  • 相同的票出现了多次
  • 出现的负数的票

为什么出现这个问题(这也是我们判断多线程程序是否会有数据安全问题的标准)

  • 多线程操作共享数据

如果解决多线程安全问题?

  • 基本思想:让程序没有安全问题的环境

实现方法

  • 把多条语句操作共享数据的代码起来,让任意时刻只能有一个先吃执行。

同步代码块

锁多条语句操作共享数据,可以使用同步代码块实现

  • 格式:

synchronized(任意对象){ 多条语句操作共享数据的代码 }

  • 默认情况是打开的,只要有一个线程进去执行代码了,锁就会关闭。
  • 当线程执行完了之后,锁就会自动打开。

同步的好处和弊端

  • 好处:解决了多线程的数据安全问题
  • 弊端:当线程很多时,因为每个线程都会去判断同步上的锁,这是非常浪费资源的,无形中降低了程序的运行效率

下面我们更新一下Ticket类。

public class Ticket implements Runnable {

    private int ticketCount = 100;
    private Object o = new Object();

    @Override
    public void run() {
        while(true){
        
            //锁对象,任意对象就可以.
            //多个线程必须使用同一把锁
            synchronized (o){
                if (ticketCount==0){
                    break;
                }else{
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    this.ticketCount -= 1;
                    System.out.println(Thread.currentThread().getName()+"正在卖票,还剩有"+this.ticketCount+"张");
                }
            }
        }
    }
}

此时的运行结果变得非常自然。

synchronized的锁对象必须是唯一的

同步方法

同步方法:就是把synchronized关键字加到方法上。

  • 格式:

修饰符 synchronized 返回值类型 方法名(方法参数){ }

同步静态方法:就是把synchronized关键词加到静态方法上

  • 格式:

修饰符 static synchronized 返回值类型 方法名(方法参数){ }

主要记住:

  1. 同步方法到底锁对象是什么? this
  2. 同步静态方法的锁对象是什么? 类名.class

同步代码块和同步方法的区别

  • 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码。
  • 同步代码块可以指定锁对象,同步方法不能指定锁对象。

★Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,为了更加清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock

Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作

Lock中提供了获得锁和释放锁的方法

  • void lock() 获得锁
  • void unlock() 释放锁

Lock是接口不能直接实例化,可以采用它的实现类ReentrantLock来实例化

ReentrantLock的构造方法

  • ReentrantLock() 创建一个ReentrantLock的实例

注意:一般释放锁unlock要放入finally中。

下面我们使用Lock来更新一下Ticket类

public class Ticket implements Runnable {

    private int ticketCount = 100;
    
    //锁对象Lock
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            //开启Lock锁
            lock.lock();
            try {
                if (ticketCount == 0) {
                    break;
                } else {
                    Thread.sleep(100);
                    this.ticketCount -= 1;
                    System.out.println(Thread.currentThread().getName() + "正在卖票,还剩有" + this.ticketCount + "张");
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //释放Lock锁
                lock.unlock();
            }
        }
    }
}

死锁

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源,导致这些线程处于等待状态,无法前往执行。

建议:不要写锁的嵌套。


本站所有未注明转载的文章均为原创,并采用CC BY-NV-SA 4.0 授权协议,转载请注明来源。

Last Modified: June 5, 2020
Archives QR Code
QR Code for this page
Tipping QR Code