java ticket 是什么 java 多线程模拟火车售票系统问题
大家好,今天小编来为大家解答以下的问题，关于java ticket 是什么，java 多线程模拟火车售票系统问题这个很多人还不知道，现在让我们一起来看看吧！
java 怎么创建一个新的进程
不能创建进程，只能创建线程
在Java中，类仅支持单继承，也就是说，当定义一个新的类的时候，它只能扩展一个外部类.这样，如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的，那么这个自定义类就不能再去扩展其他的类，也就无法实现更加复杂的功能。因此，如果自定义类必须扩展其他的类，那么就可以使用实现Runnable接口的方法来定义该类为线程类，这样就可以避免Java单继承所带来的局限性。
还有一点最重要的就是使用实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享.
（1）通过扩展Thread类来创建多线程
假设一个影院有三个售票口，分别用于向儿童、成人和老人售票。影院为每个窗口放有100张电影票，分别是儿童票、成人票和老人票。三个窗口需要同时卖票，而现在只有一个售票员，这个售票员就相当于一个CPU，三个窗口就相当于三个线程。通过程序来看一看是如何创建这三个线程的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<span style="font-size: 16px;">public class MutliThreadDemo{
public static void main(String [] args){
MutliThread m1=new MutliThread("Window 1");
MutliThread m2=new MutliThread("Window 2");
MutliThread m3=new MutliThread("Window 3");
m1.start();
m2.start();
m3.start();
}
}
class MutliThread extends Thread{
private int ticket=100;//每个线程都拥有100张票
MutliThread(String name){
super(name);//调用父类带参数的构造方法
}
public void run(){
while(ticket>0){
System.out.println(ticket--+" is saled by"+Thread.currentThread().getName());
}
}
}
</span>
程序中定义一个线程类，它扩展了Thread类。利用扩展的线程类在MutliThreadDemo类的主方法中创建了三个线程对象，并通过start()方法分别将它们启动。
从结果可以看到，每个线程分别对应100张电影票，之间并无任何关系，这就说明每个线程之间是平等的，没有优先级关系，因此都有机会得到CPU的处理。但是结果显示这三个线程并不是依次交替执行，而是在三个线程同时被执行的情况下，有的线程被分配时间片的机会多，票被提前卖完，而有的线程被分配时间片的机会比较少，票迟一些卖完。
可见，利用扩展Thread类创建的多个线程，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。
（2）通过实现Runnable接口来创建多线程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<span style="font-size: 16px;">public class MutliThreadDemo2{
public static void main(String [] args){
MutliThread m1=new MutliThread("Window 1");
MutliThread m2=new MutliThread("Window 2");
MutliThread m3=new MutliThread("Window 3");
Thread t1=new Thread(m1);
Thread t2=new Thread(m2);
Thread t3=new Thread(m3);
t1.start();
t2.start();
t3.start();
}
}
class MutliThread implements Runnable{
private int ticket=100;//每个线程都拥有100张票
private String name;
MutliThread(String name){
this.name=name;
}
public void run(){
while(ticket>0){
System.out.println(ticket--+" is saled by"+name);
}
}
}
</span>
由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和（1）结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。
可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。
由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和例4.2.1的结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。
可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。
（3）通过实现Runnable接口来实现线程间的资源共享
现实中也存在这样的情况，比如模拟一个火车站的售票系统，假如当日从A地发往B地的火车票只有100张，且允许所有窗口卖这100张票，那么每一个窗口也相当于一个线程，但是这时和前面的例子不同之处就在于所有线程处理的资源是同一个资源，即100张车票。如果还用前面的方式来创建线程显然是无法实现的，这种情况该怎样处理呢？看下面这个程序，程序代码如下所示：
+ View Code
结果正如前面分析的那样，程序在内存中仅创建了一个资源，而新建的三个线程都是基于访问这同一资源的，并且由于每个线程上所运行的是相同的代码，因此它们执行的功能也是相同的。
可见，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的，读者想想看，为什么？
实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。
java 的小问题
Java线程认识
在了解线程之前，先了解一下，什么是进程。简单地说，在多任务系统中，每个独立执行的程序就称为进程。在一个进程中又可以包含一个或多个线程，一个线程就是一个程序内部的一条执行线索。
线程又分为单线程和多线程。
在单线程中，程序代码是按照调用顺序依次往下执行，在这种情况下，当主函数调用了子函数，那么主函数就必须要等待子函数返回后才能继续往下执行，不能实现两段代码同时交替运行。如果想要一程序中的多段代码同时交替运行，那么就需要产生出多个线程，并指定产生的每个线程上所要运行的程序代码段，这就是多线程。
当我们的Java程序启动运行的时候，就自动产生了一个线程，主函数main就是在这个线程上运行的。当这个线程运行的时候不再产生出新的线程时，那么这个程序就是单线程的。
实现线程的方式有两种：
1.继承java.lang.Thread，并重写它的run()方法，将线程的执行主体放入其中。
2.实现java.lang.Runnable接口，实现它的run()方法，并将线程的执行主体放入其中。
这两种实现方式的区别并不大。继承Thread类的方式实现起来较为简单，但是继承它的类就不能再继承别的类了，因此也就不能继承别的类的有用的方法了。而使用是想Runnable接口的方式就不存在这个问题了，而且这种实现方式将线程主体和线程对象本身分离开来，逻辑上也较为清晰，所以推荐大家更多地采用这种方式。
如何启动线程
我们通过以上两种方式实现了一个线程之后，线程的实例并没有被创建，因此它们也并没有被运行。我们要启动一个线程，必须调用方法来启动它，这个方法就是Thread类的start()方法，而不是run()方法（既不是我们继承Thread类重写的run()方法，也不是实现Runnable接口的run()方法）。run()方法中包含的是线程的主体，也就是这个线程被启动后将要运行的代码，它跟线程的启动没有任何关系。上面两种实现线程的方式在启动时会有所不同。那下面我们就分别看看两种实现方式的具体方式。
用Thread类创建线程
Java的线程是通过java.lang.Thread类来控制的，一个Thread类的对象就代表一个线程，而且只能代表一个线程，通过Thread类和它定义的对象，我们可以获取当前线程对象、获取某一线程的名称，可以实现控制线程暂停一段时间等功能。为了深入了解Thread类，我们来看看这样的一个程序：
public class ThreadDemo{
public static void main(String args[]){
new TestThread().run();
while(true){
System.out.println("main thread is running");
}
}
}
class TestThread{
public void run(){
while(true){
System.out.println(Thread.currentThread().getName()+" is
running");
}
}
}
运行结果是在屏幕上不停的打印出main is running,这说明了主函数里的那段无限循环代码没有被执行。因为调用的子函数是一个无限循环，主函数就得到不执行。这段代码很清楚的说明了什么是单线程。
在我们的生活中为了提高效率，往往需要实现同步任务，即多个任务交替进行，那么多线程就能满足这样的情况。下面我们把上面的单线程代码稍微修改一下，让它来实现多线程任务，代码如下：
public class ThreadDemo{
public static void main(String args[]){
new TestThread().start();
while(true){
System.out.println("main thread is running");
}
}
}
class TestThread extends Thread{
public void run(){
while(true){
System.out.println(Thread.currentThread().getName()+" is
running");
}
}
}
在这段程序里TestThread类继承了Thead类，也就是说TestTread类具有了Thread类的全部特性，在程序中没有直接调用TestThread类对象的run方法，而是调用了该类对象从Thread类继承来的start方法。程序的运行结果是两个while循环处的代码同时交替运行，这就是我们常常谈到的多线程。由此可见，在单线程中，我们必须要等待前一个任务完成了才能进行下一个任务，而在多线程中，我们可以同时处理多个任务，不用在等待。
小结：
(1)要将一段代码在一个新的线程上运行，该段代码应该在一个类的run函数中，并且run函数所在的类是Thread类的子类。要实现多线程，必须要编写一个继承了Thread类的子类，子类要覆盖Thread类中的run函数，在子类的run函数中就是想要在新线程上运行的程序代码。
(2)启动一个新的线程，不是直接调用Thread子类对象的run方法，而是调用Thread子类对象的start方法，Thread类对象的start方法将产生一个新的线程，并在该线程上运行该Thread类对象的run方法。根据面向对象的多态性，在该线程上实际运行的是Thread子类对象中的run方法。
(3)由于线程的代码段是在run方法中，那么我们就可以通过控制run方法来控制程序的运行。
用Runnable接口创建多线程
在JDK文档中，还看到了一个Thread构造方法，从JDK文档中长款Runnable接口类的帮助，该接口中只有一个run方法，当使用Thread类中的方法创建对象时，需要为该方法传递一个实现了Runnable接口的类的对象，这样创建的线程将调用那个实现了Runnable接口的类对象中的run方法作为其运行代码，而不再调用Thread类中的run方法。我们将前面继承Thread类的程序稍微修改一下就可以了，代码如下：
public class ThreadDemo{
public static void main(String args[]){
TestThread tt=new TestThread();
Thread t=new Thread(tt);
t.start();
while(true){
System.out.println("main thread is running");
}
}
}
class TestThread implements Runnable{
public void run(){
while(true){
System.out.println(Thread.currentThread().getName()+" is
running");
}
}
}
这段代码的运行效果同继承Thread类的运行效果一样。既然直接继承Thread和实现Runnable接口都能实现多线程，那么这两种实现多线程的方式在应用上有什么区别呢？到底用哪一个好呢？下面就来看看。
两种实现多线程方式的对比分析
为了对Thread类和Runnable接口实现多线的方式进行比较分析，我们还是通过编写程序来看效果清楚些。我们来模拟一个售票系统，实现通过四个售票点发售某次列车的100张票，一个售票点用一个县城来表示。我们把前面的代码复制下来修改一下就可以了，具体代码如下：
public class ThreadDemo{
public static void main(String args[]){
TestThread tt=new TestThread();
tt.start();
tt.start();
tt.start();
tt.start();
}
}
class TestThread extends Thread{
private int tickets=100;
public void run(){
while(true){
if(tickets>0)
System.out.println(Thread.currentThread().getName()+" is
saling ticket"+tickets--);
}
}
}
在TheadDemo类的main方法中，我们创建了一个线程对象，并重复启动了四次，我们从运行结果上，我们发现其实只有一个线程在运行，这个结果告诉我们，一个线程对象只能启动一个线程，无论你调用多上遍start方法，结果都只有一个线程。因此，我们就要再次修改程序，在main方法中创建四个TestThread对象，修改后的程序代码如下：
public class ThreadDemo{
public static void main(String args[]){
TestThread tt1=new TestThread();
TestThread tt2=new TestThread();
TestThread tt3=new TestThread();
TestThread tt4=new TestThread();
tt1.start();
tt2.start();
tt3.start();
tt4.start();
}
}
class TestThread extends Thread{
private int tickets=100;
public void run(){
while(true){
if(tickets>0)
System.out.println(Thread.currentThread().getName()+" is
saling ticket"+tickets--);
}
}
}
我们再次运行程序，从结果中我们看到了每一个票号都被打印了四遍，即是四个线程都各自卖各自的100张票，而不是去卖共同的100张票。我们需要的是多个线程去处理同一资源，一个资源只能对应一个对象，而在上面的程序中，我们创建了四个TestThread对象，就等同于创建了四个资源，每个TestThread对象中都有100张票，每个线程在独立的处理各自的资源，因此相互之间没有关联。
到现在为止我们已经修改了两次，还是没有达到我们想要的结果，要想实现这个模拟程序，我们只能创建一个资源对象，但要创建多个线程去处理同一资源对象，并且每个线程上所运行的是相同的程序代码。回顾一下我们在前面使用接口编写多线的过程，现在我们把继承Thread类的模拟程序改写为实现Runnable接口的程序，修改的代码如下：
public class ThreadDemo{
public static void main(String args[]){
TestThread tt=new TestThread();
Thread t1=new Thread(tt);
Thread t2=new Thread(tt);
Thread t3=new Thread(tt);
Thread t4=new Thread(tt);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class TestThread implements Runnable{
private int tickets=100;
public void run(){
while(true){
if(tickets>0)
System.out.println(Thread.currentThread().getName()+" is
saling ticket"+tickets--);
}
}
}
在这个程序中，通过Thread类创建了四个线程，每个线程调用的都是同一个TestThread对象中的run方法，访问的是同一个对象中的变量实例，这个程序就刚好满足了我们的需求。可以，实现Runnable接口相对于继承Thread类来说，有下面的好处：
(1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU同程序的代码、数据有效分离，较好地体现了面向对象的设计思想。
(2)可以避免由于Java的单继承带来的局限。
(3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是对立的。事实上，几乎所有多线程应用都可用第二种方式，即实现Runnable接口。我们既然谈到了线程，那就应该更深的去了解一下。
后台线程和联合线程
(1)后台线程
在上面的模拟程序中，我们在main方法中创建并启动新的线程后，main方法便结束了，主线程也就随之结束了，在这样的情况下，虽然main线程结束了，但整个Java程序没有随之结束。对于Java程序来说，只要还有一个前台线程在运行，这个程序就不会结束。如果一个进程中只有后台线程运行，这个进行就会结束。前台线程是相对于后台线程而言的。如果对某个线程对象在启动之前调用了setDaemon(true)方法，这个线程就变成了后台线程。
下面我们就来看看，进程中只有后台线程运行时，进程就会结束的情况。我们修改一下上面的代码，详情如下：
public class ThreadDemo{
public static void main(String args[]){
TestThread tt=new TestThread();
Thread t=new Thread(tt);
t.setDaemon(true);
t.start();
}
}
class TestThread implements Runnable{
private int tickets=100;
public void run(){
while(true){
if(tickets>0)
System.out.println(Thread.currentThread().getName()+" is
saling ticket"+tickets--);
}
}
}
从上面程序的运行结果，我们可以看到，虽然创建了一个无限循环的线程，因为它是后台线程，整个进程在主线结束时就随之终止运行了。这久验证了进程中只有后台线程运行时，进程就会结束的说法。
(2)联合线程与join方法
先不谈联合线程，我们先看看下面这段程序，我们不用重新新程序，我们只需要将前面的程序拿过来修改就可以了，详细代码如下：
public class JoinThread{
public static void main(String args[]){
TestThread tt=new TestThread();
Thread t=new Thread(tt);
t.start();
int i=0；
while(true){
if(i==100){
try{
t.join();
}
catch(Exception e){
System.out.println(e.getMessage());
}
}
System.out.println("main thread is running"+i++);
}
}
}
class TestThread implements Runnable{
public void run(){
int i=0;
while(true){
System.out.println(Thread.currentThread().getName()+" is
running"+""+i++);
}
}
}
在这个程序中用到了Thread类的join方法，即t.join();语句，它的作用就是把t所对应的线程合并到调用t.join();语句的线程中。我们查看JDK文档发现，除了有无参数的join方法外，还有两个带参数的join方法，分别是join(long millis)和join(long millis,int nanos)
，它们的作用就是指定合并时间，前者精确到毫秒，后者精确到纳秒，意思就是两个线程合并指定的时间后，又开始分离，回到合并前的状态。
总之，多线程的用途非常广泛，比如网络聊天程序、复制表记录、www服务器等
java 多线程模拟火车售票系统问题
在synchronized(str)里加一句 if(ticket> 0)//判断是否有余票,没有余票还卖什么?
也就是这样:
package socket;
public class Test
{
public static void main(String [] args)
{
TestThread tt=new TestThread();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
}
}
class TestThread implements Runnable
{
int ticket=10;
String str="";
public void run()
{
while(ticket>0)
{
synchronized(str)
{
if(ticket> 0){
System.out.println(Thread.currentThread().getName()+":ticket"+ticket+" is saling");
ticket--;
}
}
}
}
}
你的while循环只是超出票数的循环,在同步里面还要有判断是否有票的条件.因为里面同步的时候除了一个线程在执行外,其它几个都在等待,而此时并没有跳出循环,当然会出现负数了.
当然把while判断放到同步代码里面去也可以.不过这样就没有超出票数的判断了,实际应用中应该有个超出票数的判断..例如:for(int i=0;i<100;i++)//同步检测只有5张票,显示100张,实际上卖出的还是5张..用来检测同步是否正确...
关于java ticket 是什么，java 多线程模拟火车售票系统问题的介绍到此结束，希望对大家有所帮助。