《JAVA多线程》PPT课件

21.
myThread
t1，t2，t3，t4;
22.
t1=new myThread("Thread 1");
23.
t2=new myThread("Thread 2");
24.
t3=new myThread("Thread 3");
25.
t4=new myThread("Thread 4");
26.
4.
number=num;
5.
System.out.println("创建线程：" +number);
6. }
7. public void run(){
8.
while(true){
9.
System.out.println("线程 " + number + "：计数 " + count);
10.
if(++count==6) return;
8.2.1 多线程编程中常用的常量和方法
Thread类包含的常量有：
–1. public static final int MAX_PRIORITY： 最大 优先级，值是10。
–2. public static final int MIN_PRIORITY： 最小 优先级，值是1。
–3. public static final int NORM_PRIORITY：缺省 优先级，值是5。
– isAlive( ) ： 判断线程是否处于执行的状态，返回值true表 示处于运行状态，false表示已停止。
– start( ) ：使调用该方法的线程开始执行。 – run( ) ：该方法由start( )方法自动调用。
8.2.1 多线程编程中常用的常量和方法
常用方法：
– stop( ) ：使线程停止执行，并退出可执行状态。 – suspend()： 使线程暂停执行，不退出可执行态。 – resume( ) ： 将暂停的线程继续执行。 – setName(String s) ：赋予线程一个名字。 – getName( ) ：获得调用线程的名字。 – getPriority( ) ：获得调用线程的优先级。 – setPriority(int p) ：设置线程的优先级。 – join( ) ：等待线程死亡，若中断了该线程， 将抛出异常。
当前线程： Thread[main，7，main]
线程名 ： main
优先级 ：7
8.2.2 线程的生命周期
Java支持一种“抢占式”（preemptive)调度方式 “Newborn”（新建）状态：
–线程在己被创建但未执行这段时间内，处于一个特殊 的"Newborn"状态，这时，线程对象己被分配内存空间， 其私有数据己被初始化，但该线程还未被调度。此时 线程对象可通过start（）方法调度，或者利用stop（） 方法杀死.新创建的线程一旦被调度，就将切换到 "Runnable"状态。
时间片； – （5）优先级是从0到10的整数，并且它仅表示线程之间的相对关系； – （6）多个线程共享一组资源，有可能在运行时产生冲突。必须采用
synchronized关键字协调资源，实现线程同步。
8.2 线程类
8.2.1 8.2.2 8.2.3
多线程编程中常用的常量和方法 线程的生命周期 创建多线程的方法
7.
System.out.println("当前线程： "+curr);
8.
System.out.println("线程名： "+ curr.getName( ));
9.
System.out.println("优先级 ："+
curr.getPriority( ));
10.
}
11.}
程序输出结果：
notify notify All
I/O请求 stop wait
结束
等待
图8-1 线程生命周期示意图
8.2.3 创建多线程的方法
Java中编程实现多线程应有两种途径
–一种是创建Thread线程的子类 –实现一个接口Runnable –无论是哪种途径最终都需要使用Thread类及其方法。
8.2.3 创建多线程的方法
2. int sleeptime;
3. public myThread(String id) { // 构造函数
4.
super(id);
5.
sleeptime=(int)(Math.random( )*100);
6.
System.out.println("The Thread Name="+getName( )+
盖该方法时，前面必须带上public。
8.2.3 创建多线程的方法
2．通过实现Runnable接口实现多线程
–（1）定义一个实现Runnable接口的类。 –（2）定义方法run( )。Runnable接口中有一个空的方
法run( )，实现它的类必须覆盖此方法。 –（3）创建该类的一个线程对象，并将该对象作参数，
t1.start( );
t2.start( );
27.
t3.start( );
t4.start( );
28. }
29.}
【实例8-2】
程序某次的运行结果： he Thread Name=Thread 1，Sleeping： 6 The Thread Name=Thread 2，Sleeping： 49 The Thread Name=Thread 3，Sleeping： 19 The Thread Name=Thread 4，Sleeping： 69 The running Thread=Thread 1 The running Thread=Thread 3 The running Thread=Thread 2 The running Thread=Thread 4 ★注意：Thread类中的run( )方法具有public属性，覆
“Dead”（死亡）状态：
– Dead表示线程巳退出运行状态，并且不再进入就绪队列。其中原 因可能是线程巳执行完毕（正常结束），也可能是该线程被另一 线程所强行中断（kill）。
I/O请求结束
阻塞
创建
resume
挂起
suspend
start
时间片结束
就绪
运行
分配时间片
sleep
睡眠时 间结束
睡眠
传递给Thread类的构造函数，从而生成Thread类的一 个对象。 –（4）通过start( )方法启动线程。
【实例8-3】
1. class myThread implements Runnable{
2. int count=1，number;
3. public myThread(int num){
【实例8-1】
1. class getThreadInfo {
2.
public static void main(String args[ ]) {
3.
Thread curr;
4.
int num=7;
5.
curr=Thread.currentThread( );
6.
curr.setPriority(num);
8.1 多线程的概念
多线程具有以下特点：
– （1）多个线程在运行时，系统自动在线程之间进行切换； – （2）由于多个线程共存于同一块内存，线程之间的通信非常容易； – （3）Java将线程视为一个对象。线程要么是Thread类的对象，要么是接
口Runnable的对象。 – （4）当多个线程并行执行时，具有较高优先级的线程将获得较多的CPU
8.2.2 线程的生命周期
"Runnable"（就绪）状态：
–表示线程正等待处理器资源，随时可被调用执行。处 于就绪状态的线程事实上己被调度，也就是说，它们 己经被放到某一队列等待执行。处于就绪状态的线程 何时可真正执行，取决于线程优先级以及队列的当前 状况。线程的优先级如果相同，将遵循"先来先服务" 的调度原则。
17. }
18. }
【实例8-3】 程序运行某次的输出结果：
创建线程：1 创建线程：2 线程 1：计数 1 线程 1：计数 2 线程 1：计数 3 线程 2：计数 1 线程 2：计数 2 线程 2：计数 3 创建线程：3 线程 3：计数 1 线程 3：计数 2 线程 3：计数 3 ★值得指出的是同一个实现了Runnable接口的对象作为参数产生的所有
1．通过继承Thread类实现多线程
–（1） 定义Thread类的一个子类。 –（2） 定义子类中的方法run( )，覆盖父类中的方法
run( )。 –（3）创建该子类的一个线程对象。 –（4） 通过start( )方法启动线程。
【实例8-2】
1. class myThread extends Thread{
8.3 资源的协调与同步
8.3.1 8.3.2 8.3.3
线程调度模型 资源冲突 同步方法
8.3.1 线程调度模型
当计算机中只有一个CPU时，同一时刻正在运行的线程只能有一个， 当一个新的线程通过new()创建并通过start()方法启动后，线程只是 进入就绪状态，是否能运行要看调度的结果。
8.2.1 多线程编程中常用的常量和方法
常用方法：
– currentThread( )：返回当前运行的线程对象，是一个静态的方 法。
– sleep(int n) ： 使当前运行的线程睡n个毫秒，然后继续执行， 也是静态方法。
– yield( ) ：使当前运行的线程放弃执行，切换到其它线程，是 一个静态方法。
第8章 多线程
8.1 多线程的概念 8.2 线程类 8.3 资源的协调与同步 8.4 线程间通信
8.1 多线程的概念
程序是一段静态的代码，它是应用软件执行的蓝 本。进程就是程序的运行时的一个实例。
线程可以看作单独地占有CPU时间来执行相应的代 码的。
线程是共享地址空间的，也就是说多线程可以同 时读取相同的地址空间，并且利用这个空间进行 交换数据。
8.2.2 线程的生命周期
“Running”（运行）状态：
–表明线程正在运行，该线己经拥有了对处理器的控制 权，其代码目前正在运行。这个线程将一直运行直到 运行完毕，除非运行过程的控制权被一优先级更高的 线程强占。
8.2.2 线程的生命周期
“Blocked”（堵塞）状态：
– 一个线程如果处于"Blocked"（堵塞）状态，那么暂时这个线程 将无法进入就绪队列。处于堵塞状态的线程通常必须由某些事件 才能唤醒。至于是何种事件，则取决于堵塞发生的原因：处于睡 眠中的线程必须被堵塞一段固定的时间;被挂起、或处于消息等 待状态的线程则必须由一外来事件唤醒。
Thread对象是同一对象下的线程。
8.2.3 创建多线程的方法
3．两种方法的简单比较
– 使用Thread方法简单明了，符合大家的习惯，但是，它也有一个 很大的缺点，那就是如果我们的类已经从一个类继承（如小程序 必须继承自 Applet 类），则无法再继承 Thread 类。
– 使用 Runnable 接口来实现多线程使得我们能够在一个类中包容 所有的代码，有利于封装，它的缺点在于，我们只能使用一套代 码，若想创建多个线程并使各个线程执行不同的代码，则仍必须 额外创建类，如果这样的话，在大多数情况下也许还不如直接用 多个类分别继承 Thread 来得紧凑。
11.
}
12. }
13. }
14. public class runnableThreads{
15. public static void main(String args[]){
16.
for(int i = 0; i<5; i++) new Thread(new myThread(i+1)).start();
7.
"，Sleeping： "+sleeptime);
8. }
9. public void run(){
10.
try{ // 通过线程睡眠模拟程序的执行
11.
Thread.sleep(sleeptime);
1dException e){
14.
System.err.println("Exception：" +e.toString());
15.
}
16.
System.out.println("The running Thread="+getName());
17. }
18.}
【实例8-2】
19.public class fourThreads{
20. public static void main(String args[ ]) {