11. 多线程

一个程序可以创建多个线程。
…… Thread newThrd0 = new Thread(new MyThread("子线程#1")); Thread newThrd1 = new Thread(new MyThread("子线程#2")); Thread newThrd2 = new Thread(new MyThread("子线程#3")); newThrd0.start(); newThrd1.start(); newThrd2.start();
}
}
主线程最后结束是良好的编程习惯。
2）扩展（继承）Thread 类同样需要重写 run() 方法
public class MyThread extends Thread { String thrdName; public MyThread(String name) { thrdName = name; } @Override public void run() { System.out.println(thrdName + " 开始了。"); try { for (int count = 0; count < 5; count++) { Thread.sleep(400); // 线程暂停 400 毫秒 System.out.println("在线程 " + thrdName + "内， count = " + count); } } catch (InterruptedException exc) { System.out.println(thrdName + " 中断了。"); } System.out.println(thrdName + " 结束了。"); } }
public class Example { public static void main(String[] args) { System.out.println("主线程开始了。");
int a[] = { 6, 2, 10 };
// 共享资源
Thread newThrd0 = new Thread(new MyThread(a), "子线程#1"); Thread newThrd1 = new Thread(new MyThread(a), "子线程#2"); newThrd0.start(); try { newThrd0.join(); newThrd1.join(); // 等子线程结束 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("主线程结束了。"); } } newThrd1.start();
public class SumArray { private int sum; synchronized int sumArray(int nums[]) {
sum = 0;
for (int i : nums) { sum += i; System.out.println("正在运行的子线程 " + Thread.currentThread().getName() + " 目前的计算结果是：" + sum); try { Thread.sleep(10); } catch (InterruptedException ex) { System.out.println("线程中断");
public class MyThread implements Runnable { String thrdName; public MyThread(String name) { thrdName = name;
}
@Override public void run() { System.out.println(thrdName + " 开始了。"); try { for (int count = 0; count < 5; count++) { Thread.sleep(400); // 线程暂停 400 毫秒 System.out.println("在线程 " + thrdName + "内， count = " + count); } } catch (InterruptedException exc) { System.out.println(thrdName + " 中断了。"); } System.out.println(thrdName + " 结束了。"); } }
三、线程同步
使线程协调工作的过程称为同步（synchronization）。 需要同步最常见的原因是多个线程都需要访问某一时刻只能由一个线程 使用的共享资源。
Java 中使用 “锁”来实现同步，资源被一个线程“锁”住以后，其他线 程就不能访问。 1. 同步方法
在方法前加上 synchronized 关键字定义同步方法，当线程可运行对象 的 run() 调用同步方法时，线程锁住对象（数据），其他线程试图访问 对象时等待，方法执行结束时解锁。
MyThread mt = new MyThread("子线程#1");
Thread newThrd = new Thread(mt);
do { try { Thread.sleep(100);
newThrd.start();
} catch (InterruptedException ex) {
System.out.println("主线程中断了。"); } } while (newThrd.isAlive()); // 子线程未结束
2. 同步语句 如果仅仅打算让线程中的语句同步，只需将语句放入 synchronized 代 码块中即可。 synchronized(同步语句所属对象) { 同步语句; }
public void run() { answer = 0; synchronized(this) { for (int i : a) { answer += i; System.out.println("正在运行的子线程 " + Thread.currentThread().getName() + " 目前的计算结果是：" + answer); } } …… }
……
每个线程都有优先级，决定了相对于其他活动线程，被 CPU 执行的可能 的优先等级和执行时间。 默认情况下，子线程的优先级与父线程相同，可以通过线程对象的 setPriorty(int 优先级) 来改变。
2. 线程结束 线程的 run() 方法结束后就自行结束。
判断线程结束的方法：
1）线程对象调用 isAlive()，通过返回值是否为 true 判断。
public class Example { public static void main(String[] args) { System.out.println("主线程开始了。"); MyThread mt = new MyThread("子线程#1"); // 创建可运行对象 Thread newThrd = new Thread(mt); // 构造一个线程 newThrd.start(); for (int i = 0; i < 15; i++) { System.out.print(". "); try { Thread.sleep(100); } catch (InterruptedException exc) { System.out.println("主线程中断了。"); } } System.out.println("主线程结束了如果线程 T 访问资源 x 时不可用，于是开始等待，但是 T 锁住了资源 y，这样一来，造成 y 也无法被其他线程访问。需要 T 暂时 解锁 y，当 x 可用时，再通知 T 继续执行。 这个过程就需要线程间的通信。 wait()、notify() 和 notifyAll() 方法用于线程间的通信。 • wait() 方法：调用 wait() 方法使线程等待，暂时解锁其他资源 • notify() 方法：解锁资源，通知一个等待线程
• notifyAll() 方法：解锁资源，通知所有等待线程
wait() 的调用应该出现在一个判断资源是否可用的循环中。
如果多个线程相互竞争资源且无法释放，称为死锁。
public class MyThread implements Runnable { …… boolean isWorking = false; // 资源占用标志 @Override public void run() { synchronized (this) { while (isWorking) { // 资源被占用时 wait() try { wait(); } catch (InterruptedException e) { … } } isWorking = true; // 设立标志，让其他线程 wait() for (int i : a) { // 资源使用中 answer += i; System.out.println("正在运行的子线程 " + Thread.currentThread().getName() + " 目前的计算结果是：" + answer); } isWorking = false; // 修改标志，表示资源占用完毕 notifyAll(); // 通知其他线程恢复执行 } } }