yyrm7.html

关于java学习的一些基本知识！

            MediaTracker(this); </P>
            <P>//Set the size and width of our applet maxWidth = 100; maxHeight 
            =100; </P>
            <P>images = new Image[10]; //Set up the double-buffer and resize our 
            applet try { offScrImage = createImage(maxWidth,maxHeight); offScrGC 
            = offScrImage.getGraphics(); offScrGC.setColor(Color.lightGray); 
            offScrGC.fillRect(0,0,maxWidth,maxHeight); 
            resize(maxWidth,maxHeight); }catch (Exception e) { 
            e.printStackTrace(); } </P>
            <P>//load the animation images into an array for (int 
            i=0;i&lt;10;i++) { String imageFile = new String ("images/Duke/T" 
            +String.valueOf(i+1) +".gif"); images[i] = 
            getImage(getDocumentBase(),imageFile): //Register this image with 
            the tracker tracker.addImage(images[i],i); } try { //Use tracker to 
            make sure all the images are loaded tracker.waitForAll(); } catch 
            (InterruptedException e) {} loaded = true; } </P>
            <P>//Paint the current frame. public void paint (Graphics g) { if 
            (loaded) { g.drawImage(offScrImage,0,0,this); } } </P>
            <P>//Start ,setup our first image public void start() { if 
            (tracker.checkID (index)) { offScrGC.drawImage 
            (images[index],0,0,this); } animator = new Thread(this); 
            animator.start(); } </P>
            <P>//Run,do the animation work here. //Grab an image, pause ,grab 
            the next... public void run() { //Get the id of the current thread 
            Thread me = Thread.currentThread(); </P>
            <P>//If our animator thread exist,and is the current thread... while 
            ((animatr!= null) &amp;&amp; (animator==me)) { if ( tracker.checkID 
            (index)) { //Clear the background and get the next image 
            offScrGC.fillRect(0,0,100,100); 
            offScrGCdrawImage(images[index],0,0,this); index++; //Loop back to 
            the beginning and keep going if (index&gt;= images.length) { index = 
            0; } } //Delay here so animation looks normal try { 
            animator.sleep(200); }catch (InterruptedException e) {} //Draw the 
            next frame repaint(); } } } </P>
            <H2 align=center>7.3 多 线 程 ?reg; 间 的 通 讯</H2>
            <H3 align=center>7.3.1 生 产 者 和 消 费 者 </H3>
            <P>多 线 程 的 一 个 重 要 特 点 是 它 们 ?reg; 间 可 以 互 相 通 讯。你 可 以 设 计 线 程 使 用 公 
            用 对 象， 每 个 线 程 都 可 以 独 立 操作 公 用 对 象。 典 型 的 线 程 间 通 讯 建 立 在 生 产 者 和 消 
            费 者模 型 上： 一 个 线 程 产 生 输 出； 另 一 个 线 程 使 用 输 入。 </P>
            <P>buffer </P>
            <P>让 我 们 创 建 一 个 简 单 的"Alphabet Soup"生 产 者 和 相应 的 消 费 者. </P>
            <H3 align=center>7.3.2 生 产 者 </H3>
            <P>生 产 者 将 从thread类 里 派 生： class Producer extends Thread { private 
            Soup soup; private String alphabet = " ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
            </P>
            <P>public Producer(Soup s) { //Keep our own copy of the shared 
            object soup = s; } </P>
            <P>public void run() { char c; //Throw 10 letters into the soup for 
            (int i=0;i&lt;10;i++) { c = alphabet.charAt((int)(Math.random() 
            *26)); soup.add(c); //print a record of osr addition 
            System.out.println("Added"+c + "to the soup."); //wait a bit before 
            we add the next letter try { sleep((int)(Math.random() *1000)); } 
            catch (InterruptedException e) {} } } } </P>
            <P>注 意 我 们 创 建 了Soup类 的 一 个 实 例。 生 产 者 用soup.add()函数 来 建 立 字 符 池。 
            </P>
            <H3 align=center>7.3.3 消 费 者</H3>
            <P>让 我 们 看 看 消 费 者 的 程 序： class Consumer extends Thread { private 
            Soup soup; </P>
            <P>public Consumer (Soup s) { //keep our own copy of the shared 
            object soup = s; } </P>
            <P>public void run() { char c; //Eat 10 letters from the alphabet 
            soup for (int I=0 ;i&lt;10;i++) { //grab one letter c = soup.eat(); 
            //Print out the letter that we retrieved System.out.println("Ate a 
            letter: " +c); //try { sleep((int)(Math.raddom()*2000)); } catch 
            (InterruptedException e) {} } } } </P>
            <P>同 理， 象 生 产 者 一 样， 我 们 用soup.eat()来 处 理 信 息。 那 么，Soup类到 底 干 什 么 呢？ 
            </P>
            <H3 align=center>7.3.4 监 视 </H3>
            <P>Soup类 执 行 监 视 两 个 线 程 ?reg; 间 传 输 信 息 的 功 能。 监 视是 多 线 程 中 不 可 缺 少 
            的 一 部 分， 因 为 它 保 持 了 通 讯 的 流 ?copy;。 让 我 们 看 看Soup.java文 件： class 
            Soup { private char buffer[] = new char[6]; private int next = 0; 
            //Flags to keep track of our buffer status private boolean isFull = 
            false; private boolean isEmpty = true; </P>
            <P>public syschronized char eat() { //We can't eat if there isn't 
            anything in the buffer while (isEmpty == true) { try { wait() 
            ;//we'll exit this when isEmpty turns false }catch 
            (InterruptedException e) {} } //decrement the count,since we're 
            going to eat one letter next--; //Did we eat the last letter? if 
            (next== 0) { isEmpty = true; } //We know the buffer can't be 
            full,because we just ate isFull = false; notify(); //return the 
            letter to the thread that is eating return (buffer[next]); } </P>
            <P>//method to add letters to the buffer public synchronized void 
            add(char c) { //Wait around until there's room to add another letter 
            while (isFull == true ) { try{ wait();//This will exit when isFull 
            turns false }catch (InterruptedException e) {} } //add the letter to 
            the next available spot buffer[next]=c; //Change the next available 
            spot next++; //Are we full; if (next ==6) { isFull =true; } isEmpty 
            =false; notify(); } } </P>
            <P>soup类 包 含 两 个 重 要 特 征： 数 据 成 员buffer[]是 私 有 的， 功能 成 员add()和eat()是 
            公 有 的。 </P>
            <P>数 据 私 有 避 免 了 生 产 者 和 消 费 者 直 接 获 得 数 据。 直 接访 问 数 据 可 能 造 成 错 误。 
            例 如， 如 果 消 费 者 企 图 从 空 缓 冲区 里 取 出 数 据， 你 将 得 到 不 必 要 的 异 常， 否 则， 你 只 
            能 锁住 进 程。 同 步 访 问 方 法 避 免 了 破 坏 一 个 共 享 对 象。 当 生 产者 向soup里 加 入 一 个 字 
            母 时， 消 费 者 不 能 吃 字 符， 诸 如 此 类。这 种 同 步 是 维 持 共 享 对 象 完 整 性 的 重 要 方 
            面。notify()函 数将 唤 醒 每 一 个 等 待 线 程。 等 待 线 程 将 继 续 它 的 访 问。 </P>
            <H3 align=center>7.3.5 联 系 起 来 </H3>
            <P>现 在 我 们 有 一 个 生 产 者， 一 个 消 费 者 和 一 个 共 享 对 象，怎 样 实 现 它 们 的 交 互 呢？ 
            我 们 只 需 要 一 个 简 单 的 控 制 程序 来 启 动 所 有 的 线 程 并 确 信 每 一 个 线 程 都 是 访 问 的 
            同 一个 共 享 对 象。 下 面 是 控 制 程 序 的 代 码，SoupTest.java: class SoupTest { 
            public static void main(String args[]) { Soup s = new Soup(); 
            Producer p1 = new Producer(s); Consumer c1 = new Consumer(s); </P>
            <P>p1.start(); c1.start(); } } </P>
            <H3 align=center>7.3.6 监 视 生 产 者 </H3>
            <P>生 产 者/消 费 者 模 型 程 序 经 常 用 来 实 现 远 程 监 视 功 能，它 让 消 费 者 看 到 生 产 者 同 
            用 户 的 交 互 或 同 系 统 其 它 部 分的 交 互。 例 如， 在 网 络 中， 一 组 生 产 者 线 程 可 以 在 很 
            多 工作 站 上 运 行。 生 产 者 可 以 打 印 文 档， 文 档 打 印 后， 一 个 标志 将 保 存 下 来。 一 个（或 
            多 个?copy; 消 费 者 将 保 存 标 志 并 在晚 上 报 告 白 天 打 印 活 动 的 情 况。 另 外， 还 有 例 子 
            在 一 个 工作 站 是 分 出 几 个 独 立 的 窗 口。 一 个 窗 口 用 作 用 户 输 入（生产 者?copy;， 另 一 
            个 窗 口 作 出 对 输 入 的 反 应（消 费 者?copy;。 </P>
            <H2 align=center>7.4 线 程API列 表 </H2>
            <P>下 面 是 一 ?copy; 常 用 的 线 程 类 的 方 法 函 数 列 表： </P>
            <P>类 函 数： 以 下 是Thread的 静 态 函 数， 即 可 以 直 接 从Thread类调 用。 </P>
            <P>currentThread 返 回 正 在 运 行 的Thread对 象 yield 停 止 运 行 当 前线 程， 让 系 统 
            运 行 下 一 个 线 程 sleep(int n) 让 当 前 线 程 睡 眠n毫秒 </P>
            <P>对 象 函 数： 以 下 函 数 必 须 用Thread的 实 例 对 象 来 调 用。 </P>
            <P>start start函 数 告 诉java运 行 系 统 为 本 线 程 建 立 一 个 执 行环 境， 然 后 调 用 本 线 
            程 的run()函 数。 run 是 运 行 本 线 程 的 将要 执 行 的 代 码， 也 是Runnable接 口 的 唯 一 函 
            数。 当 一 个 线 程初 始 化 后， 由start函 数 来 调 用 它， 一 ?copy;run函 数 返 回， 本线 程 也 就 
            终 止 了。 stop 让 某 线 程 马 上 终 止， 系 统 将 删 除 本线 程 的 执 行 环 境 suspend 与stop函 
            数 不 同，suspend将 线 程 暂 停 执行， 但 系 统 不 破 坏 线 程 的 执 行 环 境， 你 可 以 用resume来 
            恢 复本 线 程 的 执 行 resume 恢 复 被 挂 起 的 线 程 进 入 运 行 状 态 setPriority(int p) 
            给 线 程 设 置 优 先 级 getPriority 返 回 线 程 的 优 先 级 setName(String name) 给 线 
            程 设 置 名 称 getName 取 线 程 的 名 称 </P>
            <H2 align=center>本 章 小 结： </H2>
            <P>1.多 线 程 是java语 言 的 重 要 特 点，java语 言 用Thread类 封 装 了线 程 的 所 有 操 作。 
            2.线 程 的 接 口 名 为Runnable 3.线 程 ?reg; 间同 步 机 制 为synchronized关 键 词 4.线 
            程 ?reg; 间 通 讯 靠wait与notify消息 </P></TD>
        <TR>
        <TR>
          <TD bgColor=#f0f0f0 borderColor=#ffffff class=t1 noWrap 
            width="50%"><IMG height=12 src="yyrm7.files/yellow_dot.gif" 
            width=12><A 
            href="http://www.chinajavaworld.net/doc/yyrm/yyrm6.html">上一章</A> </TD>
          <TD bgColor=#f0f0f0 borderColor=#ffffff class=t1 noWrap 
            width="50%"><IMG height=12 src="yyrm7.files/blue_dot.gif" 
            width=12><A 
            href="http://www.chinajavaworld.net/doc/yyrm/yyrm8.html">下一章</A> </TD>
        <TR></TR></TBODY></TABLE></TD></TR></TBODY></TABLE><!--end first table --><!--  start foot -->
<SCRIPT src="yyrm7.files/foot1.js"></SCRIPT>

<SCRIPT src="yyrm7.files/adsindex.js"></SCRIPT>

<SCRIPT src="yyrm7.files/foot2.js"></SCRIPT>
<!--  end foot --></CENTER></BODY></HTML>