yyrm7.html

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

            每 一 帧 ?reg; 间 停 顿 一 秒 而 并 不 使系 统 暂 停。 一 ?copy; 线 程 启 动 后， 它 可 以 被 挂 
            起， 暂 时 不让 它 执 行。 挂 起 的 线 程 可 以 重 新 恢 复 执 行。 任 何 时 间 线 程都 可 以 被 停 止， 
            被 停 止 的 线 程 就 不 能 再 重 新 启 动。 Java语言 里， 线 程 表 现 为 线 程 类， 线 程 类 封 装 了 
            所 有 需 要 的 线 程操 作 控 制。 在 你 心 里， 必 须 很 清 晰 地 区 分 开 线 程 对 象 和 运行 线 程， 你 
            可 以 将 线 程 对 象 看 作 是 运 行 线 程 的 控 制 面 板。在 线 程 对 象 里 有 很 多 函 数 来 控 制 一 
            个 线 程 是 否 运 行， 睡眠， 挂 起 或 停 止。 线 程 类 是 控 制 线 程 行 为 的 唯 一 的 手 段。一 
            ?copy; 一 个Java程 序 启 动 后， 就 已 经 有 一 个 线 程 在 运 行。你 可 通 过 调 
            用Thread.currentThread 函 数 来 查 看 当 前 运 行 的 是哪 一 个 线 程。 一 ?copy; 你 得 到 
            一 个 线 程 的 控 制 柄， 你 就 可以 作 一 ?copy; 很 有 趣 的 事 情， 即 使 单 线 程 也 一 样。 下 面 
            这个 例 子 让 你 知 道 怎 样 操 纵 当 前 线 程。 Filename:testthread </P>
            <P>class testthread { public static void main(String args[]) { 
            Thread t =Thread.currentThread(); t.setName("This Thread is 
            running"); System.out.println("The running thread:" + t); try { for 
            (int i=0;i&lt;5;i++) { System.out.println("Sleep time "+i); 
            Thread.sleep(1000); } </P>
            <P>} catch (InterruptedException e) {System.out.println("thread has 
            wrong"); } </P>
            <P>} } </P>
            <P>执 行 结 果：java testthread The running thread:Thread[This Thread is 
            running,5,main] Sleep time 0 Sleep time 1 Sleep time 2 Sleep time 3 
            Sleep time 4 </P>
            <H3 align=center>7.1.2 启 动 接 口</H3>
            <P>一 个 线 程 并 不 激 动 人 心， 多 个 线 程 才 有 实 际 意 义。 我 们怎 样 创 建 更 多 的 线 程 呢？ 
            我 们 需 要 创 建 线 程 类 的 另 一 个实 例。 当 我 们 构 造 了 线 程 类 的 一 个 新 的 实 例， 我 们 必 
            须 告诉 它 在 新 的 线 程 里 应 执 行 哪 一 段 程 序。 你 可 以 在 任 意 实现 了 启 动 接 口 的 对 象 上 
            启 动 一 个 线 程。 启 动 接 口 是 一 个抽 象 接 口， 来 表 示 本 对 象 有 一 ?copy; 函 数 想 异 步 
            执 行。 要实 现 启 动 接 口， 一 个 类 只 需 要 有 一 个 叫run的 函 数。 下 面 是创 建 一 个 新 线 程 的 
            例 子： </P>
            <P>Filename:twothread.java </P>
            <P>class twothread implements Runnable { twothread() { Thread t1 
            =Thread.currentThread(); t1.setName("The first main thread"); 
            System.out.println("The running thread:" + t1); Thread t2 = new 
            Thread(this,"the second thread"); System.out.println("creat another 
            thread"); t2.start(); try { System.out.println("first thread will 
            sleep"); Thread.sleep(3000); }catch (InterruptedException e) 
            {System.out.println("first thread has wrong"); } 
            System.out.println("first thread exit"); } public void run() { try { 
            for (int i=0;i&lt;5;i++) { System.out.println("Sleep time for thread 
            2:"+i); Thread.sleep(1000); } </P>
            <P>} catch (InterruptedException e) {System.out.println("thread has 
            wrong"); } </P>
            <P>System.out.println("second thread exit"); } public static void 
            main(String args[]) { new twothread(); } } </P>
            <P>执 行 结 果：java twothread </P>
            <P>The running thread:Thread[The first main thread,5,main] creat 
            another thread first thread will sleep Sleep time for thread 2:0 
            Sleep time for thread 2:1 Sleep time for thread 2:2 first thread 
            exit Sleep time for thread 2:3 Sleep time for thread 2:4 second 
            thread exit </P>
            <P>main线 程 用new Thread(this, "the second thread")创 建 了一 个Thread对 象， 
            通 过 传 递 第 一 个 参 数 来 标 明 新 线 程 来 调 用this对象 的run函 数。 然 后 我 们 调 用start函 
            数， 它 将 使 线 程 从run函 数开 始 执 行。 </P>
            <H3 align=center>7.1.3 同 步 </H3>
            <P>因 为 多 线 程 给 你 提 ?copy; 了 程 序 的 异 步 执 行 的 功 能， 所以 在 必 要 时 必 须 还 提 
            ?copy; 一 种 同 步 机 制。 例 如， 你 想 两个 线 程 通 讯 并 共 享 一 个 复 杂 的 数 据 结 构， 你 需 
            要 一 种 机制 让 他 们 相 互 牵 制 并 正 确 执 行。 为 这 个 目 的，Java用 一 种 叫监 视 
            器(monitor)的 机 制 实 现 了 进 程 间 的 异 步 执 行。 可 以 将 监视 器 看 作 是 一 个 很 小 的 盒 
            子， 它 只 能 容 纳 一 个 线 程。 一 ?copy; 一 个 线 程 进 入 一 个 监 视 器， 所 有 其 他 线 程 必 
            须 等 到 第 一个 线 程 退 出 监 视 器 后 才 能 进 入。 这 ?copy; 监 视 器 可 以 设 计成 保 护 共 享 
            的 数 据 不 被 多 个 线 程 同 时 操 作。 大 多 数 多 线程 系 统 将 这 ?copy; 监 视 器 设 计 成 对 
            象，Java提 ?copy; 了 一 种更 清 晰 的 解 决 方 案。 没 有Monitor类； 每 个 对 象 通 过 将 他 们 
            的成 员 函 数 定 义 成synchronized来 定 义 自 己 的 显 式 监 视 器， 一 ?copy; 一 个 线 程 执 
            行 在 一 个synchronized函 数 里， 其 他 任 何 线 程 都 不能 调 用 同 一 个 对 象 的 
            synchronized函 数。 </P>
            <H3 align=center>7.1.4 消 息 </H3>
            <P>一 ?copy; 你 的 程 序 被 分 成 几 个 逻 辑 线 程， 你 必 须 清 晰 的知 道 这 ?copy; 线 程 
            ?reg; 间 应 怎 样 相 互 通 讯。Java 提 ?copy; 了wait和notify等 功 能 来 使 线 程 ?reg; 
            间 相 互 交 谈。 一 个 线 程可 以 进 入 某 一 个 对 象 的synchronized 函 数 进 入 等 待 状 态， 
            直到 其 他 线 程 显 式 地 将 它 唤 醒。 可 以 有 多 个 线 程 进 入 同 一个 函 数 并 等 待 同 一 个 唤 醒 
            消 息。 </P>
            <H2 align=center>7.2 Java线 程 例 子 </H2>
            <H3 align=center>7.2.1 显 式 定 义 线 程 </H3>
            <P>在 我 们 的 单 线 程 应 用 程 序 里， 我 们 并 没 有 看 见 线 程， 因为Java能 自 动 创 建 和 控 制 
            你 的 线 程。 如 果 你 使 用 了 理 解Java语言 的 浏 览 器， 你 就 已 经 看 到 使 用 多 线 程 的Java程 
            序 了。 你 也许 注 意 到 两 个 小 程 序 可 以 同 时 运 行， 或 在 你 移 动 滚 动 条时 小 程 序 继 续 执 
            行。 这 并 不 是 表 明 小 程 序 是 多 线 程 的， 但说 明 这 个 浏 览 器 是 多 线 程 的。 多 线 程 应 用 
            程 序(或applet)可以 使 用 好 几 个 执 行 上 下 文 来 完 成 它 们 的 工 作。 多 线 程 利用 了 很 多 任 
            务 包 含 单 独 的 可 分 离 的 子 任 务 的 特 点。 每 一个 线 程 完 成 一 个 子 任 务。 </P>
            <P>但 是， 每 一 个 线 程 完 成 子 任 务 时 还 是 顺 序 执 行 的。 一 个多 线 程 程 序 允 许 各 个 线 
            程尽快 执 行 完 它 们。 这 种 特 点 会 有更 好 的 实 时 输 入 反 应。 </P>
            <H3 align=center>7.2.2 多 线 程 例 子</H3>
            <P>下 面 这 个 例 子 创 建 了 三 个 单 独 的 线 程， 它 们 分 别 打 印自 己 的“Hello World": 
            </P>
            <P>//Define our simple threads.They will pause for a short time 
            //and then print out their names and delay times class TestThread 
            extends Thread { private String whoami; private int delay; </P>
            <P>//Our constructor to store the name (whoami) //and time to sleep 
            (delay) public TestThread(String s, int d) { whoami = s; delay = d; 
            } </P>
            <P>//Run - the thread method similar to main() //When run is 
            finished, the thread dies. //Run is called from the start() method 
            of Thread public void run() { //Try to sleep for the specified time 
            try { sleep(delay); } catch(InterruptedException e) {} //Now print 
            out our name System.out.println("Hello World!"+whoami+""+delay); } } 
            /** * Multimtest. A simple multithread thest program */ public class 
            multitest { public static void main(String args[]) { TestThread 
            t1,t2,t3; //Create our test threads t1 = new 
            TestThread("Thread1",(int)(Math.readom()*2000)); t2 = new 
            TestThread("Thread2",(int)(Math.readom()*2000)); t3 = new 
            TestThread("Thread3",(int)(Math.readom()*2000)); </P>
            <P>//Start each of the threads t1.start(); t2.start(); t3.start(); } 
            } </P>
            <H3 align=center>7.2.3 启 动 一 个 线 程 </H3>
            <P>程 序 启 动 时 总 是 调 用main()函 数， 因 此main()是 我 们 创 建 和启 动 线 程 的 地 方： 
            </P>
            <P>t1 = new TestThread("Thread1",(int)(Math.readom()*2000)); </P>
            <P>这 一 行 创 建 了 一 个 新 的 线 程。 后 面 的 两 个 参 数 传 递 了线 程 的 名 称 和 线 程 在 打 印 
            信 息 ?reg; 前 的 延 时 时 间。 因 为我 们 直 接 控 制 线 程， 我 们 必 须 直 接 启 动 它： 
            t1.start(); </P>
            <H3 align=center>7.2.4 操 作 线 程 </H3>
            <P>如 果 创 建 线 程 正 常，t1应 包 含 一 个 有 效 的 执 行 线 程。 我们 在 线 程 的run()函 数 里 控 
            制 线 程。 一 ?copy; 我 们 进 入run()函数， 我 们 便 可 执 行 里 面 的 任 何 程 序。run()好 
            象main()一 样。 一 ?copy;run() 执 行 完， 这 个 线 程 也 就 结 束 了。 在 这 个 例 子 里，我 们 
            试 着 延 迟 一 个 随 机 的 时 间（通 过 参 数 传 递?copy;： sleep(delay); </P>
            <P>sleep()函 数 只 是 简 单 地 告 诉 线 程 休 息 多 少 个 毫 秒 时 间。如 果 你 想 推 迟 一 个 线 
            程 的 执 行， 你 应 使 用sleep()函 数。 当 线程 睡 眠 是sleep()并 不 占 用 系 统 资 源。 其 它 线 
            程 可 继 续 工 作。一 ?copy; 延 迟 时 间 完 毕， 它 将 打 印"Hello World"和 线程 名 称 及 延 迟 
            时 间。 </P>
            <H3 align=center>7.2.5 暂 停 一 个 线 程 </H3>
            <P>我 们 经 常 需 要 挂 起 一 个 线 程 而 不 指 定 多 少 时 间。 例 如，如 果 你 创 建 了 一 个 含 有 
            动 画 线 程 的 小 程 序。 也 许 你 让 用户 暂 停 动 画 至 到 他 们 想 恢 复 为 止。 你 并 不 想 将 动 画 
            线 程仍 调， 但 想 让 它 停 止。 象 这 种 类 似 的 线 程 你 可 用suspend()函数 来 控 制： 
            t1.suspend(); </P>
            <P>这 个 函 数 并 不 永 久 地 停 止 了 线 程， 你 还 可 用resume()函 数重 新 激 活 线 程： 
            t1.resume(); </P>
            <H3 align=center>7.2.6 停 止 一 个 线 程 </H3>
            <P>线 程 的 最 后 一 个 控 制 是 停 止 函 数stop()。 我 们 用 它 来 停止 线 程 的 执 行： 
            t1.stop(); </P>
            <P>注 意： 这 并 没 有 消 灭 这 个 线 程， 但 它 停 止 了 线 程 的 执 行。并 且 这 个 线 程 不 能 
            用t1.start()重 新 启 动。 在 我 们 的 例 子 里，我 们 从 来 不 用 显 式 地 停 止 一 个 线 程。 我 们 
            只 简 单 地 让 它执 行 完 而 已。 很 多 复 杂 的 线 程 例 子 将 需 要 我 们 控 制 每 一个 线 程。 在 这 
            种 情 况 下 会 使 用 到stop()函 数。 如 果 需 要， 你可 以 测 试 你 的 线 程 是 否 被 激 活。 一 个 线 
            程 已 经 启 动 而 且没 有 停 止 被 认 为 是 激 活 的。 t1.isAlive() 如 果t1是 激 活 的， 这个 函 
            数 将 返 回true. </P>
            <H3 align=center>7.2.7 动 画 例 子 </H3>
            <P>下 面 是 一 个 包 含 动 画 线 程 的applet例 子： </P>
            <P>import java.awt.*; import java.awt.image.ImageProducer; import 
            java.applet.Applet; </P>
            <P>public class atest3 extends Applet implements Runnable { Image 
            images[]; MediaTracker tracker; int index = 0; Thread animator; </P>
            <P>int maxWidth,maxHeight; //Our off-screen components for double 
            buffering. Image offScrImage; Graphics offScrGC; </P>
            <P>//Can we paint yes? boolean loaded = false; </P>
            <P>//Initialize the applet. Set our size and load the images public 
            void init() [ //Set up our image monitor tracker = new