疯狂JAVA讲义---第十六章：多线程（下）

看过我昨天的博客，大家肯定对多线程有所了解，今天要讲多线程中比较高层次的东西。首先讲下JDK1.5新出来的线程同步机制---同步锁（Lock），其实和synhronized方法用法差不多，只是更灵活。同步锁有多种，其中一般为了线程安全都用ReentrantLock(可重入锁)，eg

public class Account { //定义锁对象 private final ReentrantLock lock = new ReentrantLock(); private String accountNo; private double balance; public Account(){} public Account(String accountNo , double balance) { this.accountNo = accountNo; this.balance = balance; } public void setAccountNo(String accountNo) { this.accountNo = accountNo; } public String getAccountNo() { return this.accountNo; } public double getBalance() { return this.balance; } public void draw(double drawAmount) { lock.lock(); try { //账户余额大于取钱数目 if (balance >= drawAmount) { //吐出钞票 System.out.println(Thread.currentThread().getName() + "取钱成功！吐出钞票:" + drawAmount); try { Thread.sleep(1); } catch (InterruptedException ex) { ex.printStackTrace(); } //修改余额 balance -= drawAmount; System.out.println("/t余额为: " + balance); } else { System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足！"); } } finally { lock.unlock(); } } public int hashCode() { return accountNo.hashCode(); } public boolean equals(Object obj) { if (obj != null && obj.getClass() == Account.class) { Account target = (Account)obj; return target.getAccountNo().equals(accountNo); } return false; } }

下面讲下线程的协调

void   notify():      唤醒一个正在等待该对象的线程。   
void   notifyAll():   唤醒所有正在等待该对象的线程。eg

public class Account { private String accountNo; private double balance; //标识账户中是否已有存款的旗标 private boolean flag = false; public Account(){} public Account(String accountNo , double balance) { this.accountNo = accountNo; this.balance = balance; } public void setAccountNo(String accountNo) { this.accountNo = accountNo; } public String getAccountNo() { return this.accountNo; } public double getBalance() { return this.balance; } public synchronized void draw(double drawAmount) { try { //如果flag为假，表明账户中还没有人存钱进去，则取钱方法阻塞 if (!flag) { wait(); } else { //执行取钱 System.out.println(Thread.currentThread().getName() + " 取钱:" + drawAmount); balance -= drawAmount; System.out.println("账户余额为：" + balance); //将标识账户是否已有存款的旗标设为false。 flag = false; //唤醒其他线程 notifyAll(); } } catch (InterruptedException ex) { ex.printStackTrace(); } } public synchronized void deposit(double depositAmount) { try { //如果flag为真，表明账户中已有人存钱进去，则存钱方法阻塞 if (flag) { wait(); } else { //执行存款 System.out.println(Thread.currentThread().getName() + " 存款:" + depositAmount); balance += depositAmount; System.out.println("账户余额为：" + balance); //将表示账户是否已有存款的旗标设为true flag = true; //唤醒其他线程 notifyAll(); } } catch (InterruptedException ex) { ex.printStackTrace(); } } public int hashCode() { return accountNo.hashCode(); } public boolean equals(Object obj) { if (obj != null && obj.getClass() == Account.class) { Account target = (Account)obj; return target.getAccountNo().equals(accountNo); } return false; } }

当使用同步锁时不能使用wait(),notify(),notifyAll(),而要使用Condition实例来操作，eg

public class Account { //显示定义Lock对象 private final Lock lock = new ReentrantLock(); //获得指定Lock对象对应的条件变量 private final Condition cond = lock.newCondition(); private String accountNo; private double balance; //标识账户中是否已经存款的旗标 private boolean flag = false; public Account(){} public Account(String accountNo , double balance) { this.accountNo = accountNo; this.balance = balance; } public void setAccountNo(String accountNo) { this.accountNo = accountNo; } public String getAccountNo() { return this.accountNo; } public double getBalance() { return this.balance; } public void draw(double drawAmount) { //加锁 lock.lock(); try { //如果账户中还没有存入存款，该线程等待 if (!flag) { cond.await(); } else { //执行取钱操作 System.out.println(Thread.currentThread().getName() + " 取钱:" + drawAmount); balance -= drawAmount; System.out.println("账户余额为：" + balance); //将标识是否成功存入存款的旗标设为false flag = false; //唤醒该Lock对象对应的其他线程 cond.signalAll(); } } catch (InterruptedException ex) { ex.printStackTrace(); } //使用finally块来确保释放锁 finally { lock.unlock(); } } public void deposit(double depositAmount) { lock.lock(); try { //如果账户中已经存入了存款，该线程等待 if(flag) { cond.await(); } else { //执行存款操作 System.out.println(Thread.currentThread().getName() + " 存款:" + depositAmount); balance += depositAmount; System.out.println("账户余额为：" + balance); //将标识是否成功存入存款的旗标设为true flag = true; //唤醒该Lock对象对应的其他线程 cond.signalAll(); } } catch (InterruptedException ex) { ex.printStackTrace(); } //使用finally块来确保释放锁 finally { lock.unlock(); } } public int hashCode() { return accountNo.hashCode(); } public boolean equals(Object obj) { if (obj != null && obj.getClass() == Account.class) { Account target = (Account)obj; return target.getAccountNo().equals(accountNo); } return false; } }

线程通信，eg（使用管道通信）

class ReaderThread extends Thread { private PipedReader pr; //用于包装管道流的BufferReader对象 private BufferedReader br; public ReaderThread(){} public ReaderThread(PipedReader pr) { this.pr = pr; this.br = new BufferedReader(pr); } public void run() { String buf = null; try { //逐行读取管道输入流中的内容 while ((buf = br.readLine()) != null) { System.out.println(buf); } } catch (IOException ex) { ex.printStackTrace(); } //使用finally块来关闭输入流 finally { try { if (br != null) { br.close(); } } catch (IOException ex) { ex.printStackTrace(); } } } } class WriterThread extends Thread { String[] books = new String[] { "Struts2权威指南", "ROR敏捷开发指南", "基于J2EE的Ajax宝典", "轻量级J2EE企业应用指南" }; private PipedWriter pw; public WriterThread(){} public WriterThread(PipedWriter pw) { this.pw = pw; } public void run() { try { //循环100次，向管道输出流中写入100个字符串 for (int i = 0; i < 100 ; i++) { pw.write(books[i % 4] + "/n"); } } catch (IOException ex) { ex.printStackTrace(); } //使用finally块来关闭管道输出流 finally { try { if (pw != null) { pw.close(); } } catch (IOException ex) { ex.printStackTrace(); } } } } public class PipedCommunicationTest { public static void main(String[] args) { PipedWriter pw = null; PipedReader pr = null; try { //分别创建两个独立的管道输出流、输入流 pw = new PipedWriter(); pr = new PipedReader(); //连接管道输出流、出入流 pw.connect(pr); //将连接好的管道流分别传入2个线程， //就可以让两个线程通过管道流进行通信 new WriterThread(pw).start(); new ReaderThread(pr).start(); } catch (IOException ex) { ex.printStackTrace(); } } }

但一般不用以上方法来通信而是利用共享数据来通信，这样更方便，而网络中线程之间的通信就用的比较多了，这我会过两天的blog中讲。

利用线程组来分组处理未处理的异常，eg

class TestThread extends Thread { //提供指定线程名的构造器 public TestThread(String name) { super(name); } //提供指定线程名、线程组的构造器 public TestThread(ThreadGroup group , String name) { super(group, name); } public void run() { for (int i = 0; i < 20 ; i++ ) { System.out.println(getName() + " 线程的i变量" + i); } } } public class ThreadGroupTest { public static void main(String[] args) { //获取主线程所在的线程组，这是所有线程默认的线程组 ThreadGroup mainGroup = Thread.currentThread().getThreadGroup(); System.out.println("主线程组的名字：" + mainGroup.getName()); System.out.println("主线程组是否是后台线程组：" + mainGroup.isDaemon()); new TestThread("主线程组的线程").start(); ThreadGroup tg = new ThreadGroup("新线程组"); tg.setDaemon(true); System.out.println("tg线程组是否是后台线程组：" + tg.isDaemon()); TestThread tt = new TestThread(tg , "tg组的线程甲"); tt.start(); new TestThread(tg , "tg组的线程乙").start(); } }

处理未处理的异常，eg

//定义自己的异常处理器 class MyExHandler implements Thread.UncaughtExceptionHandler { //实现uncaughtException方法，该方法将处理线程的未处理异常 public void uncaughtException(Thread t, Throwable e) { System.out.println(t + " 线程出现了异常：" + e); } } public class ExHandler { public static void main(String[] args) { //设置主线程的异常处理器 Thread.currentThread().setUncaughtExceptionHandler( new MyExHandler()); int a = 5 / 0; } }

最后讲个线程池的例子，JDK1.5本身提供了线程池，所以很方便，eg

class TestThread implements Runnable { public void run() { for (int i = 0; i < 100 ; i++ ) { System.out.println(Thread.currentThread().getName() + "的i值为:" + i); } } } public class ThreadPoolTest { public static void main(String[] args) { //创建一个具有固定线程数（6）的线程池 ExecutorService pool = Executors.newFixedThreadPool(6); //向线程池中提交2个线程 pool.submit(new TestThread()); pool.submit(new TestThread()); //关闭线程池 pool.shutdown(); } }

以后我将讲我以前做过的断点续传工具，就是利用了线程池，今天就到这里