7.1.3同步

　　因为多线程给你提?copy;了程序的异步执行的功能，所以在必要时必须还提?copy;一种同步机制。例如，你想两个线程通讯并共享一个复杂的数据结构，你需要一种机制让他们相互牵制并正确执行。为这个目的，Java用一种叫监视器(monitor)的机制实现了进程间的异步执行。可以将监视器看作是一个很小的盒子，它只能容纳一个线程。一?copy;一个线程进入一个监视器，所有其他线程必须等到第一个线程退出监视器后才能进入。这?copy;监视器可以设计成保护共享的数据不被多个线程同时操作。大多数多线程系统将这?copy;监视器设计成对象，Java提?copy;了一种更清晰的解决方案。没有Monitor类;每个对象通过将他们的成员函数定义成synchronized来定义自己的显式监视器，一?copy;一个线程执行在一个synchronized函数里，其他任何线程都不能调用同一个对象的

　　synchronized函数。

　　7.1.4消息

　　你的程序被分成几个逻辑线程，你必须清晰的知道这?copy;线程?reg;间应怎样相互通讯。Java提了wait和notify等功能来使线程?reg;间相互交谈。一个线程可以进入某一个对象的synchronized函数进入等待状态，直到其他线程显式地将它唤醒。可以有多个线程进入同一个函数并等待同一个唤醒消息。

　　7.2Java线程例子

　　7.2.1显式定义线程

　　在我们的单线程应用程序里，我们并没有看见线程，因为Java能自动创建和控制你的线程。如果你使用了理解Java语言的浏览器，你就已经看到使用多线程的Java程序了。你也许注意到两个小程序可以同时运行，或在你移动滚动条时小程序继续执行。这并不是表明小程序是多线程的，但说明这个浏览器是多线程的。多线程应用程序(或applet)可以使用好几个执行上下文来完成它们的工

　　作。多线程利用了很多任务包含单独的可分离的子任务的特点。每一个线程完成一个子任务。但是，每一个线程完成子任务时还是顺序执行的。一个多线程程序允许各个线程尽快执行完它们。这种特点会有更好的实时输入反应。

　　7.2.2多线程例子

　　下面这个例子创建了三个单独的线程，它们分别打印自己的\"HelloWorld\":

　　//Defineoursimplethreads.Theywillpauseforashorttime//andthen

　　printouttheirnamesanddelaytimesclassTestThreadextendsThread

　　{privateStringwhoami;privateintdelay;

　　//Ourconstructortostorethename(whoami)//andtimetosleep(delay)

　　publicTestThread(Strings,intd){whoami=s;delay=d;}

　　//Run-thethreadmethodsimilartomain()//Whenrunisfinished,the

　　threaddies.//Runiscalledfromthestart()methodofThreadpublicvoid

　　run(){//Trytosleepforthespecifiedtimetry{sleep(delay);}

　　catch(InterruptedExceptione){}//Nowprintoutourname

　　System.out.println(\"HelloWorld!\"+whoami+\"\"+delay);}}/***Multimtest.

　　Asimplemultithreadthestprogram*/publicclassmultitest{public

　　staticvoidmain(Stringargs[]){TestThreadt1,t2,t3;//Createourtest

　　threadst1=newTestThread(\"Thread1\",(int)(Math.readom()*2000));t2=

　　newTestThread(\"Thread2\",(int)(Math.readom()*2000));t3=new

　　TestThread(\"Thread3\",(int)(Math.readom()*2000));

　　//Starteachofthethreadst1.start();t2.start();t3.start();}}

　　7.2.3启动一个线程

　　程序启动时总是调用main()函数，因此main()是我们创建和启动线程的地方：

　　t1=newTestThread(\"Thread1\",(int)(Math.readom()*2000));

　　这一行创建了一个新的线程。后面的两个参数传递了线程的名称和线程在打印信息?reg;前的延时时间。因为我们直接控制线程，我们必须直接启动它：t1.start();

　　7.2.4操作线程

　　如果创建线程正常，t1应包含一个有效的执行线程。我们在线程的run()函数里控制线程。一?copy;我们进入run()函数，我们便可执行里面的任何程序。run()好象main()一样。

　　run()执行完，这个线程也就结束了。在这个例子里，我们试着延迟一个随机的时间(通过参数传递?)sleep(delay);

　　sleep()函数只是简单地告诉线程休息多少个毫秒时间。

　　如果你想推迟一个线程的执行，你应使用sleep()函数。当线程睡眠是sleep()并不占用系统资源。其它线程可继续工作。一?copy;延迟时间完毕，它将打印\"HelloWorld\"和线程名称及延迟时间。

　　7.2.5暂停一个线程

　　我们经常需要挂起一个线程而不指定多少时间。例如，如果你创建了一个含有动画线程的小程序。也许你让用户暂停动画至到他们想恢复为止。你并不想将动画线程仍调，但想让它停止。象这种类似的线程你可用suspend()函数来控制：t1.suspend();这个函数并不永久地停止了线程，你还可用resume()函数重新激活线程：t1.resume();

　　7.2.6停止一个线程

　　线程的最后一个控制是停止函数stop()。我们用它来停止线程的执行：t1.stop();

　　注意：这并没有消灭这个线程，但它停止了线程的执行。并且这个线程不能用t1.start()重新启动。在我们的例子里，我们从来不用显式地停止一个线程。我们只简单地让它执行完而已。很多复杂的线程例子将需要我们控制每一个线程。在这种情况下会使用到stop()函数。如果需要，你可以测试你的线程是否被激活。一个线程已经启动而且没有停止被认为是激活的。t1.isAlive()如果t1是激活的，这个函数将返回true.

　　7.2.7动画例子

　　下面是一个包含动画线程的applet例子：

　　importjava.awt.*;importjava.awt.image.ImageProducer;import

　　java.applet.Applet;

　　publicclassatest3extendsAppletimplementsRunnable{Imageimages[];

　　MediaTrackertracker;intindex=0;Threadanimator;

　　intmaxWidth,maxHeight;//Ouroff-screencomponentsfordoublebuffering.

　　ImageoffScrImage;GraphicsoffScrGC;

　　//Canwepaintyes?booleanloaded=false;

　　//Initializetheapplet.Setoursizeandloadtheimagespublicvoidinit()

　　[//Setupourimagemonitortracker=newMediaTracker(this);

　　//SetthesizeandwidthofourappletmaxWidth=100;maxHeight=100;

　　images=newImage[10];//Setupthedouble-bufferandresizeourapplet

　　try{offScrImage=createImage(maxWidth,maxHeight);offScrGC=

　　offScrImage.getGraphics();offScrGC.setColor(Color.lightGray);

　　offScrGC.fillRect(0,0,maxWidth,maxHeight);

　　resize(maxWidth,maxHeight);}catch(Exceptione)

　　{e.printStackTrace();}

　　//loadtheanimationimagesintoanarrayfor(inti=0;i

　　imageFile=newString(\"images/Duke/T\"+String.valueOf(i+1)+\".gif\");

　　images[i]=getImage(getDocumentBase(),imageFile)://Registerthis

　　imagewiththetrackertracker.addImage(images[i],i);}try{//Use

　　trackertomakesurealltheimagesareloadedtracker.waitForAll();}

　　catch(InterruptedExceptione){}loaded=true;}

　　//Paintthecurrentframe.publicvoidpaint(Graphicsg){if(loaded)

　　{g.drawImage(offScrImage,0,0,this);}}

　　//Start,setupourfirstimagepublicvoidstart(){if(tracker.checkID

　　(index)){offScrGC.drawImage(images[index],0,0,this);}animator=new

　　Thread(this);animator.start();}

　　//Run,dotheanimationworkhere.//Grabanimage,pause,grabthenext...

　　publicvoidrun(){//GettheidofthecurrentthreadThreadme=

　　Thread.currentThread();

　　//Ifouranimatorthreadexist,andisthecurrentthread...while

　　((animatr!=null)&&(animator==me)){if(tracker.checkID(index))

　　{//Clearthebackgroundandgetthenextimage

　　offScrGC.fillRect(0,0,100,100);

　　offScrGCdrawImage(images[index],0,0,this);index++;//Loopbacktothe

　　beginningandkeepgoingif(index>=images.length){index=0;}}

　　//Delayheresoanimationlooksnormaltry{animator.sleep(200);}catch

　　(InterruptedExceptione){}//Drawthenextframerepaint();}}}

　　7.3多线程间的通讯

　　7.3.1生产者和消费者

　　多线程的一个重要特点是它们?reg;间可以互相通讯。你可以设计线程使用公用对象，每个线程都可以独立操作公用对象。典型的线程间通讯建立在生产者和消费者模型上：一个线程产生输出;另一个线程使用输入buffer

　　让我们创建一个简单的\"AlphabetSoup\"生产者和相应的消费者.

　　7.3.2生产者

　　生产者将从thread类里派生：classProducerextendsThread

　　{privateSoupsoup;privateStringalphabet=\"

　　ABCDEFGHIJKLMNOPQRSTUVWXYZ\";

　　publicProducer(Soups){//Keepourowncopyofthesharedobjectsoup

　　=s;}

　　publicvoidrun(){charc;//Throw10lettersintothesoupfor(int

　　i=0;i

　　soup.add(c);//printarecordofosraddition

　　System.out.println(\"Added\"+c+\"tothesoup.\");//waitabitbeforewe

　　addthenextlettertry{sleep((int)(Math.random()*1000));}catch

　　(InterruptedExceptione){}}}}

　　注意我们创建了Soup类的一个实例。生产者用soup.add()函数来建立字符池。

　　7.3.3消费者

　　让我们看看消费者的程序：classConsumerextendsThread{privateSoupsoup;

　　publicConsumer(Soups){//keepourowncopyofthesharedobjectsoup

　　=s;}

　　publicvoidrun(){charc;//Eat10lettersfromthealphabetsoupfor

　　(intI=0;i

　　letterthatweretrievedSystem.out.println(\"Atealetter:\"+c);//try

　　{sleep((int)(Math.raddom()*2000));}catch(InterruptedExceptione){}}}}

　　同理，象生产者一样，我们用soup.eat()来处理信息。那么，Soup类到底干什么呢?

　　7.3.4监视

　　Soup类执行监视两个线程?reg;间传输信息的功能。监视是多线程中不可缺少的一部分，因为它保持了通讯的流?copy;。让我们看看Soup.java文件：classSoup{privatecharbuffer[]=newchar[6];privateintnext=0;//Flagstokeeptrackof

　　ourbufferstatusprivatebooleanisFull=false;privatebooleanisEmpty

　　=true;publicsyschronizedchareat(){//Wecan\'teatifthereisn\'tanything

　　inthebufferwhile(isEmpty==true){try{wait();//we\'llexitthis

　　whenisEmptyturnsfalse}catch(InterruptedExceptione){}}//decrement

　　thecount,sincewe\'regoingtoeatoneletternext--;//Didweeatthe

　　lastletter?if(next==0){isEmpty=true;}//Weknowthebuffercan\'t

　　befull,becausewejustateisFull=false;notify();//returntheletter

　　tothethreadthatiseatingreturn(buffer[next]);}

　　//methodtoaddletterstothebufferpublicsynchronizedvoidadd(char

　　c){//Waitarounduntilthere\'sroomtoaddanotherletterwhile(isFull

　　==true){try{wait();//ThiswillexitwhenisFullturnsfalse}catch

　　(InterruptedExceptione){}}//addthelettertothenextavailablespot

　　buffer[next]=c;//Changethenextavailablespotnext++;//Arewefull;

　　if(next==6){isFull=true;}isEmpty=false;notify();}}soup类包含两个重要特征：数据成员buffer[]是私有的，功能成员add()和eat()是公有的。

　　数据私有避免了生产者和消费者直接获得数据。直接访问数据可能造成错误。例如，如果消费者企图从空缓冲区里取出数据，你将得到不必要的异常，否则，你只能锁住进程。同步访问方法避免了破坏一个共享对象。当生产者向soup里加入一个字母时，消费者不能吃字符，诸如此类。这种同步是维持共享对象完整性的重要方面。notify()函数将唤醒每一个等待线程。等待线程将继续它的访问。

　　7.3.5联系起来

　　现在我们有一个生产者，一个消费者和一个共享对象，怎样实现它们的交互呢?我们只需要一个简单的控制程序来启动所有的线程并确信每一个线程都是访问的同一个共享对象。下面是控制程序的代码，SoupTest.java:

　　classSoupTest{publicstaticvoidmain(Stringargs[]){Soups=new

　　Soup();Producerp1=newProducer(s);Consumerc1=newConsumer(s);

　　p1.start();c1.start();}}

　　7.3.6监视生产者

　　生产者/消费者模型程序经常用来实现远程监视功能，它让消费者看到生产者同用户的交互或同系统其它部分的交互。例如，在网络中，一组生产者线程可以在很多工作站上运行。生产者可以打印文档，文档打印后，一个标志将保存下来。一个(或多个?copy;消费者将保存标志并在晚上报告白天打印活动的情况。另外，还有例子在一个工作站是分出几个独立的窗口。一个窗口用作用户输入(生产者)另一个窗口作出对输入的反应(消费者)。

　　7.4线程API列表

　　下面是一个常用的线程类的方法函数列表：类函数：以下是Thread的静态函数，即可以直接从Thread类调用。

　　currentThread返回正在运行的Thread对象yield停止运行当前线程，让系统运行下一个线程sleep(intn)让当前线程睡眠n毫秒对象函数：以下函数必须用Thread的实例对象来调用。

　　startstart函数告诉java运行系统为本线程建立一个执行环境，然后调用本线程的run()函数。run是运行本线程的将要执行的代码，也是Runnable接口的唯一函数。当一个线程初始化后，由start函数来调用它，一?copy;run函数返回，本线程也就终止了。stop让某线程马上终止，系统将删除本线程的执行环境suspend与stop函数不同，suspend将线程暂停执行，但系统不破坏线程的执行环境，你可以用resume来恢复本线程的执行resume恢复被挂起的线程进入运行状态setPriority(intp)给线程设置优先级getPriority返回线程的优先级setName(Stringname)给线程设置名称getName取线程的名称

　　本章小结：

　　1.多线程是java语言的重要特点，java语言用Thread类封装了线程的所有操作。

　　2.线程的接口名为Runnable

　　3.线程间同步机制为synchronized关键词

　　4.线程间通讯靠wait与notify消息