java 中的多线程
在java 中要想实现多线程，有两种手段，一种是继续Thread 类，另外一种是实现Runable 接口。 对于直接继承Thread 的类来说，代码大致框架是： ?
1 2 3 4 5 6 7 8 9 10 11 12 class 类名extends Thread{ 方法1; 方法2； … public void run(){ // other code … } 属性1； 属性2； … }
先看一个简单的例子： ?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 1/**
* @author Rollen-Holt 继承Thread 类,直接调用run 方法
* */
class hello extends Thread {
public hello() {
}
public hello(String name) {
this .name = name;
}
public void run() {
for (int i =0; i <5; i++) {
System.out.println(name +"运行 " + i);
}
}
public static void main(String[] args) {
5 1
6 1
7 1
8 1
9 2 0 2 1 2 2 2 3 2 4 2 5 2 6 2 7 2 8
hello h1=new hello("A");
hello h2=new hello("B");
h1.run();
h2.run();
}
private String name;
}
【运行结果】：A运行 0 A运行 1 A运行 2 A运行 3 A运行 4 B运行 0 B运行 1 B运行 2 B运行 3 B运行 4
我们会发现这些都是顺序执行的，说明我们的调用方法不对，应该调用的是start （）方法。 当我们把上面的主函数修改为如下所示的时候： ?
1 2 3 4 5 6 public static void main(String[] args) { hello h1=new hello("A"); hello h2=new hello("B"); h1.start(); h2.start(); } 然后运行程序，输出的可能的结果如下：
A 运行 0
B 运行 0
B 运行 1
B 运行 2
B 运行 3
B 运行 4
A 运行 1
A 运行 2
A 运行 3
A 运行 4
因为需要用到CPU 的资源，所以每次的运行结果基本是都不一样的，呵呵。
注意：虽然我们在这里调用的是start （）方法，但是实际上调用的还是run （）方法的主体。 那么：为什么我们不能直接调用run （）方法呢？
我的理解是：线程的运行需要本地操作系统的支持。
如果你查看start 的源代码的时候，会发现：
?
1 2 3 4 5 6 7 public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system" * group threads created/set up by the VM. Any new functionality added * to this method in the future may have to also be added to the VM. *
* A zero status value corresponds to state "NEW".
8 9 10 11 12 13 14
1
5
1
6
1
7
*/
if (threadStatus !=0 ||this != me)
throw new IllegalThreadStateException();
group.add(this );
start0();
if (stopBeforeStart) {
stop0(throwableFromStop);
}
}
private native void start0();
注意我用红色加粗的那一条语句，说明此处调用的是start0（）。并且这个这个方法用了native 关键字，次关键字表示调用本地操作系统的函数。因为多线程的实现需要本地操作系统的支持。 但是start 方法重复调用的话，会出现https://www.doczj.com/doc/c814948213.html,ng.IllegalThreadStateException 异常。 通过实现Runnable 接口：
大致框架是： ?
1
2 3 4 5 6 7 8 9 10 11 12
class 类名implements Runnable{
方法1;
方法2；
…
public void run(){
// other code …
}
属性1；
属性2；
…
}
来先看一个小例子吧： ?
1
2
3
4
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 2
3
2
4
2
/** * @author Rollen-Holt 实现Runnable 接口 * */ class hello implements Runnable { public hello() { } public hello(String name) { this .name = name; } public void run() { for (int i =0; i <5; i++) { System.out.println(name +"运行 " + i); } } public static void main(String[] args) { hello h1=new hello("线程A"); Thread demo=new Thread(h1); hello h2=new hello("线程Ｂ"); Thread demo1=new Thread(h2); demo.start(); demo1.start(); } private String name; }
2
6
2
7
2
8
2
9
3
0 【可能的运行结果】：
线程A 运行 0
线程Ｂ运行 0
线程Ｂ运行 1
线程Ｂ运行 2
线程Ｂ运行 3
线程Ｂ运行 4
线程A 运行 1
线程A 运行 2
线程A 运行 3
线程A 运行 4
关于选择继承Thread 还是实现Runnable 接口？
其实Thread 也是实现Runnable 接口的：
?
1 2 3 4 5 6 7 8 class Thread implements Runnable { //… public void run() { if (target !=null ) { target.run(); } } }
其实Thread 中的run 方法调用的是Runnable 接口的run 方法。不知道大家发现没有，Thread 和Runnable
都实现了run 方法，这种操作模式其实就是代理模式。关于代理模式，我曾经写过一个小例子呵呵，大家有兴趣的话可以看一下：https://www.doczj.com/doc/c814948213.html,/rollenholt/archive/2011/08/18/2144847.html
Thread 和Runnable 的区别：
如果一个类继承Thread ，则不适合资源共享。但是如果实现了Runable 接口的话，则很容易的实现资源共享。 ?
1
2
3
4
5
6 7 8 9 10 11 12 13 14 15 16 17 18 19 2
2
1
2
2
/** * @author Rollen-Holt 继承Thread 类，不能资源共享 * */ class hello extends Thread { public void run() { for (int i =0; i <7; i++) { if (count >0) { System.out.println("count= " + count--); } } } public static void main(String[] args) { hello h1 =new hello(); hello h2 =new hello(); hello h3 =new hello(); h1.start(); h2.start(); h3.start(); } private int count =5; }
2
3
【运行结果】：
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
大家可以想象，如果这个是一个买票系统的话，如果count 表示的是车票的数量的话，说明并没有实现资源的共享。
我们换为Runnable 接口
?
1 2 3 4 5 6 7 8 9 class MyThread implements Runnable{
private int ticket =5; //5张票
public void run() {
for (int i=0; i<=20; i++) {
if (this .ticket >0) {
System.out.println(Thread.currentThread().getName()+"正在卖票"+this .ticket--);
1 0 1 1 1
2 1
3 1
4 1
5 1
6 1
7 1
8 1
9 2 0 2 1
}
}
}
}
public class lzwCode {
public static void main(String [] args) { MyThread my =new MyThread();
new Thread(my,"1号窗口").start();
new Thread(my,"2号窗口").start();
new Thread(my,"3号窗口").start();
}
}
【运行结果】：
count= 5
count= 4
count= 3
count= 2
count= 1
总结一下吧：
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java 中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。
所以，本人建议大家劲量实现接口。 ?
1
2
3
4
5 6 7 8 9 10 11 12 13 14 15 16 1
7
1
8
/**
* @author Rollen-Holt
* 取得线程的名称
* */
class hello implements Runnable {
public void run() {
for (int i =0; i <3; i++) {
System.out.println(Thread.currentThread().getName()); }
}
public static void main(String[] args) {
hello he =new hello();
new Thread(he,"A").start();
new Thread(he,"B").start();
new Thread(he).start();
}
}
【运行结果】：
A
A
A
B
B
B
Thread-0
Thread-0
Thread-0
说明如果我们没有指定名字的话，系统自动提供名字。
提醒一下大家：main 方法其实也是一个线程。在java 中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU 的资源。
在java 中，每次程序运行至少启动2个线程。一个是main 线程，一个是垃圾收集线程。因为每当使用java 命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。
判断线程是否启动 ?
1
2
3
4 5 6 7 8 9 10 11 12 13 14 15 16
1
7
/**
* @author Rollen-Holt 判断线程是否启动
* */
class hello implements Runnable {
public void run() {
for (int i =0; i <3; i++) {
System.out.println(Thread.currentThread().getName()); }
}
public static void main(String[] args) {
hello he =new hello();
Thread demo =new Thread(he);
System.out.println("线程启动之前---》" + demo.isAlive()); demo.start();
System.out.println("线程启动之后---》" + demo.isAlive()); }
}
8 【运行结果】
线程启动之前---》false
线程启动之后---》true
Thread-0
Thread-0
Thread-0
主线程也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。
线程的强制执行： ?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 /**
* @author Rollen-Holt 线程的强制执行
* */
class hello implements Runnable {
public void run() {
for (int i =0; i <3; i++) {
System.out.println(Thread.currentThread().getName()); }
}
public static void main(String[] args) {
hello he =new hello();
Thread demo =new Thread(he,"线程");
demo.start();
for (int i=0;i<50;++i){
if (i>10){
try {
demo.join(); //强制执行demo
}catch (Exception e) {
e.printStackTrace();
}
}
System.out.println("main 线程执行-->"+i);
}
}
}
9
2
2
1
2
2
2
3
2
4
2
5
2
6
【运行的结果】：main 线程执行-->0 main 线程执行-->1 main 线程执行-->2 main 线程执行-->3 main 线程执行-->4 main 线程执行-->5 main 线程执行-->6 main 线程执行-->7 main 线程执行-->8 main 线程执行-->9 main 线程执行-->10线程
线程
线程
main 线程执行-->11 main 线程执行-->12 main 线程执行-->13．．．
线程的休眠： ?
1
2
3
4
5
6 7 8 9 10 11 12 13 14 15 16 17 18 1
9
2
2
1
/** * @author Rollen-Holt 线程的休眠 * */ class hello implements Runnable { public void run() { for (int i =0; i <3; i++) { try { Thread.sleep(2000); }catch (Exception e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + i); } } public static void main(String[] args) { hello he =new hello(); Thread demo =new Thread(he,"线程"); demo.start(); } } 【运行结果】：（结果每隔2s 输出一个）
线程0
线程1
线程2
线程的中断： ?
1
2
3
4
5
6
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 2
3
2
4
2
5
/**
* @author Rollen-Holt 线程的中断
* */
class hello implements Runnable {
public void run() {
System.out.println("执行run 方法");
try {
Thread.sleep(10000);
System.out.println("线程完成休眠");
}catch (Exception e) {
System.out.println("休眠被打断");
return ; //返回到程序的调用处
}
System.out.println("线程正常终止");
}
public static void main(String[] args) {
hello he =new hello();
Thread demo =new Thread(he,"线程");
demo.start();
try {
Thread.sleep(2000);
}catch (Exception e) {
e.printStackTrace();
}
demo.interrupt();//2s 后中断线程
}
}
2
6
2
7
2
8 【运行结果】：
执行run 方法
休眠被打断
在java 程序中，只要前台有一个线程在运行，整个java 程序进程不会小时，所以此时可以设置一个后台线程，这样即使java 进程小时了，此后台线程依然能够继续运行。 ?
1
2
3
4 5 6 7 8 9 10 11 12 13 14 15 16
1
7
/**
* @author Rollen-Holt 后台线程
* */
class hello implements Runnable {
public void run() {
while (true ) {
System.out.println(Thread.currentThread().getName() +"在运行");
}
}
public static void main(String[] args) {
hello he =new hello();
Thread demo =new Thread(he,"线程");
demo.setDaemon(true );
demo.start();
}
}
虽然有一个死循环，但是程序还是可以执行完的。因为在死循环中的线程操作已经设置为后台运行了。 线程的优先级：
?
1
2
3 4
5
6
7 8 9 10 11 12 13 14 15 16 17 18 19 20 2
1
2
2
2
3
/**
* @author Rollen-Holt 线程的优先级
* */
class hello implements Runnable {
public void run() {
for (int i=0;i<5;++i){
System.out.println(Thread.currentThread().getName()+"运行"+i);
}
}
public static void main(String[] args) {
Thread h1=new Thread(new hello(),"A");
Thread h2=new Thread(new hello(),"B");
Thread h3=new Thread(new hello(),"C");
h1.setPriority(8);
h2.setPriority(2);
h3.setPriority(6);
h1.start();
h2.start();
h3.start();
}
}
【运行结果】：
A 运行0
A 运行1
A 运行2
A 运行3
A 运行4
B 运行0
C 运行0
C 运行1
C 运行2
C 运行3
C 运行4
B 运行1
B 运行2
B 运行3
B 运行4
。但是请读者不要误以为优先级越高就先执行。谁先执行还是取决于谁先去的CPU 的资源、
另外，主线程的优先级是5.
线程的礼让。
在线程操作中，也可以使用yield （）方法，将一个线程的操作暂时交给其他线程执行。 ?
1 2 3 4 5 6 7 8 9 10 11 12 1/**
* @author Rollen-Holt 线程的优先级
* */
class hello implements Runnable {
public void run() {
for (int i=0;i<5;++i){
System.out.println(Thread.currentThread().getName()+"运行
"+i);
if (i==3){
System.out.println("线程的礼让");
Thread.currentThread().yield();
}
}
}
public static void main(String[] args) {
3 1
4 1
5 1
6 1
7 1
8 1
9 2 0 2 1 2 2
Thread h1=new Thread(new hello(),"A");
Thread h2=new Thread(new hello(),"B");
h1.start();
h2.start();
}
}
A运行0
A运行1
A运行2
A运行3
线程的礼让
A运行4
B运行0
B运行1
B运行2
B运行3
线程的礼让
B运行4
同步和死锁：
【问题引出】:比如说对于买票系统，有下面的代码：?
2
3
4
5
6
7
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
2
4
2
5
2
6
2
/** * @author Rollen-Holt * */ class hello implements Runnable { public void run() { for (int i=0;i<10;++i){ if (count>0){ try { Thread.sleep(1000); }catch (InterruptedException e){ e.printStackTrace(); } System.out.println(count--); } } } public static void main(String[] args) { hello he=new hello(); Thread h1=new Thread(he); Thread h2=new Thread(he); Thread h3=new Thread(he); h1.start(); h2.start(); h3.start(); } private int count=5; }
线程与线程类 1 线程的概念 线程的概念来源于计算机的操作系统的进程的概念。进程是一个程序关于某个数据集的一次运行。也就是说，进程是运行中的程序，是程序的一次运行活动。 线程和进程的相似之处在于，线程和运行的程序都是单个顺序控制流。有些教材将线程称为轻量级进程(light weight process)。线程被看作是轻量级进程是因为它运行在一个程序的上下文内，并利用分配给程序的资源和环境。 作为单个顺序控制流，线程必须在运行的程序中得到自己运行的资源，如必须有自己的执行栈和程序计数器。线程内运行的代码只能在该上下文内。因此还有些教程将执行上下文(execution context)作为线程的同义词。 所有的程序员都熟悉顺序程序的编写，如我们编写的名称排序和求素数的程序就是顺序程序。顺序程序都有开始、执行序列和结束，在程序执行的任何时刻，只有一个执行点。线程（thread ）则是进程中的一个单个的顺序控制流。单线程的概念很简单，如图1所示。 多线程（multi-thread ）是指在单个的程序内可以同时运行多个不同的线程完成不同的任务，图2说明了一个程序中同时有两个线程运行。 图1 单线程程序示意图 图2 多线程程序示意图 有些程序中需要多个控制流并行执行。例如， for(int i = 0; i < 100; i++) System.out.println("Runner A = " + i); for(int j = 0; j < 100; j++ ) System.out.println("Runner B = "+j); 上面的代码段中，在只支持单线程的语言中，前一个循环不执行完不可能执行第二个循环。要使两个循环同时执行，需要编写多线程的程序。 很多应用程序是用多线程实现的，如Hot Java Web 浏览器就是多线程应用的例子。在Hot Java 浏览器中，你可以一边滚动屏幕，一边下载Applet 或图像，可以同时播放动画和声音等。 2 Thread 类和Runnable 接口 多线程是一个程序中可以有多段代码同时运行，那么这些代码写在哪里，如何创建线程对象呢? 首先，我们来看Java 语言实现多线程编程的类和接口。在https://www.doczj.com/doc/c814948213.html,ng 包中定义了Runnable 接口和Thread 类。
7Java多线程机制 7.1单项选择题 1. 线程调用了sleep（）方法后，该线程将进入（）状态。 A. 可运行状态 B. 运行状态 C. 阻塞状态 D. 终止状态 2. 关于java线程，下面说法错误的是（） A. 线程是以CPU为主体的行为 B. java利用线程使整个系统成为异步 C. 创建线程的方法有两种：实现Runnable接口和继承Thread类 D. 新线程一旦被创建，它将自动开始运行 3. 在java中的线程模型包含（） A. 一个虚拟处理器 B. CPU执行的代码 C. 代码操作的数据 D. 以上都是 4.在java语言中，临界区可以是一个语句块，或者是一个方法，并用（）关键字标识。 A. synchronized B. include C. import D. Thread 5. 线程控制方法中，yield()的作用是（） A. 返回当前线程的引用 B. 使比其低的优先级线程执行 C. 强行终止线程 D. 只让给同优先级线程运行 6. 线程同步中，对象的锁在（）情况下持有线程返回 A. 当synchronized()语句块执行完后 B. 当在synchronized()语句块执行中出现例外（exception）时 C. 当持有锁的线程调用该对象的wait()方法时 D. 以上都是 7. 在以下（）情况下，线程就进入可运行状态 A. 线程调用了sleep()方法时 B. 线程调用了join()方法时
C. 线程调用了yield()方法时 D. 以上都是 8. java用（）机制实现了进程之间的异步执行 A. 监视器 B. 虚拟机 C. 多个CPU D. 异步调用 类的方法中，toString()方法的作用是（） A. 只返回线程的名称 B. 返回当前线程所属的线程组的名称 C. 返回当前线程对象 D. 返回线程的名称 语言具有许多优点和特点,下列选项中,哪个反映了Java程序并行机制的特点（） A. 安全性 B. 多线程 C. 跨平台 D. 可移值 11.以下哪个关键字可以用来对对象加互斥锁？（） A. transient B. synchronized C. serialize D. static 12.下面关于进程、线程的说法不正确的是( )。 A．进程是程序的一次动态执行过程。一个进程在其执行过程中，可以产生多个线程——多线程，形成多条执行线索。 B．线程是比进程更小的执行单位，是在一个进程中独立的控制流，即程序内部的控制流。线程本身不能自动运行，栖身于某个进程之中，由进程启动执行。 C．Java多线程的运行与平台无关。 D．对于单处理器系统，多个线程分时间片获取CPU或其他系统资源来运行。对于多处理器系统，线程可以分配到多个处理器中，从而真正的并发执行多任务。 7.2填空题 1.________是java程序的并发机制，它能同步共享数据、处理不同的事件。 2.线程是程序中的一个执行流，一个执行流是由CPU运行程序的代码、__________所形 成的，因此，线程被认为是以CPU为主体的行为。 3.线程的终止一般可以通过两种方法实现：自然撤销或者是__________. 4.线程模型在java中是由__________类进行定义和描述的。 5.线程的创建有两种方法：实现_________接口和继承Thread类。 6.多线程程序设计的含义是可以将程序任务分成几个________的子任务。 7.按照线程的模型，一个具体的线程也是由虚拟的CPU、代码与数据组成，其中代码与数 据构成了___________,线程的行为由它决定。 8.ava中，新建的线程调用start()方法、如(),将使线程的状态从New(新建状态)转换为 _________。 9.多线程是java程序的________机制，它能同步共享数据，处理不同事件。 10.进程是由代码、数据、内核状态和一组寄存器组成，而线程是表示程序运行状态的
重庆交通大学综合性设计性实验报告 实验项目名称：进程调度（先来先服务） 实验项目性质： JAVA多线程 实验所属课程： JAVA程序设计 实验室(中心)：语音大楼 8 楼 801 班级：软件专业 2012级2班 姓名：尚亚* 学号： 631206050216 指导教师：杨 实验完成时间： 2014 年 11 月 25 日
一、实验目的 1、理解程序、线程和进程的概念； 2、理解多线程的概念； 3、掌握线程的各种状态； 4、熟练使用Thread类创建线程； 5、熟练使用线程各种方法； 6、掌握线程的调度及线程同步的实现原理。 二、实验内容及要求 进程调度是处理机管理的核心内容。本实验要求采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念。并体会了优先数和先来先服务调度算法的具体实施办法。 用JA V A语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。做一个能够直观体现多个进程时，CPU 是怎样调度就绪队列中的进程（按照先来先服务的原则）。
三、实验设备 PC机，windows7，eclipse。 四、设计方案 ㈠设计主要思想 （1）要模拟进程的调度算法，必须先体现处进程及系统资源。 （2）要体现先来先服务的算法，就必须表现出当有一个进程进入CPU时其他进程不能进入，并在就绪队列中排队。本实验建立了四个圆移动的线程表示作业调度，用圆在表示就绪队列的方框中停留表示进程在就绪队列中排队。 （3）当有一个圆移动到表示CPU的范围内时，让其它线程在就绪队列中排队，当CPU内无进程时，先来的圆先移动，以表示CPU 对进程的调度。 ㈡设计的主要步骤 （1）建立四个不同颜色的圆移动的线程，表示对四个进程的调度。 （2）当有一个表示进程的圆到达表示CPU范围内时，通过让其它几个圆停留在表示就绪队列的方框范围内，表示进程在就绪队列中排成队列。 （3）当第一个先到达的进程释放CPU，在排成队列的几个圆中选择先到达的圆，使其移动表示对先来的进程进行调度，直到所有的圆移动完毕。 五、主要代码 import java.awt.Font; import java.awt.event.*;
J a v a第七单元练习题 J a v a多线程机制 The latest revision on November 22, 2020
7Java多线程机制 7.1单项选择题 1. 线程调用了sleep（）方法后，该线程将进入（）状态。 A. 可运行状态 B. 运行状态 C. 阻塞状态 D. 终止状态 2. 关于java线程，下面说法错误的是（） A. 线程是以CPU为主体的行为 B. java利用线程使整个系统成为异步 C. 创建线程的方法有两种：实现Runnable接口和继承Thread类 D. 新线程一旦被创建，它将自动开始运行 3. 在java中的线程模型包含（） A. 一个虚拟处理器 B. CPU执行的代码 C. 代码操作的数据 D. 以上都是 4.在java语言中，临界区可以是一个语句块，或者是一个方法，并用（）关键字标识。 A. synchronized B. include C. import D. Thread 5. 线程控制方法中，yield()的作用是（） A. 返回当前线程的引用 B. 使比其低的优先级线程执行 C. 强行终止线程 D. 只让给同优先级线程运行 6. 线程同步中，对象的锁在（）情况下持有线程返回 A. 当synchronized()语句块执行完后 B. 当在synchronized()语句块执行中出现例外（exception）时 C. 当持有锁的线程调用该对象的wait()方法时 D. 以上都是 7. 在以下（）情况下，线程就进入可运行状态 A. 线程调用了sleep()方法时 B. 线程调用了join()方法时 C. 线程调用了yield()方法时 D. 以上都是 8. java用（）机制实现了进程之间的异步执行
1.如果线程死亡，它便不能运行。（T） 2.在Java中，高优先级的可运行线程会抢占低优先级线程。（T ） 3.线程可以用yield方法使低优先级的线程运行。（F） 4...程序开发者必须创建一个线程去管理内存的分配。（F） 5.一个线程在调用它的start方法，之前，该线程将一直处于出生期。（T） 6.当调用一个正在进行线程的stop( )方法时，该线程便会进入休眠状态。（F） 7.一个线程可以调用yield方法使其他线程有机会运行。（T） 二、选择题 1.Java语言中提供了一个▁D▁线程，自动回收动态分配的内存。 A．异步 B．消费者 C．守护 D．垃圾收集 2.Java语言避免了大多数的▁C▁错误。 A．数组下标越界 B．算术溢出 C．内存泄露 D．非法的方法参数 3.有三种原因可以导致线程不能运行，它们是▁ACD▁▁。 A．等待 B．阻塞 C．休眠 D．挂起及由于I/O操作而阻塞 4.当▁A方法终止时，能使线程进入死亡状态。 A．run B．setPrority C．yield D．sleep 5.用▁B▁方法可以改变线程的优先级。 A．run B．setPrority C．yield D．sleep 6.线程通过▁C▁方法可以使具有相同优先级线程获得处理器。 A．run B．setPrority C．yield D．sleep 7.线程通过▁D▁方法可以休眠一段时间，然后恢复运行。 A．run B．setPrority C．yield
8.方法resume( )负责重新开始▁D▁线程的执行。 A．被stop( )方法停止 B．被sleep( )方法停止 C．被wait( )方法停止 D．被suspend( )方法停止 9.▁BCD▁方法可以用来暂时停止当前线程的运行。 A．stop( ) B．sleep( ) C．wait( ) D．suspend( ) 三、简述题 1.简述程序、进程和线程之间的关系？什么是多线程程序？ 答：程序是一段静态的代码，它是应用软件执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行到执行完毕的一个完整过程。这个过程也是进程本身从产生、发展、到消亡的过程。线程是比进程更小的单位。一个进程在其执行过程中，可以产生多个线程，形成多个执行流。每个执行流即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念。多线程程序是指一个程序中包含多个执行流。 2.线程有哪几个基本状态？它们之间如何转化？简述线程的生命周期。 答：新建状态，可运行状态，运行状态，阻碍状态，终止状态。对线程调用各种控制方法，就使线程从一种状态转换到另一种状态。线程的生命周期从新建开始，在可运行、运行和其他阻碍中循环，在可运行、运行、对象锁阻塞、等待阻塞中循环，最终在运行后run()方法结束后终止。 3.什么是线程调度？Java的线程调度采用什么策略？ 答：在单个CPU上以某种顺序运行多个线程，称为线程的调度。Java的线程调度策略是一种优先级的抢先式调度。Java基于线程的优先级选择高优先级的线程进行运行。该线程将持续运行，直到它终止运行，或其他高优先级线程称为可运行的。 4.如何在Java程序中实现多线程？ 答：1：通过Thread类的构造方法 2：通过实现Runnable接口创建线程、 3：通过继承Thread类创建线程 5.试简述Thread类的子类或实现Runnable接口两种方法的异同？ 答：采用继承Thread类方法使程序代码简单，并可以在run（）方法中直接调用线程的其他方法。而实现Runnable接口更符合面向对象设计的思想，因为从OO设计的角度，thread 类是虚拟CPU的封装，所以Thread的子类应该是关于CPU行为的类。但在继承Thread类之类构造线程的方法中，Thread类的子类大都是与CPU不相关的类。而实现Runnable接口的方法，将不影响Java类的体系，所以更加符合面向对象的设计思想。同时，实现了Runnable 接口的类可以用extends继承其他的类。 四、程序设计题 1.编写一个类，在类中定义： A：一个整型属性
第一页在 Java 程序中使用多线程要比在 C 或 C++ 中容易得多，这是因为Java 编程语言提供了语言级的支持。本文通过简单的编程示例来说明 Java 程序中的多线程是多么直观。读完本文以后，用户应该能够编写简单的多线程程序。 为什么会排队等待？下面的这个简单的 Java 程序完成四项不相关的任务。这样的程序有单个控制线程，控制在这四个任务之间线性地移动。此外，因为所需的资源 ? 打印机、磁盘、数据库和显示屏 -- 由于硬件和软件的限制都有内在的潜伏时间，所以每项任务都包含明显的等待时间。因此，程序在访问数据库之前必须等待打印机完成打印文件的任务，等等。如果您正在等待程序的完成，则这是对计算资源和您的时间的一种拙劣使用。改进此程序的一种方法是使它成为多线程的。四项不相关的任务class myclass { static public void main(String args[] { print_a_file(; manipulate_another_file(; access_database(; draw_picture_on_screen(; } } 在本例中，每项任务在开始之前必须等待前一项任务完成，即使所涉及的任务毫不相关也是这样。但是，在现实生活中，我们经常使用多线程模型。我们在处理某些任务的同时也可以让孩子、配偶和父母完成别的任务。例如，我在写信的同时可能打发我的儿子去邮局买邮票。用软件术语来说，这称为多个控制（或执行）线程。可以用两种不同的方法来获得多个控制线程：多个进程在大多数操作系统中都可以创建多个进程。当一个程序启动时，它可以为即将开始的每项任务创建一个进程，并允许它们同时运行。当一个程序因等待网络访问或用户输入而被阻塞时，另一个程序还可以运行，这样就增加了资源利用率。但是，按照这种方式创建每个进程要付出一定的代价：设置一个进程要占用相当一部分处理器时间和内存资源。而且，大多数操作系统不允许进程访问其他进程的内存空间。因此，进程间的通信很不方便，并且也不会将它自己提供给容易的编程模型。线程线程也称为轻型进程 (LWP。因为线程只能在单个进程的作用域内活动，所以创建线程比创建进程要廉价得多。这样，因为线程允许协作和数据交换，并且在计算资源方面非常廉价，所以线程比进程更可取。线程需要操作系统的支持，因此不是所有的机器都提供线程。Java 编程语言，作为相当新的一种语言，已将线程支持与语言本身合为一体，这样就对线程提供了强健的支持。使用 Java 编程语言实现线程Jav
7 Java 多线程机制 7.1 单项选择题 1. 线程调用了sleep ()方法后，该线程将进入( )状态。 A. 可运行状态 B. 运行状态 C. 阻塞状态 D. 终止状态 2. 关于java 线程，下面说法错误的是() A. 线程是以CPU为主体的行为 B. java 利用线程使整个系统成为异步 C. 创建线程的方法有两种：实现Runnable 接口和继承Thread 类 D. 新线程一旦被创建，它将自动开始运行 3. 在java 中的线程模型包含() A. 一个虚拟处理器 B. CPU执行的代码 C. 代码操作的数据 D. 以上都是 4. 在java 语言中，临界区可以是一个语句块，或者是一个方法，并用()关键字标识。 A. synchronized B. include C. import D. Thread 5. 线程控制方法中，yield()的作用是() A. 返回当前线程的引用 B. 使比其低的优先级线程执行 C. 强行终止线程 D. 只让给同优先级线程运行 6. 线程同步中，对象的锁在()情况下持有线程返回 A. 当synchronized()语句块执行完后 B. 当在synchronized()语句块执行中出现例外( exception )时 C. 当持有锁的线程调用该对象的wait()方法时 D. 以上都是 7. 在以下()情况下，线程就进入可运行状态 A. 线程调用了sleep()方法时 B. 线程调用了join()方法时 C. 线程调用了yield()方法时 D. 以上都是 8. java 用()机制实现了进程之间的异步执行 A. 监视器 B. 虚拟机
Java面向对象程序设计 实验七 多线程 学号： 姓名： 学院：计算机与信息学院 专业班级： 指导老师：林志伟 2 015.12.3
1 .单线程实例的运行结果是： mainbegins12345678910111213141516171819202122 2 324252627282930313233343536373839404142434445 647484950ABCDEFGHIJKLMNOPQRSTUVWXYZa 4 bcdefghijklmnopqrstuvwxyzmainends 多线程视力的运行结果是： mainbeginsmainendsA1B2C3D4E5F6G7H8I9JKLMNO PQRS 10 T11U 12 V13 W 14X15 Y16Z 17 a18b 19 c20 d 21e22 f 23 g24 h25i 26j 27k 28l 29m30n31o32p33q34r35 s36 t 37u38v39w40x41y42z4344454647484950 多线程与单线程的区别在于多线程可以同时运行多段代码，提高程序的执行 效率。 2 .程序运行结果如下： mainprint0 Thread1print5 Thread1print6 Thread1print7 Thread1print8 Thread1print9 Thread2print0 Thread2print1 Thread2print2 Thread2print3 Thread2print4 Thread2print5 Thread2print6 Thread2print7 Thread2print8 Thread2print9 mainprint1 mainprint2 mainprint3 mainprint4 mainprint5 mainprint6 mainprint7 mainprint8 mainprint9 Thread1print0 Thread1print1 Thread1print2 Thread1print3 Thread1print4 Threads 类实现了Runnable 接口，故程序运行到了t1.start()时会创建一个新 的线程并运行t1.run()内部的代码，运行到t2.start()时会再创建一个新的线程， 并运行t2.run()内部的代码。虽然这个程序是多线程的，但是由于cpu 运行速 度过快，导致这个程序的运行结果跟单线程运行的结果没有区别。当将run() 方法中的循环次数增加到了100 时，就可以看出多线程运行结果与单线程运 行结果的不同了。
TCP协议服务端多线程技术 代码： UploadTask.java 1.import https://www.doczj.com/doc/c814948213.html,.Socket; 2.import java.io.InputStream; 3.import java.io.FileOutputStream; 4.import java.io.File; 5.import java.io.OutputStream; 6. 7.public class UploadTask implements Runnable 8.{ 9. private Socket s; 10. 11. public UploadTask(Socket s){ 12. this.s = s; 13. } 14. 15. public void run(){ 16. 17. int count = 0; 18. 19. String ip = s.getInetAddress().getHostAddress(); 20. System.out.println(ip + "......connected"); 21. 22. try{ 23. InputStream in = s.getInputStream(); 24. 25. File dir = new File("c:\\pic"); 26. if(!dir.exists()){ 27. dir.mkdirs();
28. } 29. File file = new File(dir,ip + ".bmp"); 30. 31. //如果文件已经存在于服务端。 32. while(file.exists()){ 33. file = new File(dir,ip + "(" + (++count) + ").bmp"); 34. } 35. 36. FileOutputStream fos = new FileOutputStream(file); 37. 38. byte[] buf = new byte[1024]; 39. 40. int len = 0; 41. 42. while((len = in.read(buf)) != -1){ 43. fos.write(buf,0,len); 44. } 45. 46. OutputStream out = s.getOutputStream(); 47. 48. out.write("上传成功".getBytes()); 49. 50. fos.close(); 51. s.close(); 52. }catch(Exception e){ 53. e.printStackTrace(); 54. } 55. } 56.}
7J a v a多线程机制7.1单项选择题 1. 线程调用了sleep（）方法后，该线程将进入（）状态。 A. 可运行状态 B. 运行状态 C. 阻塞状态 D. 2. 关于 A. C. D. 3. 在 A. C. D. 4.在 5. A. B. C. D. 6. A. 当 B. C. 当持有锁的线程调用该对象的wait()方法时 D. 以上都是 7. 在以下（）情况下，线程就进入可运行状态 A. 线程调用了sleep()方法时 B. 线程调用了join()方法时 C. 线程调用了yield()方法时 D. 以上都是 8. java用（）机制实现了进程之间的异步执行 A. 监视器 B. 虚拟机 C. 多个CPU
D. 异步调用 9.Thread类的方法中，toString()方法的作用是（） A. 只返回线程的名称 B. 返回当前线程所属的线程组的名称 C. 返回当前线程对象 D. 返回线程的名称 10.Java语言具有许多优点和特点,下列选项中,哪个反映了Java程序并行机制的特点（） A. 安全性 B. 多线程 C. 跨平台 D. 可移值 11. 12. A B C．Java D 7.2 1. 2.因 3. 4. 5. 6. 7. 了 8.ava)转 换为_________。 9.多线程是java程序的________机制，它能同步共享数据，处理不同事件。 10.进程是由代码、数据、内核状态和一组寄存器组成，而线程是表示程序运行状态的______，如 程序计数器、栈指针以及堆栈组成。 11.Thread类提供了一系列基本线程控制方法，如果我们需要让与当前进程具有相同优先级的线程 也有运行的机会则可以调用________方法。 12.在多线程系统中，多个线程之间有________和互斥两种关系。 13. 在一个时间只能由一个线程访问的资源称为临界资源，访问临界资源的代码___________。