第十四：线程

1. 第十四：线程 周甫 zoofchow@hotmail.com

2. 1 2 3 4 线程的概念 线程状态和调度 线程中断/恢复的几种方式 创建线程的两种方式 学习目标

3. 5 线程的应用 学习目标

4. 1 线程的概念 • 在单CPU的情况下，一个时刻只能运行一个进程，进程在运行时，也只能运行一个线程来代表该进程的执行。 • 进程是正在执行的程序。一个或更多的线程构成了一个进程（操作系统是以进程为单位的，而进程是以线程为单位的，进程中必须有一个主线程）。

5. 一个线程（执行上下文）由三个主要部分组成：一个线程（执行上下文）由三个主要部分组成： 一个虚拟CPU CPU执行的代码 代码操作的数据

6. 代码可以由多个线程共享，它不依赖数据。如果两个线程执行同一个类的实例的代码时，则它们可以共享相同的代码。代码可以由多个线程共享，它不依赖数据。如果两个线程执行同一个类的实例的代码时，则它们可以共享相同的代码。 • 类似地，数据可以由多个线程共享，而不依赖代码。如果两个线程共享对一个公共对象的访问，则它们可以共享相同的数据。 • 在Java编程中，虚拟处理机封装在Thread类的一个实例里。构造线程时，定义其上下文的代码和数据是由传递给它的构造函数的对象指定的。Java线程分守护线程和用户线程，由创建时设置。

7. 2 创建线程的两种方式 • 1. 实现Runnable接口 从面向对象的角度来看，Thread类是一个虚拟处理机严格的封装，因此只有当处理机模型修改或扩展时，才应该继承类。正因为这个原因和区别一个正在运行的线程的处理机、代码和数据部分的意义，本教程采用了这种方法。 由于Java技术只允许单一继承，所以如果你已经继承了Thread，你就不能再继承其它任何类，例如Applet。在某些情况下，这会使你只能采用实现Runnable的方法。 因为有时你必须实现Runnable，所以你可能喜欢保持一致，并总是使用这种方法。

8. 2. 继承Thread类 当一个run()方法体现在继承Thread的类中，用this指向实际控制运行的Thread实例。因此，代码不再需要使用如下控制： Thread.currentThread().join(); 而可以简单地用： join(); 因为代码简单了一些，许多Java编程语言的程序员使用扩展Thread的机制。注意：如果你采用这种方法，在你的代码生命周期的后期，单继承模型可能会给你带来困难。

9. 实例分析 1 • 问题的描述： 创建和启动Java线程 • 解决方案： 以2种方式创建线程

10. 实现java.lang.Runnable接口 • 实现run()方法 • 将这个新类的实例作为Thread类的构造方法的参数，创建Thread类的实例。 class Xyz implements Runnable { int i; public void run() { while (true) { System.out.println("Hello " + i++); if (i == 50) break; } } }

11. public class ThreadTest { public static void main(String args[]) { Xyz r = new Xyz(); Thread t = new Thread(r); t.start(); } } 一个新创建的线程并不自动开始运行.你必须调用它的start() 方法。例如，你可以发现上例中第4行代码中的命令： t.start(); 调用start()方法使线程所代表的虚拟处理机处于可运行状 态，这意味着它可以由JVM调度并执行。这并不意味着线程 就会立即运行。

12. 继承java.lang.Thread类 • 覆盖Thread类的run()方法 • 创建该子类的实例 class Xyz extends Thread { int i; public void run() { while (true) { System.out.println("Hello " + i++); if (i == 50) break; } } }

13. public class ThreadTest { public static void main(String args[]) { Xyz r = new Xyz(); //Thread t = new Thread(r); r.start(); } }

14. 课堂练习 • 问题描述: 以2种方式编写一个线程,打印1到100.

15. 3 线程状态和调度 • 在Java中，线程是抢占式的，而不是分时的 (一个常见的错误是认为“抢占式”只不过是“分时”的一种新奇的称呼而已) 。 • 抢占式调度模型是指可能有多个线程是可运行的，但只有一个线程在实际运行。 一个Thread对象在它的生命周期中会处于各种不同的状态。

16. Java线程不一定是分时的，所有你必须确保你的代码中的线程会不时地给另外一个线程运行的机会。有三种方法可以做到这一点：Java线程不一定是分时的，所有你必须确保你的代码中的线程会不时地给另外一个线程运行的机会。有三种方法可以做到这一点： • sleep() • yield() • join()

17. 实例分析 2 • 问题描述 2个线程的调度 class Xyz1 implements Runnable { int i; public void run() { while (true) { System.out.println("Hello " + i++); if( i == 25){ try { Thread.sleep(10); }catch (InterruptedException e) { } } if (i == 50) break; } } }

18. class Xyz2 implements Runnable { int j = 100; public void run() { while (true) { System.out.println(" World " + j++); if (j == 150) break; } } }

19. public class ThreadTest { public static void main(String args[]) { Xyz1 r1 = new Xyz1(); Xyz2 r2 = new Xyz2(); Thread t = new Thread(r1); t.start(); t = new Thread(r2); t.start(); } }

20. 课堂练习 • 问题描述: 在前一个练习的基础上编写另外一个线程,该线程打印100到1之间的递减过程.要求: 在第一个线程打印到50时,第一个线程暂停10秒.

21. 多个线程共享同一数据 当多个线程共享同一资源时，它们操作会竞争同一资源,出现一些意料之外的错误。

22. 实例分析 3 • 问题描述: 一个生产者(Producer)和一个消费者(Consumer)分别从堆栈加入和取出字符 • 生产者向堆栈(MyStack)加入一个字符 • 消费者从同一个堆栈中取出一个字符

23. public class MyStack { int idx = 0; char [] data = new char[6]; public void push(char c) { data[idx] = c; idx++; } public char pop() { idx--; return data[idx]; } }

24. public class Producer extends Thread{ MyStack mt; char[] mc = {'m','s','t','a','c','k'}; public Producer(MyStack mt){ this.mt = mt; this.start(); } public void run(){ for(int ii = 0; ii < 6; ii++){ mt.push(mc[ii]); try{ sleep(1); } catch(Exception e){} } } }

25. public class Consumer extends Thread{ MyStack mt; public Consumer(MyStack mt){ this.mt = mt; this.start(); } public void run(){ for(int ii = 0; ii < 6; ii++){ System.out.println(ii + " : " +mt.pop()); } } }

26. public class Test { public static void main(String[] args) { MyStack ms = new MyStack(); Producer p = new Producer(ms); Consumer c = new Consumer(ms); } }

27. 对象锁与同步(synchronized) • 每个对象都有一个标志,它被认为是”锁标志”. • synchronized允许和锁标志交互。 • 要使锁有效，所有存取共享数据的方法必须在同一把锁上同步。 • 锁是对象级的。成员没有所谓的锁。

28. 下面是对前一示例的修改： public void push(char c) { synchronized(this) { data[idx] = c; idx++; } } public char pop() { synchronized(this) { idx--; return data[idx]; } }

29. 释放锁标志 • 线程执行到synchronized()代码块末尾时释放 • synchronized()代码块抛出中断或异常时自动释放 • 由于等待一个对象的锁标志的线程在得到标志之前不能恢复运行，所以让持有锁标志的线程在不再需要的时候返回标志是很重要的。 • 锁标志将自动返回给它的对象。持有锁标志的线程执行到synchronized()代码块末尾时将释放锁。Java技术特别注意了保证即使出现中断或异常而使得执行流跳出synchronized()代码块，锁也会自动返回。

30. 死锁 • 两个线程相互等待对方占用的锁 • 死锁不能被监测也不可避免 • 死锁可以通过以下方法来避免 • 确定获取锁的次序 • 始终遵照这个次序 • 按照相反的次序释放锁

31. 同步示例 • 对前面的资源竞争的例子稍做改动。在MyStack的两个方法进行同步。 • public synchronized void push(char c){…} • public synchronized char pop(){…}

32. 通过wait()和notify()/notifyAll()方法进行同步 Object类中提供了用于线程通信的方法：wait()和notify()，notifyAll()。如果线程对一个指定的对象x发出一个wait()调用，该线程会暂停执行,此外，调用wait()的线程自动释放对象的锁，直到另一个线程对同一个指定的对象x发出一个notify()调用。 为了让线程对一个对象调用wait()或notify()，线程必须锁定那个特定的对象。也就是说，只能在它们被调用的实例的同步块内使用wait()和notify()。

33. public class MyStack { int idx = 0; char[] data = new char[26]; public synchronized void push(char c) { this.notify(); if(idx > 0){ try{ this.wait(); } catch(Exception e){e.printStackTrace();} } data[idx] = c; idx++; }

34. public synchronized char pop() { this.notify(); if(idx <= 0) { try { this.wait(); } catch(Exception e){e.printStackTrace();} } idx--; return data[idx]; } }

35. 独立实践 • 实践 1 创建一个可以容纳10个随机整数的栈堆，数据的加入在数组尾部，删除在头部，并保证线程操作的安全性。