11 第十一课：线程

World " + j++);
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(); } }

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

实现ng.Runnable接口
实现run()方法 将这个新类的实例作为Thread类的构造方法的参数，创建Thread 类的实例。
class Xyz implements Runnable { int i;

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

下面是对前一示例的修改： public void push(char c) { synchronized(this) { data[idx] = c; idx++; } } public char pop() { synchronized(this) { idx--; return data[idx]; } }
问题描述 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; } } }
}

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


class Xyz2 implements Runnable { int j = 100; public void run() { while (true) { System.out.println(" if (j == 150) break; } : 在前一个练习的基础上编写另外一个线程, 该线程打印100到1之间的递减过程.要求: 在第一个线程打印到50时,第一个线程暂停 直至第二个线程结束.

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

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

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

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

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{

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

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

public class Test { public static void main(String[] args) { MyStack ms = new MyStack(); Producer p = new Producer(ms); Consumer c = new Consumer(ms); } }
sleep(1);
} catch(Exception e){} } }
}

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()); } } }

一个Thread对象在它的生命周期中会处于各种不同的状态。

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

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

3 线程状态和调度 在Java中，线程是抢占式的，而不是分时的 (一 个常见的错误是认为“抢占式”只不过是“分时” 的一种新奇的称呼而已) 。 抢占式调度模型是指可能有多个线程是可运行的， 但只有一个线程在实际运行。

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

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

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

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]; } }
public void run() { while (true) { System.out.println("Hello " + i++); if (i == 50) break; } }
}

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调度并执行。这并不意味着线程 就会立即运行。

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