java 通过卖票的例子引入多线程及线程锁synchronized

最新推荐文章于 2023-02-06 21:43:19 发布
最新推荐文章于 2023-02-06 21:43:19 发布
阅读量456 收藏 1
点赞数
分类专栏： # java线程 文章标签： 多线程 java 程序人生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32224047/article/details/106431348
版权

 先创建Seller 类，用来表示线程类。卖票的过程，用来描述线程的任务信息

示例一：Seller 类的属性tickets设置为非静态属性，此种情况下A,B，C,D 四个对象各自卖了100张

public class SealTicketDemo_1 {

    public static void main(String[] args) {
        //创建四个对象--四个线程+一个主线程
        Seller_1 s1 = new Seller_1();
        Seller_1 s2 = new Seller_1();
        Seller_1 s3 = new Seller_1();
        Seller_1 s4 = new Seller_1();
        //创建四个线程对象（Thread类对象）,并指定线程名称
        Thread t1 = new Thread(s1,"A");
        Thread t2 = new Thread(s2,"B");
        Thread t3 = new Thread(s3,"C");
        Thread t4 = new Thread(s4,"D");
        //开启线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}


//代表线程类，描述线程的任务信息--卖票的过程
class Seller_1 implements Runnable{
    //属性表示票数,非静态属性，各自卖100张
    int tickets = 100;
    @Override
    public void run() {
        while (tickets!=0) {
            //每次卖一张票
            tickets = tickets - 1;
            //输出
            //currentThread--返回当前正在执行的线程
            //再次调用getName() 返回线程的名称（不指定名称则返回线程自己的编号，不利于查看）
            System.out.println(Thread.currentThread().getName()
                    + "卖了一张票，还剩余：" + tickets + "张票");
        }
    }
}

运行结果：

示例二：Seller 类的属性tickets设置为静态属性，此种情况，A,B，C,D四个对象卖票数量是100

但是：1.静态变量是类共享，线程不安全 2.基本类型没有对象，不能实现后期排序

public class SealTicketDemo_1 {

    public static void main(String[] args) {
        //创建四个对象--四个线程+一个主线程
        Seller_1 s1 = new Seller_1();
        Seller_1 s2 = new Seller_1();
        Seller_1 s3 = new Seller_1();
        Seller_1 s4 = new Seller_1();
        //创建四个线程对象（Thread类对象）,并指定线程名称
        Thread t1 = new Thread(s1,"A");
        Thread t2 = new Thread(s2,"B");
        Thread t3 = new Thread(s3,"C");
        Thread t4 = new Thread(s4,"D");
        //开启线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}


//代表线程类，描述线程的任务信息--卖票的过程
class Seller_1 implements Runnable{
    //属性表示票数,静态属性，卖100张
    static int tickets = 100;
    @Override
    public void run() {
        while (tickets!=0) {
            //每次卖一张票
            tickets = tickets - 1;
            //输出
            //currentThread--返回当前正在执行的线程
            //再次调用getName() 返回线程的名称（不指定名称则返回线程自己的编号，不利于查看）
            System.out.println(Thread.currentThread().getName()
                    + "卖了一张票，还剩余：" + tickets + "张票");
        }
    }
}

执行结果：

示例三：引入代表票据的类Ticket,定义私有属性count 表示票据数目，Seller_1类中添加有参构造函数，参数传入Ticket对象，为了更为方便的设置票据数量，增加配置文件ticket.properties（文件路径可以放在项目工程根目录下），配置信息如下

因为目前没有添加锁，所以存在线程抢占，在run()方法中添加休眠，使得线程抢占较为明显

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

public class SealTicketDemo_1 {

    public static void main(String[] args) throws IOException {
        //读取properties文件内容
        Properties p = new Properties();
        p.load(new FileReader("ticket.properties"));
        //获取票数，获取映射里的值
        String count = p.getProperty("count");
        //创建代表票的类
        Ticket t = new Ticket();
        //设置票数为100
        t.setCount(Integer.parseInt(count));
        //创建四个对象--四个线程+一个主线程
        Seller_1 s1 = new Seller_1(t);
        Seller_1 s2 = new Seller_1(t);
        Seller_1 s3 = new Seller_1(t);
        Seller_1 s4 = new Seller_1(t);
        //创建四个线程对象（Thread类对象）,并指定线程名称
        Thread t1 = new Thread(s1,"A");
        Thread t2 = new Thread(s2,"B");
        Thread t3 = new Thread(s3,"C");
        Thread t4 = new Thread(s4,"D");
        //开启线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}


//代表线程类，描述线程的任务信息--卖票的过程
class Seller_1 implements Runnable{
    //注入Ticket 类对象当做属性
    Ticket t;

    public Seller_1(Ticket t) {
        this.t = t;
    }

    @Override
    public void run() {
        while (t.getCount()!=0) {
            //每次卖一张票
            t.setCount(t.getCount()-1);
            //输出
            //currentThread--返回当前正在执行的线程
            //再次调用getName() 返回线程的名称（不指定名称则返回线程自己的编号，不利于查看）
            System.out.println(Thread.currentThread().getName()
                    + "卖了一张票，还剩余：" + t.getCount() + "张票");
            //添加休眠，方便实现线程抢占
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

代表票的类

//代表票的类
class Ticket{
    //属性票数
    private int count;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

执行结果如下：标注处就是线程抢占导致的结果

示例四：为了解决示例三的线程抢占情况，添加锁synchronized，此例子先添加同步代码块锁，下面代码(synchronized (t))中的锁对象t表示当前参与操作的线程对象的共享对象，也可以换成Math.class 、Seller.class 等这些方法区资源（方法区的资源（被所有的线程对象共享），但是这些锁对象，范围太大，消耗的资源太多，所以最好用当前参与操作的线程对象的共享对象），因为锁在while循环外依然会出现抢占，所以，while要放在锁外面，但不能出现判断语句，锁中需要添加循环的结束条件，即票据为0时break;结束循环。

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

public class SealTicketDemo_1 {

    public static void main(String[] args) throws IOException {
        //读取properties文件内容
        Properties p = new Properties();
        p.load(new FileReader("ticket.properties"));
        //获取票数，获取映射里的值
        String count = p.getProperty("count");
        //创建代表票的类
        Ticket t = new Ticket();
        //设置票数为100
        t.setCount(Integer.parseInt(count));
        //创建四个对象--四个线程+一个主线程
        Seller_1 s1 = new Seller_1(t);
        Seller_1 s2 = new Seller_1(t);
        Seller_1 s3 = new Seller_1(t);
        Seller_1 s4 = new Seller_1(t);
        //创建四个线程对象（Thread类对象）,并指定线程名称
        Thread t1 = new Thread(s1,"A");
        Thread t2 = new Thread(s2,"B");
        Thread t3 = new Thread(s3,"C");
        Thread t4 = new Thread(s4,"D");
        //开启线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}


//代表线程类，描述线程的任务信息--卖票的过程
class Seller_1 implements Runnable{
    //注入Ticket 类对象当做属性
    Ticket t;

    public Seller_1(Ticket t) {
        this.t = t;
    }

    @Override
    public void run() {
        //因为在锁的外面依然有抢占，所以不能出现判断语句
        while (true){
            //同步代码块锁
            //()---锁对象（指定线程对象共享的锁对象）
            //被共享的线程对象就会在执行锁住的代码区域中，不会被抢占
            //方法区的资源（被所有的线程对象共享）
        synchronized (t){
            //上面的t 可以换成  Math.class 、Seller.class 等
                //while 放到锁的外面，但是不能出现判断语句
                //结束循环条件
                if (t.getCount()==0)
                    break;
                //每次卖一张票
                t.setCount(t.getCount()-1);
                //输出
                //currentThread--返回当前正在执行的线程
                //再次调用getName() 返回线程的名称（不指定名称则返回线程自己的编号，不利于查看）
                System.out.println(Thread.currentThread().getName()
                        +"卖了一张票，还剩余："+t.getCount()+"张票");
                //添加休眠，方便实现线程抢占
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

执行结果如下：

示例五：对于上面的示例四，synchronized (t)处的t当前参与操作的线程对象的共享对象,可以换成this，Runnable 实现类创建的对象被参与的线程对象共享，锁对象为this的情况，只能创建一个Seller_1对象

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

public class SealTicketDemo_1 {

    public static void main(String[] args) throws IOException {
        //读取properties文件内容
        Properties p = new Properties();
        p.load(new FileReader("ticket.properties"));
        //获取票数，获取映射里的值
        String count = p.getProperty("count");
        //创建代表票的类
        Ticket t = new Ticket();
        //设置票数为100
        t.setCount(Integer.parseInt(count));
        //锁对象为this的情况，只能创建一个Seller_1对象
        Seller_1 s1 = new Seller_1(t);
        //创建四个线程对象（Thread类对象）,并指定线程名称
        Thread t1 = new Thread(s1,"A");
        Thread t2 = new Thread(s1,"B");
        Thread t3 = new Thread(s1,"C");
        Thread t4 = new Thread(s1,"D");
        //开启线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}


//代表线程类，描述线程的任务信息--卖票的过程
class Seller_1 implements Runnable{
    //注入Ticket 类对象当做属性
    Ticket t;

    public Seller_1(Ticket t) {
        this.t = t;
    }

    @Override
    public void run() {
        //因为在锁的外面依然有抢占，所以不能出现判断语句
        while (true){
            //同步代码块锁
            //()---锁对象（指定线程对象共享的锁对象）
            //被共享的线程对象就会在执行锁住的代码区域中，不会被抢占
            //方法区的资源（被所有的线程对象共享）
        synchronized (this){
            //上面的t 可以换成  Math.class 、Seller.class 等
                //while 放到锁的外面，但是不能出现判断语句
                //结束循环条件
                if (t.getCount()==0)
                    break;
                //每次卖一张票
                t.setCount(t.getCount()-1);
                //输出
                //currentThread--返回当前正在执行的线程
                //再次调用getName() 返回线程的名称（不指定名称则返回线程自己的编号，不利于查看）
                System.out.println(Thread.currentThread().getName()
                        +"卖了一张票，还剩余："+t.getCount()+"张票");
                //添加休眠，方便实现线程抢占
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果为：

实例六：同步方法锁，在方法的身上加上synchronized ，是锁住整个方法，锁对象不用指定（如果是非静态方法，锁对象就是this，如果是静态方法锁对象就是当前类.class(方法区资源)）

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

public class SealTicketDemo_1 {
    public static void main(String[] args) throws IOException {

        //读取properties文件里内容
        Properties p=new Properties();
        p.load(new FileReader("ticket.properties"));
        //获取票数，获取映射里的值
        String count=p.getProperty("count");
        //创建代表票的类
        Ticket t=new Ticket();
        //设置100票数
        t.setCount(Integer.parseInt(count));
        //创建四个售票系统
        Seller_1 s1=new Seller_1(t);
        Seller_1 s2=new Seller_1(t);
        Seller_1 s3=new Seller_1(t);
        Seller_1 s4=new Seller_1(t);
        //创建四个线程对象（Thread类对象）
        //可以指定线程对象的名称
        Thread t1=new Thread(s1,"A");
        Thread t2=new Thread(s2,"B");
        Thread t3=new Thread(s3,"C");
        Thread t4=new Thread(s4,"D");
        //开启线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}


class Seller_1 implements Runnable{

    //注入Ticket类对象当作属性
    Ticket t;
    //有参构造
    public Seller_1(Ticket t){
        this.t=t;
    }
    //重写方法---卖票过程
    //当同步方法是非静态方法时锁对象就是this
    //当同步方法是静态方法锁对象就是当前类.class
    //锁住的代码区域就是整个方法
    @Override
    public synchronized void run() {
        //因为在锁的外面依然还是由抢占所以不能出现判断语句
        while (true) {

            //结束循环的条件
            if(t.getCount()==0)
                break;

            //卖一张票
            t.setCount(t.getCount() - 1);
            //输出
            //Thread.currentThread()---返回的是当前正在
            //执行的线程
            //再次调用getName()返回线程的名称
            System.out.println(Thread.currentThread()
                    .getName() + "卖了一张票，还剩余" + t.getCount()
                    + "张票...");

            //休眠
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果为：

32224047_yw
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java简单的多线程卖票
weixin_52210086的博客
04-09 4332
package xiancheng; /* 定义一个MaiPiao类实现Runnable接口，里面定义一个成员变量: private int tickets =100(票数); 在类中重写run()方法实现卖票，代码步骤如下 1：判断票数大于0，就卖票，并告知是哪个窗口卖的 2:卖了票之后，总票数要减1 3：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行 定义一个测试类MaiPiaoDemo，里面有main方法，代码步骤如下 1:创建MaiPiao类的对象 2:创建三个Th.
java实现多线程卖票功能
08-25
主要为大家详细介绍了java实现多线程卖票功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
JAVA多线程模拟火车站售票大厅
forthenight996的博客
05-18 5287
文章目录实验要求一、程序流程图（试验原理）二、变量说明三、功能分析及设计四、多线程卖票的实现五、实验结果及代码代码： 实验要求 用多线程设计一个模拟火车站售票大厅的工作情形。火车站有许多售票窗口，有些开放，有些不开放。用多个线程去订票，不能有两个或者以上的线程订到同一个票，当最后一张票卖掉时，再订就异常提示出票卖完了。每个窗口买票需要1-3秒的时间，每次卖票需要打印出买票的时间和买票的窗口名。 一、程序流程图（试验原理） 二、变量说明 count:当前剩余总票数 place[]:途径站点 num:本
【Java】多线程售票案例
最新发布
RedMaple
02-06 748
java多线程卖票案例
java多线程仿火车票售票
12-24
java课程学习多线程中模仿火车站多窗口同时售票的场景，适合初学者学习
Java通过卖票理解多线程
08-29
"Java通过卖票理解多线程" 本文主要介绍了一个多线程卖票的例子，通过卖票这个实例来介绍多线程的方式，加深理解。多线程是一种非常重要的编程概念，它可以使得程序的执行效率更高，提高程序的性能。在本文中，我们...
Java 多线程同步 锁机制与synchronized深入解析
09-05
总结来说，Java的synchronized关键字提供了锁机制，用于实现多线程环境下的同步。同步方法和同步代码块是两种不同级别的同步控制，同步代码块提供了更灵活的控制和更高的效率。理解并合理使用这些机制对于编写高效、...
Java 多线程synchronized关键字详解(六)
09-03
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以避免数据不一致和竞态条件。在这个问题中，我们将深入理解`synchronized`的关键字用法，包括同步方法和同步块。 1. **...
java 多线程-锁详解及示例代码
09-01
总的来说，Java多线程中的锁机制主要包括`synchronized`关键字和`Lock`接口。正确理解和使用锁，能够有效地解决并发问题，保证程序的正确性和高效性。在实际开发中，应根据具体需求选择合适的锁类型，同时注意避免...
Java_线程—经典的例子：售票
不求重复造轮子，但必须要知道轮子是怎么造的。
09-02 1998
在多线程中，有一个经典的例子：售票 售票很常见，公园，车站，电影院，都有售票系统，通常这些售票的地方，都开放着不止一个售票窗口。这就涉及到了多线程的概念了。 接下来看看这个例子： 既然线程有两种方式，我们就分别看看这两种方式写出来的程序和运行之后的结果是咋样的？ 先来看看继承Thread的方式：
java多线程重复卖票的问题
zouxucong的博客
01-13 3420
上代码：public class Test { public static void main(String[] args) { ThreadTicket ticket = new ThreadTicket(); Thread t1 = new Thread(ticket); Thread t2 = new Thread(ticket);
java多线程实现售票
无敌海盗的博客
11-27 4375
package com.gxk.thread; class ticketThread extends Thread { private static int ticket = 50; private String name; public ticketThread(String name) { this.name = name; } @Override public voi
多线程的经典案例(卖票问题)
热门推荐
weimeig的博客
03-10 1万+
转帖请注明本文出自weimeig的博客（http://blog.csdn.net/weimeig/article/details/79512965），请尊重他人的辛勤劳动成果，谢谢应朋友们反馈的JAVA基础薄弱的问题，决定出一套完整的JAVA基础教程，帮助大家复习，巩固JAVA基础，今天要讲的是多线程的经典案例。卖票问题class Xc implements Runnable{ public ...
java第三式——巧通线程，进程
Mr_楠先森的博客
11-03 157
进程：（1）资源分配的最小单位——有独立的地址空间（共享进程中的数据） （2）每次创建一个进程就会通过堆栈来创建一个地址空间给对应的元素的位置来进行操作处理 （因此，同等条件下创建一个进程的成本更高） （3）为动态的有自己的生命周期，它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消。反映了一个程序...
java_常见面试题（多线程卖票）
qq_41921378的博客
08-18 126
1、第一种方式 继承Thread package com.Demo.exe; import java.io.IOException; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class TestSaleTicketThreadDemo{ public static void main(String[] args) { Sal.
Java售票任务_多线程详细实现
qq_40285647的博客
06-12 2685
Java售票任务_多线程详细实现 题目回顾：铁道部发布了一个售票任务，要求销售1000张票，要求有3个窗口来进行销售，请编写多线程程序来模拟这个效果。 ​ i. 窗口001正在销售第1000张票 ​ ii. 窗口001正在销售第999张票 ​ iii. 窗口002正在销售第998张票 ​ iv. … ​ v. 窗口002正在销售第1张票 ​ vi. 票已经销售完毕 一 、注意细节： ​ 问题1：三个线程都卖了1000张票，一共卖了3000张票 ​ 原因：三个线程代表三个对象，就有三个成
JUC学习（一）：synchronized的介绍及使用（实现多线程卖票）
m0_49499183的博客
03-20 680
一、synchronized简介 synchronized 是 Java 中的关键字，是一种同步锁。它修饰的对象有以下几种： 1、修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{} 括起来的代码，作用的对象是调用这个代码块的对象；2、修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3、修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； ...
java多线程经典案列（卖票）
qq_36755127的博客
05-01 894
public class Ticket implements Runnable { private int ticket = 100; @Override public void run() { while (true) { if (ticket > 0) { try { Thread.sleep(1000); } catch.
Java JUC并发编程实例：守护线程与Synchronized锁
这个资源通过具体的代码实例，展示了Java多线程编程中的基础概念，包括如何使用用户线程和守护线程，以及如何利用JUC库中的同步机制（如`synchronized`和`Lock`）来处理并发场景中的数据一致性问题。这些知识对于有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值