Java:多线程模拟多站点售票过程

简介:
这是一个在并发状态下对共享资源的多线程访问。这些访问必须是互斥的进行,因为涉及到对资源的修改。假设现在销售火车票。目的地有 3 个,分别是北京,天津和上海。使用一个枚举类型表示。
Destation.java
package  com.zj.tickets;
 
public   enum  Destation {
     BEIJING SHANGHAI TIANJING
}
下面设计车票类, final   int   original 表示车票基数; int   current 表示当前还有多少张票; Destation  destation 表示目的地,它必须从上面的枚举型中取出其一。
Ticket.java
package  com.zj.tickets;
 
public   class  Ticket {
     private   final   int   original ;
     private   int   current ;
     private   final  Destation  destation ;
 
     public  Ticket( int  nums, Destation where) {
        current  =  original  = nums;
        destation  = where;
    }
 
     public   int  degress() {
        return  -- current ;
    }
 
     public   int  original() {
        return   original ;
    }
 
     public   boolean  soldout() {
        return   current  <= 0;
    }
 
     public  Destation getDestation() {
        return   destation ;
    }
 
     public   int  getCurrent() {
        return   current ;
    }
}
下面设计售票厅类, Map<Destation, Ticket>  tickets 表示目前可销售的车票种类,它通过一个 static 块初始化。 Map<Destation, Integer>  records 是当前售票厅的火车票销售情况。 List<BookingOffice>  offices 表示当前可工作的所有售票厅,每个售票厅是一个线程。 int   ticketsSold 表示当前售票厅售出的火车票总数。 int   id 表示当前售票厅编号。
每个线程都会模拟客户买票、工作人员查询数据库和售票交易过程。
模拟的数据为,当前发往北京、上海和天津的火车票各 5 张;每个售票厅交易 5 次(无论交易成功或失败)后关闭。
BookingOffice.java
package  com.zj.tickets;
import  java.util.ArrayList;
import  java.util.HashMap;
import  java.util.List;
import  java.util.Map;
import  java.util.Random;
import  java.util.concurrent.TimeUnit;
 
public   class  BookingOffice  implements  Runnable {
     private   static  Map<Destation, Ticket>  tickets  =  new  HashMap<Destation, Ticket>();
     private  Map<Destation, Integer>  records ;
     private   static  List<BookingOffice>  offices  =  new  ArrayList<BookingOffice>();
     private   int   ticketsSold  = 0;
     private   final   int   id ;
 
     // now today's tickets for sell:
     static  {
        tickets .put(Destation. BEIJING new  Ticket(5, Destation. BEIJING ));
        tickets .put(Destation. SHANGHAI new  Ticket(5, Destation. SHANGHAI ));
        tickets .put(Destation. TIANJING new  Ticket(5, Destation. TIANJING ));
    }
 
     public  BookingOffice( int  id) {
        this . id  = id;
        offices .add( this );
       resetRecords();
    }
 
     private   void  resetRecords() {
        records  =  new  HashMap<Destation, Integer>();
    }
 
     private   void  addRecords(Destation d) {
       Integer freq =  records .get(d);
        records .put(d, freq ==  null  ? 1 : freq + 1);
    }
 
     public   void  run() {
        int  transaction = 5;
        while  (transaction-- > 0) {
            // simulate a customer's coming:
           Destation d = Destation.values()[ new  Random().nextInt(Destation
                  .values(). length )];
           print( this  +  "i want a ticket for "  + d);
            // simulate the officer's checking:
            try  {
              TimeUnit. SECONDS .sleep(1);
            catch  (InterruptedException e) {
              e.printStackTrace();
           }
            // simulate the transaction:
           Ticket wanted =  tickets .get(d);
            synchronized  ( wanted ) {
               if  (!wanted.soldout()) {
                  print( this  +  "sold a ticket for "  + d);
                  wanted.degress();
                  addRecords(d);
                  ++ ticketsSold ;
                  print( this  +  ""  + d +  " tickets still have "
                         + wanted.getCurrent());
               else
                  print( this  +  "tickets for "  + d +  " have been sold out." );
           }
       }
       print( this  +  "closed" );
       print( this  +  "totally sold tickets:"  +  ticketsSold  +  ",sell records:"
               records );
    }
 
     public   synchronized   int  getValue() {
        return   ticketsSold ;
    }
 
     public  String toString() {
        return   "<Officce-"  +  id  +  ">" ;
    }
 
     static   void  print(String s) {
       System. out .println(s);
    }
}
模拟售票过程如下,启动 5 个售票厅。
Sell.java
package  com.zj.tickets;
import  java.util.concurrent.ExecutorService;
import  java.util.concurrent.Executors;
 
public   class  Sell {
     public   static   void  main(String[] args)  throws  Exception {
       ExecutorService exec = Executors.newCachedThreadPool();
        for  ( int  i = 0; i < 5; i++)
           exec.execute( new  BookingOffice(i));
       exec.shutdown();
    }
}
结果:
<Officce-0>i want a ticket for BEIJING
<Officce-1>i want a ticket for SHANGHAI
<Officce-2>i want a ticket for TIANJING
<Officce-3>i want a ticket for SHANGHAI
<Officce-4>i want a ticket for SHANGHAI
<Officce-0>sold a ticket for BEIJING
<Officce-0>BEIJING tickets still have 4
<Officce-0>i want a ticket for TIANJING
<Officce-1>sold a ticket for SHANGHAI
<Officce-1>SHANGHAI tickets still have 4
<Officce-1>i want a ticket for SHANGHAI
<Officce-2>sold a ticket for TIANJING
<Officce-2>TIANJING tickets still have 4
<Officce-2>i want a ticket for BEIJING
<Officce-3>sold a ticket for SHANGHAI
<Officce-3>SHANGHAI tickets still have 3
<Officce-3>i want a ticket for TIANJING
<Officce-4>sold a ticket for SHANGHAI
<Officce-4>SHANGHAI tickets still have 2
<Officce-4>i want a ticket for BEIJING
<Officce-4>sold a ticket for BEIJING
<Officce-4>BEIJING tickets still have 3
<Officce-4>i want a ticket for SHANGHAI
<Officce-3>sold a ticket for TIANJING
<Officce-3>TIANJING tickets still have 3
<Officce-3>i want a ticket for TIANJING
<Officce-2>sold a ticket for BEIJING
<Officce-2>BEIJING tickets still have 2
<Officce-2>i want a ticket for BEIJING
<Officce-1>sold a ticket for SHANGHAI
<Officce-1>SHANGHAI tickets still have 1
<Officce-1>i want a ticket for SHANGHAI
<Officce-0>sold a ticket for TIANJING
<Officce-0>TIANJING tickets still have 2
<Officce-0>i want a ticket for SHANGHAI
<Officce-4>sold a ticket for SHANGHAI
<Officce-4>SHANGHAI tickets still have 0
<Officce-4>i want a ticket for BEIJING
<Officce-3>sold a ticket for TIANJING
<Officce-3>TIANJING tickets still have 1
<Officce-3>i want a ticket for BEIJING
<Officce-2>sold a ticket for BEIJING
<Officce-2>BEIJING tickets still have 1
<Officce-2>i want a ticket for SHANGHAI
<Officce-1>tickets for SHANGHAI have been sold out.
<Officce-1>i want a ticket for SHANGHAI
<Officce-0>tickets for SHANGHAI have been sold out.
<Officce-0>i want a ticket for SHANGHAI
<Officce-4>sold a ticket for BEIJING
<Officce-4>BEIJING tickets still have 0
<Officce-4>i want a ticket for BEIJING
<Officce-3>tickets for BEIJING have been sold out.
<Officce-3>i want a ticket for BEIJING
<Officce-2>tickets for SHANGHAI have been sold out.
<Officce-2>i want a ticket for SHANGHAI
<Officce-1>tickets for SHANGHAI have been sold out.
<Officce-1>i want a ticket for BEIJING
<Officce-0>tickets for SHANGHAI have been sold out.
<Officce-0>i want a ticket for SHANGHAI
<Officce-4>tickets for BEIJING have been sold out.
<Officce-4>closed
<Officce-4>totally sold tickets:4,sell records:{BEIJING=2, SHANGHAI=2}
<Officce-3>tickets for BEIJING have been sold out.
<Officce-3>closed
<Officce-3>totally sold tickets:3,sell records:{TIANJING=2, SHANGHAI=1}
<Officce-2>tickets for SHANGHAI have been sold out.
<Officce-2>closed
<Officce-2>totally sold tickets:3,sell records:{BEIJING=2, TIANJING=1}
<Officce-1>tickets for BEIJING have been sold out.
<Officce-1>closed
<Officce-1>totally sold tickets:2,sell records:{SHANGHAI=2}
<Officce-0>tickets for SHANGHAI have been sold out.
<Officce-0>closed
<Officce-0>totally sold tickets:2,sell records:{BEIJING=1, TIANJING=1}


本文转自zhangjunhd51CTO博客,原文链接:http://blog.51cto.com/zhangjunhd/70767,如需转载请自行联系原作者
相关文章
|
2天前
|
存储 缓存 前端开发
Java串口通信技术探究3:RXTX库线程 优化系统性能的SerialPortEventListener类
Java串口通信技术探究3:RXTX库线程 优化系统性能的SerialPortEventListener类
12 3
|
2天前
|
Java
JAVA难点包括异常处理、多线程、泛型和反射,以及复杂的分布式系统知识
JAVA难点包括异常处理、多线程、泛型和反射,以及复杂的分布式系统知识。入坑JAVA因它的面向对象特性、平台无关性、强大的标准库和活跃的社区支持。
13 2
|
2天前
|
Java 调度 开发者
Java中的多线程编程:基础与实践
【5月更文挑战第2天】本文将深入探讨Java中的多线程编程,从基础概念到实际应用,为读者提供全面的理解和实践指导。我们将首先介绍线程的基本概念和重要性,然后详细解析Java中实现多线程的两种主要方式:继承Thread类和实现Runnable接口。接着,我们将探讨线程同步的问题,包括synchronized关键字和Lock接口的使用。最后,我们将通过一个实际的生产者-消费者模型来演示多线程编程的实践应用。
|
2天前
|
安全 Java 程序员
Java中的多线程编程:从理论到实践
【5月更文挑战第2天】 在计算机科学中,多线程编程是一项重要的技术,它允许多个任务在同一时间段内并发执行。在Java中,多线程编程是通过创建并管理线程来实现的。本文将深入探讨Java中的多线程编程,包括线程的概念、如何创建和管理线程、以及多线程编程的一些常见问题和解决方案。
12 1
|
3天前
|
存储 安全 Java
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第1天】本文将深入探讨Java并发编程的核心概念,包括线程安全和性能优化。我们将详细分析线程安全问题的根源,以及如何通过合理的设计和编码实践来避免常见的并发问题。同时,我们还将探讨如何在保证线程安全的前提下,提高程序的并发性能,包括使用高效的同步机制、减少锁的竞争以及利用现代硬件的并行能力等技术手段。
|
3天前
|
并行计算 Java 数据处理
Java中的多线程编程:基础知识与实践
【5月更文挑战第1天】本文将深入探讨Java中的多线程编程,包括其基本概念、实现方式以及实际应用。我们将从理论和实践两个角度出发,详细解析线程的创建、启动、控制以及同步等关键问题,并通过实例代码演示如何在Java中有效地使用多线程。
|
3天前
|
Java 程序员
Java中的多线程编程:从理论到实践
【5月更文挑战第1天】 在现代计算机科学中,多线程编程是一个重要的概念,它允许程序员在同一程序中并行运行多个任务。Java作为一种广泛使用的编程语言,提供了一套丰富的多线程编程工具。本文将介绍Java中多线程编程的基本概念,包括线程的创建、启动、控制和同步,以及一些常见的多线程问题和解决方案。
|
3天前
|
存储 Java 程序员
Java中的多线程编程:基础知识与实践
【5月更文挑战第1天】在现代计算机科学中,多线程是一种重要的并行计算技术,允许多个执行流程并发运行。本文将深入探讨Java语言中的多线程编程,从基础概念到实际应用,帮助读者理解多线程的核心原理,并通过实例学习如何在Java中创建和管理线程。我们将涵盖线程的生命周期、同步机制以及如何利用高级类如Executor框架来优化多线程应用的性能。通过本文的学习,读者将具备设计和实现高效、稳定多线程Java应用程序的能力。
6 2
|
4天前
|
缓存 Java 调度
Java并发编程:深入理解线程池
【4月更文挑战第30天】 在Java并发编程中,线程池是一种重要的工具,它可以帮助我们有效地管理线程,提高系统性能。本文将深入探讨Java线程池的工作原理,如何使用它,以及如何根据实际需求选择合适的线程池策略。
|
5天前
|
监控 安全 Java
【多线程学习】深入探究阻塞队列与生产者消费者模型和线程池常见面试题
【多线程学习】深入探究阻塞队列与生产者消费者模型和线程池常见面试题