Java多線程實現退電影票

① 100張票，用java多線程實現3個窗口按順序依次賣票，如何實現

很簡單, 出票里加鎖就行了完整代碼:

publicclassTest{
	publicstaticvoidmain(String[]args){
		
		for(inti=0;i<3;i++){
			newThread("線程"+i){
				publicvoidrun(){
					while(true){
						intp=getNumber();
						if(p>0){
							System.out.println(getName()+"票號:"+p);
						}else{
							System.out.println("沒票了");
							break;
						}
					}
				};
			}.start();
		}
	}
	
	
	
	
	publicstaticintnum=100;		//總票數
	
	/**
	*synchronized同步鎖
	*@return
	*/
	(){
		if(num>0){
			returnnum--;				//如果大於0,則返回當前票並減少一張
		}
		return0;
	}
}

② java怎麼讓一個方法實現線程

Java提供了線程類Thread來創建多線程的程序。其實，創建線程與創建普通的類的對象的操作是一樣的，而線程就是Thread類或其子類的實例對象。每個Thread對象描述了一個單獨的線程。要產生一個線程，有兩種方法：
◆需要從Java.lang.Thread類派生一個新的線程類，重載它的run()方法；
◆實現Runnalbe介面，重載Runnalbe介面中的run()方法。

為什麼Java要提供兩種方法來創建線程呢？它們都有哪些區別？相比而言，哪一種方法更好呢？
在Java中，類僅支持單繼承，也就是說，當定義一個新的類的時候，它只能擴展一個外部類.這樣，如果創建自定義線程類的時候是通過擴展 Thread類的方法來實現的，那麼這個自定義類就不能再去擴展其他的類，也就無法實現更加復雜的功能。因此，如果自定義類必須擴展其他的類，那麼就可以使用實現Runnable介面的方法來定義該類為線程類，這樣就可以避免Java單繼承所帶來的局限性。
還有一點最重要的就是使用實現Runnable介面的方式創建的線程可以處理同一資源，從而實現資源的共享.
（1）通過擴展Thread類來創建多線程
假設一個影院有三個售票口，分別用於向兒童、成人和老人售票。影院為每個窗口放有100張電影票，分別是兒童票、成人票和老人票。三個窗口需要同時賣票，而現在只有一個售票員，這個售票員就相當於一個CPU，三個窗口就相當於三個線程。通過程序來看一看是如何創建這三個線程的。

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

程序中定義一個線程類，它擴展了Thread類。利用擴展的線程類在MutliThreadDemo類的主方法中創建了三個線程對象，並通過start()方法分別將它們啟動。
從結果可以看到，每個線程分別對應100張電影票，之間並無任何關系，這就說明每個線程之間是平等的，沒有優先順序關系，因此都有機會得到CPU的處理。但是結果顯示這三個線程並不是依次交替執行，而是在三個線程同時被執行的情況下，有的線程被分配時間片的機會多，票被提前賣完，而有的線程被分配時間片的機會比較少，票遲一些賣完。
可見，利用擴展Thread類創建的多個線程，雖然執行的是相同的代碼，但彼此相互獨立，且各自擁有自己的資源，互不幹擾。
（2）通過實現Runnable介面來創建多線程

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

由於這三個線程也是彼此獨立，各自擁有自己的資源，即100張電影票，因此程序輸出的結果和（1）結果大同小異。均是各自線程對自己的100張票進行單獨的處理，互不影響。
可見，只要現實的情況要求保證新建線程彼此相互獨立，各自擁有資源，且互不幹擾，採用哪個方式來創建多線程都是可以的。因為這兩種方式創建的多線程程序能夠實現相同的功能。

由於這三個線程也是彼此獨立，各自擁有自己的資源，即100張電影票，因此程序輸出的結果和例4.2.1的結果大同小異。均是各自線程對自己的100張票進行單獨的處理，互不影響。
可見，只要現實的情況要求保證新建線程彼此相互獨立，各自擁有資源，且互不幹擾，採用哪個方式來創建多線程都是可以的。因為這兩種方式創建的多線程程序能夠實現相同的功能。
（3）通過實現Runnable介面來實現線程間的資源共享
現實中也存在這樣的情況，比如模擬一個火車站的售票系統，假如當日從A地發往B地的火車票只有100張，且允許所有窗口賣這100張票，那麼每一個窗口也相當於一個線程，但是這時和前面的例子不同之處就在於所有線程處理的資源是同一個資源，即100張車票。如果還用前面的方式來創建線程顯然是無法實現的，這種情況該怎樣處理呢？看下面這個程序，程序代碼如下所示：

+ View Code
結果正如前面分析的那樣，程序在內存中僅創建了一個資源，而新建的三個線程都是基於訪問這同一資源的，並且由於每個線程上所運行的是相同的代碼，因此它們執行的功能也是相同的。
可見，如果現實問題中要求必須創建多個線程來執行同一任務，而且這多個線程之間還將共享同一個資源，那麼就可以使用實現Runnable介面的方式來創建多線程程序。而這一功能通過擴展Thread類是無法實現的，讀者想想看，為什麼？
實現Runnable介面相對於擴展Thread類來說，具有無可比擬的優勢。這種方式不僅有利於程序的健壯性，使代碼能夠被多個線程共享，而且代碼和數據資源相對獨立，從而特別適合多個具有相同代碼的線程去處理同一資源的情況。這樣一來，線程、代碼和數據資源三者有效分離，很好地體現了面向對象程序設計的思想。因此，幾乎所有的多線程程序都是通過實現Runnable介面的方式來完成的。

③ 一道java方面的題目

importjava.lang.Thread;

classTicketSeller{

staticprivateintfiveNumber=1;//5元錢張數

staticprivateinttenNumber=0;//10元錢張數

staticprivateinttwentyNumber=0;//20元錢張數

publicintgetFiveNumber(){

returnTicketSeller.fiveNumber;

}

publicintgetTenNumber(){

returnTicketSeller.tenNumber;

}

publicintgetTwentyNumber(){

returnTicketSeller.twentyNumber;

}

(intreceiveMoney){

switch(receiveMoney){

case5:

TicketSeller.fiveNumber++;

break;

case10:

TicketSeller.tenNumber++;

break;

case20:

TicketSeller.twentyNumber++;

break;

default:

System.out.println("不能購買!");

}

}

}

classPeopleextendsThread{

privateTicketSellerseller=newTicketSeller();

privateStringname;

privateintmoney;

publicPeople(Stringname,intmoney){

this.name=name;

this.money=money;

this.start();

}

publicvoidrun(){

seller.sellTicket(money);

System.out.println(name+"購買"+money+"元的票，售票員當前：5元---"+seller.getFiveNumber()+"張10元---"+seller.getTenNumber()+"張20元---"+seller.getTwentyNumber()+"張");

}

}

classTest{

publicstaticvoidmain(String[]str){

Peoplep1=newPeople("張三",20);

Peoplep2=newPeople("李四",10);

Peoplep3=newPeople("王五",5);

Peoplep4=newPeople("張三1",20);

Peoplep5=newPeople("李四2",10);

Peoplep6=newPeople("王五3",5);

Peoplep7=newPeople("張三4",20);

Peoplep8=newPeople("李四5",10);

Peoplep9=newPeople("王五6",5);

}

}

④ 用java實現賣電影票的程序,實現5個窗口同時售賣100張票.(用數組保存)

{
	@Override
	publicvoidrun()
	{
		Stringname=Thread.currentThread().getName();
		while(name.startsWith("窗口"))
		{
			if(tickets.length==0)
			{
				stop();
				break;
			}
			intnum=(int)(Math.random()*tickets.length)+1;
			tickets=newint[tickets.length-num];
			System.out.println(name+"售出了"+num+"張票");
			try
			{
				Thread.sleep(500);
			}
			catch(InterruptedExceptione)
			{}
		}
	}

	publicsynchronizedvoidstart()
	{
		for(inti=0;i<ts.length;i++)
		{
			Threadthread=ts[i];
			if(thread==null)
			{
				thread=newThread(this);
				thread.setPriority(Thread.MIN_PRIORITY);
				thread.setName("窗口"+(i+1));
				thread.start();
			}
		}
	}

	publicsynchronizedvoidstop()
	{
		for(inti=0;i<ts.length;i++)
		{
			Threadthread=ts[i];
			if(thread!=null)
			{
				thread.interrupt();
			}
			thread=null;
		}
		notifyAll();
	}

	staticint[]tickets=newint[100];

	privatestaticintWIN=5;

	Thread[]ts=newThread[WIN];

	publicstaticvoidmain(String[]args)
	{
		newYugi().start();
	}
}

⑤ java多線程的賣票問題

首先，定義的鎖（lock）不對，必須是同一個鎖，像你這樣用this，new多少個MyThread就有多少個鎖，違反了線程的同步機制；

其次，你如果想要呈現多線程的競爭，不可以在run方法里讓一個線程一直運行而不釋放鎖，應該使用wait()/notify()；

以下我稍微修改下，會形成兩個線程交替執行的情形：

publicclassThreadTest{
	publicstaticObjectobj=newObject();
	publicstaticintnumber=10;//用static共享票源，不知道可以不，按理說是可以的

	/**
	*@paramargs
	*/
	publicstaticvoidmain(String[]args){
		//TODOAuto-generatedmethodstub
		MyThreadmy=newMyThread();
		MyThreadmy2=newMyThread();
		Threadt1=newThread(my2,"2號窗口");
		Threadt2=newThread(my,"1號窗口");
		t1.start();
		t2.start();
	}

	{

		publicvoidrun(){
			while(true)
				synchronized(obj){
					if(number>0){
						System.out.println(Thread.currentThread().getName()
								+"正在賣票,"+"還剩"+number+"張票");
						number--;
						obj.notifyAll();
						try{
							obj.wait();
						}catch(InterruptedExceptione){
							//TODOAuto-generatedcatchblock
							e.printStackTrace();
						}

					}else
						break;
				}

		}
	}
}