多线程--05--线程安全问题---售票模型--synchronized--Lock锁

已于 2023-11-20 11:06:19 修改
阅读量489 收藏 4
点赞数
分类专栏： 多线程高并发 文章标签： java rust
于 2020-11-13 15:29:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48052161/article/details/109639358
版权

文章目录

线程同步

多个线程有共享数据,才会有可能出现线程安全问题
在这里插入图片描述

售票模型：

业务分析:

创建三个窗口卖票，总票数为100张.用多线程的程序设计并写出代码。

方式一: 使用继承Thread类

class Window extends Thread{


    private static int ticket = 100;
    @Override
    public void run() {

        while(true){

            if(ticket > 0){
                System.out.println(getName() + "：卖票，票号为：" + ticket);
                ticket--;
            }else{
                break;
            }

        }

    }
}

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();

    }
}

存在线程的安全问题，产生重卖，同一张票卖给多人。

在这里插入图片描述

方式二: 使用实现Runnable接口

class Window1 implements Runnable{

    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}


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("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

}

存在线程的安全问题，产生超卖，0张、-1张

在这里插入图片描述

加上sleep()只是测试上大程序出错概率,不加sleep()同样存在重买和超卖问题

出错原因:

  • 当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。

在这里插入图片描述

重卖:

在这里插入图片描述

  1. 首先t1 执行run方法,执行完sout( ) 时,控制台输出票号100,这是线程t1开始阻塞.还未来的及执行ticket–
  2. 这时t2 抢到了时间片, 也开始执行sout(),因为之前线程t1,并没有执行ticket–操作,
  3. 所以此时t2,执行到sout( ) 时方法,ticket还是 等于100的.
  4. 所以最后t2 在控制台输出的票号也是 100.

超卖:

在这里插入图片描述

解决线程的安全问题- - -synchronized

  • 当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

处理方式:

  • 方式一：同步代码块
  • 方式二：同步方法。

异常会释放锁资源

一般情况异常会释放锁资源

方式一：同步代码块

synchronized(同步监视器){

//需要被同步的代码

}

说明：

  1. 操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。
  2. 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
  3. 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

要求：多个线程必须要共用同一把锁。

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

案例1：实现Runnable接口

class Window1 implements Runnable{

    private int ticket = 100;
//    Object obj = new Object();
//    Dog dog = new Dog();

    @Override
    public void run() {

        while(true){
            synchronized (this){//此时的this:唯一的Window1的对象   //方式二：synchronized (dog) {

                if (ticket > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);


                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}


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("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

}


class Dog{

}

案例2：继承Thread类

class Window2 extends Thread{


    private static int ticket = 100;

    private static Object obj = new Object();

    @Override
    public void run() {

        while(true){
            //正确的
//            synchronized (obj){
            synchronized (Window2.class){//Class clazz = Window2.class,Window2.class只会加载一次
                //错误的方式：this代表着t1,t2,t3三个对象
//              synchronized (this){

                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(getName() + "：卖票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }

        }

    }
}


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


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

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

    }
}

说明：在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。可以 用xxxx.class 来充当唯一对象

synchronized(XXXX.class){

//需要被同步的代码

}

在这里插入图片描述

以上案例2
如果锁用this,那么this代表着t1,t2,t3三个对象,锁对象不唯一.
如果用Window.class.jvm中只会加载唯一一个Window.class对象.锁对象唯一满足要求

关于同步代码块的总结：

  • 同步的方式，解决了线程的安全问题。–-好处
  • 操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 —局限性

方式二：同步方法

  • 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的

案例1：实现Runnable接口

class Window3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {

            show();
        }
    }

    private synchronized void show(){//同步监视器：this
        //synchronized (this){
        
            if (ticket > 0) {              
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                ticket--;
            }   
    }
}


public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

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

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

}

案例2：继承Thread类

class Window4 extends Thread {

    private static int ticket = 100;

    @Override
    public void run() {

        while (true) {

            show();
        }

    }
    private static synchronized void show(){//同步监视器：Window4.class
        //private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的
        if (ticket > 0) {
          
          System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
      
            ticket--;
        }
    }
}


public class WindowTest4 {
    public static void main(String[] args) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();


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

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

    }
}

在这里插入图片描述

  • 静态的同步方法，同步监视器是：当前类本身

关于同步方法的总结：

  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  2. 非静态的同步方法，同步监视器是：this
  3. 静态的同步方法，同步监视器是：当前类本身

同步机制中的锁

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Lock锁

在这里插入图片描述
在这里插入图片描述

使用流程:

  1. 实例化ReentrantLock
  2. 调用锁定方法lock()
  3. 调用解锁方法：unlock()

案例:

在这里插入图片描述

class Window implements Runnable{

    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try{

                //2.调用锁定方法lock()
                lock.lock();

                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }

        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

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

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

tryLock进行尝试锁定

  • 你可以使用tryLock进行尝试锁定，不管锁定与否，方法都将继续执行，synchronized如果搞不定的话他肯定就阻塞了，但是用ReentrantLock你自己就可以决定你到底要不要wait。

下面程序 就是说比如5秒钟你把程序执行完就可能得到这把锁，如果得不到就不行。由于我的第一个线程跑了10秒钟，所以你在第二个线程里申请5秒肯定是那不到的，把循环次数减少就可以能拿到了。

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

public class T03_ReentrantLock3 {
	Lock lock = new ReentrantLock();

	void m1() {
		try {
			lock.lock();
			for (int i = 0; i < 3; i++) {
				TimeUnit.SECONDS.sleep(1);

				System.out.println(i);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	/**
	 * 使用tryLock进行尝试锁定，不管锁定与否，方法都将继续执行
	 * 可以根据tryLock的返回值来判断是否锁定
	 * 也可以指定tryLock的时间
	 */
	void m2() {
		/*
		boolean locked = lock.tryLock();
		System.out.println("m2 ..." + locked);
		if(locked) lock.unlock();
		*/
		boolean locked = false;
		
		try {
			locked = lock.tryLock(5, TimeUnit.SECONDS);
			System.out.println("m2 ..." + locked);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			if(locked) lock.unlock();
		}
		
	}

	public static void main(String[] args) {
		T03_ReentrantLock3 rl = new T03_ReentrantLock3();
		new Thread(rl::m1).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(rl::m2).start();
	}
}

lock.lockInterruptibly() 打断的加锁

  • ReentrantLock还可以用lock.lockInterruptibly() 这个类，对interrupt()方法做出相应，可以被打断的加锁，如果以这种方式加锁的话我们可以调用一个 t2.interrupt(); 打断线程2的等待。 线程1 上来之后加锁，加锁之后开始睡，睡的没完没了的，被线程1拿到这把锁的话，线程2如果说在想拿到这把锁不太可能，拿不到锁他就会在哪儿等着，如果我们使用原来的这种lock.lock()是打断不了它的，那么我们就可以用另外一种方式lock.lockInterruptibly() 这个类可以被打断的，当你要想停止线程2就可以用 interrupt() ，这也是ReentrantLock比synchronized好用的一个地方。
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Function;

public class T04_ReentrantLock4 {
		
	public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		
		Thread t1 = new Thread(()->{
			try {
				lock.lock();
				System.out.println("t1 start");
				TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
				System.out.println("t1 end");
			} catch (InterruptedException e) {
				System.out.println("interrupted!");
			} finally {
				lock.unlock();
			}
		});
		t1.start();
		
		Thread t2 = new Thread(()->{
			try {
				//lock.lock();
				lock.lockInterruptibly(); //可以对interrupt()方法做出相应
				System.out.println("t2 start");
				TimeUnit.SECONDS.sleep(5);
				System.out.println("t2 end");
			} catch (InterruptedException e) {
				System.out.println("interrupted!");
			} finally {
				lock.unlock();
			}
		});
		t2.start();
		
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.interrupt();//打断线程2的等待
	}
}

ReentrantLock还可以指定为公平锁

  • ReentrantLock还可以指定为公平锁，公平锁的意思是当我们new一个ReentrantLock你可以传一个参数为true，这个true表示公平锁，公平锁的意思是谁等在前面就先让谁执行，而不是说谁后来了之后就马上让谁执行。如果说这个锁不公平，来了一个线程上来就抢，它是有可能抢到的，如果说这个锁是个公平锁，这个线程上来会先检查队列里有没有原来等着的，如果有的话他就先进队列里等着别人先运行，这是公平锁的概念。
  • ReentrantLock默认是非公平锁。
/**
 * ReentrantLock还可以指定为公平锁
 * @author mashibing
 */
package com.mashibing.juc.c_020;

import java.util.concurrent.locks.ReentrantLock;

public class T05_ReentrantLock5 extends Thread {
		
	private static ReentrantLock lock=new ReentrantLock(true); //参数为true表示为公平锁，请对比输出结果
    public void run() {
        for(int i=0; i<100; i++) {
            lock.lock();
            try{
                System.out.println(Thread.currentThread().getName()+"获得锁");
            }finally{
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) {
        T05_ReentrantLock5 rl=new T05_ReentrantLock5();
        Thread th1=new Thread(rl);
        Thread th2=new Thread(rl);
        th1.start();
        th2.start();
    }
}

面试题：synchronized 与 Lock的异同？

ReentrantLock可以替代synchronized这是没问题的，他也可以重入，可以锁定的。本身的底层是cas

相同：

  • 二者都可以解决线程安全问题

不同：

  • synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器,
  • Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
  • trylock：自己来控制，我锁不住该怎么办
  • lockInterruptibly：这个类，中间你还可以被打断
  • Lock它还可以公平和非公平的切换

优先使用顺序：

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

在这里插入图片描述

练习题

在这里插入图片描述

分析：

1.是否是多线程问题？ 是，两个储户线程
2.是否有共享数据？ 有，账户（或账户余额）
3.是否有线程安全问题？有
4.需要考虑如何解决线程安全问题？同步机制：有三种方式。

实现:

class Account{
    private double balance;

    public Account(double balance) {
        this.balance = balance;
    }

    //存钱
    public synchronized void deposit(double amt){
        if(amt > 0){
            balance += amt;

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ":存钱成功。余额为：" + balance);
        }
    }
}

class Customer extends  Thread{

    private Account acct;

    public Customer(Account acct) {
        this.acct = acct;
    }

    @Override
    public void run() {

        for (int i = 0; i < 3; i++) {
            acct.deposit(1000);
        }

    }
}


public class AccountTest {

    public static void main(String[] args) {
        Account acct = new Account(0);
        Customer c1 = new Customer(acct);
        Customer c2 = new Customer(acct);

        c1.setName("甲");
        c2.setName("乙");

        c1.start();
        c2.start();
    }
}
知行合一。。。
关注
专栏目录
Java多线程-线程的安全问题与线程的同步机制介绍
01-29
Java多线程-线程的安全问题与线程的同步机制介绍 在 Java 多线程编程中，线程安全问题是非常重要的一个话题。当多个线程访问同一个资源时，如果只有读操作那么不会出现线程安全问题，但是如果多个线程对资源进行读...
如何使用synchronized关键字处理线程同步问题？【购票问题】
ty6693的博客
04-15 859
一、问题引入 多个线程实现买票功能： public class MyTickRunnable implements Runnable {//MyTickRunnable实现了Runnable接口 private int tick = 10;//总共剩余10张票 @Override public void run() {//MyTickRunnable覆写了R...
多线程的经典案例（卖票）
Note from 2021.1 base 杭州
03-07 1549
前两天在站内看到几个多线程卖票的案例，发现代码都不怎么对，运行结果也不符合预期，不能有效复现多线程并发的场景。故而自己写了一套，过程中也产生了一些新的思考，在此梳理一下。 先贴代码，假设现在电影院有100张票，3个窗口同时售卖。 public class NewTask implements Runnable { public int num = 100; @Override public void run() { while(num > 0) {
经典案例：卖票问题【线程同步】
m0_66884848的博客
04-24 1265
一、案例需求 某个电影院上映了史诗级大片《回村的诱惑》，共有100张票，卖票窗口总共有三个。请设计一个程序模拟卖票的过程！ 二、步骤分析 1、定义一个卖票的线程类实现Runnable接口，并且声明一个成员变量：private int ticket=100; 2、在run方法中，判断该票数是否大于0，就卖票，打印输出剩余票数和窗口； 3、一个线程执行完之后，票数减一； 4、如果票数<=0则停止售票； ...
多线程售票lock锁（一）
【fayker】的博客
03-10 1174
package testlock; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class SellTicket implements Runnable { // 定义票 private int tickets = 100;
java多线程卖电影票的三种实现方式
weixin_43860634的博客
10-09 784
java多线程卖电影票的三种实现方式
java线程1-10-720p版本
02-13
"08_一天学会线程_多线程售票问题.mp4"可能涉及到共享资源的并发访问。在多线程环境中，如果多个线程尝试同时修改同一资源，可能会出现数据不一致的情况。解决这个问题通常需要使用同步机制，如`synchronized`关键字...
THE-SYSTEM-ABOUT-THE-RAILWAY-STATION.rar_THE RAILWAY_java线程售票
09-14
火车站售票系统的实现是一个典型的多线程应用案例，它利用Java编程语言来构建，涉及到了Java线程管理和Swing图形用户界面组件。在这个系统中，我们可以深入理解如何在并发环境中处理任务，以及如何创建用户友好的...
Java课程设计-火车站售票系统.zip
05-03
因此，理解和运用Java的多线程机制是关键，如Thread类、Runnable接口、同步机制（synchronized关键字和Lock接口）以及线程池（ExecutorService）。 3. **GUI设计**：为了实现用户交互，项目可能会使用Java的图形...
Java多线程窗口售票问题实例
08-28
Java多线程窗口售票问题实例 Java多线程窗口售票问题实例是Java多...通过这两个示例，我们可以看到，使用synchronized关键字和lock()、unlock()方法可以有效地解决多线程之间的同步问题，确保每张票只能被售出一次。
多线程解决买票问题
热门推荐
qq_51447436的博客
04-03 1万+
多线程解决买票问题
多线程中的经典例题---卖票
xzy的博客
05-24 803
文章目录多线程中的经典例题---卖票使用Runnable接口创建线程使用Thread线程类的子类创建对象 多线程中的经典例题—卖票 使用Runnable接口创建线程 使用Runnable接口创建线程的时候，可以直接创建一个接口，然后实现内部的run方法，最后让接口对象作为Thread线程类的构造器的一个参数；也可以写一个Runnable接口的实现类，然后实现Runnable接口内部的run方法，然后让这个实现类作为Thread线程类的构造器的一个参数，其实也即是间接的让Runnable接口作为Thread线
多线程四种实现方式及售票案例实现
chorany
04-08 2853
一、多线程实现的四种方式 1.继承Thread类 2.实现Runnable接口 3.实现Callable接口 4.通过线程池获取线程 二、多线程案例应用–售票案例 三、线程池相关解析 1.线程池的创建方式 2.线程池的任务提交的两种方式 ①两种提交方式有何不同 ②为什么submit提交的线程无法返回异常信息 ③怎样获取submit提交的线程的返回数据 四、线程学习过程中遇到的相关问题 1.线程测试时，Junit测试框架的使用和main函数测试相关 使用Junit测试多线程时，执行到Thread.sleep(
用Java 的锁机制实现多线程售票案例
mukewangguanfang的博客
05-26 508
本文内容主要是使用 Java 的锁机制对多线程售票案例进行实现。售票案例多数情况下主要关注多线程如何安全的减少库存，也就是剩余的票数，当票数为 0 时，停止减少库存。本文内容除了关注车票库存的减少，还会涉及到退票窗口，能够更加贴切的模拟真实的场景。
【面试：并发篇03：多线程：锁】卖票程序
m0_71229547的博客
06-21 330
有任何问题请指出，感谢各位。什么是锁：锁是为了保证线程安全，即多线程运行过程中，保证某一部分只能让当前线程运行完，而不能在当前线程运行过程中切换其他线程。总的来说：多线程保证线程安全就是让多个线程执行的情况和单线程一样。什么是卖票程序：卖票程序就是生产消费者模式，我们有很多的卖票点卖票可以卖给很多人，但所有票都在一个票池里，卖票分为两个过程：卖票，总票数减一。这样如果不用锁处理就会出现线程安全问题，比如某一个线程在卖票但票数还没有来得及减一，就切换到另一个线程了然后这个线程又把这张票卖了一次，显然不符合要求
Java 多线程售票
ym563099457的博客
11-05 3406
方式一：继承thread 类 每个线程100张票 package com.example.starter; public class SellTickets extends Thread{ public static void main(String[] args) { Thread t1 = new SellTick1(); Thread t2 = new SellTick1(); Thread t3 = new SellTick1(); t1.start(.
Java多线程--线程的安全问题与线程的同步机制介绍
最新发布
人生得意须尽欢
01-29 926
Java多线程--线程的安全问题与线程的同步机制介绍
线程同步机制（synchronized和Lock）
Valentino112358的博客
05-10 793
线程安全问题 多线程访问了共享数据 ，引发了线程安全问题。 线程安全问题的代码实现 package com.itheima.demo06.ThreadSafe; /* 实现卖票案例 */ public class RunnableImpl implements Runnable{ //定义一个多个线程共享的票源 private int ti...
Java——线程安全（synchronized解决线程安全问题，窗口售票为例）
程序员阿龙的博客
08-01 1038
Java——线程安全（synchronized解决线程安全问题，窗口售票为例）
Java基础：进程与线程详解-多线程并发实践
因此，在编写多线程代码时，需要使用适当的同步机制，如synchronized关键字、Lock接口或并发包（Concurrent Collections）提供的工具，来保护共享数据的一致性和完整性。 理解进程和线程的概念，以及如何在Java中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值