2011.09.07

Java线程：线程的交互  

一、线程交互的基础知识

线程交互知识点需要从java.lang.Object的类的三个方法来学习： 

l void notify() ：唤醒在此对象监视器上等待的单个线程。 

l void notifyAll()：唤醒在此对象监视器上等待的所有线程。 

l void wait() ：导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或notifyAll() 方法。

notify():

(唤醒)

      (在此对象监视器上)

 (等待的)

(单个)

      (线程)。

当然，wait()还有另外两个重载方法：

void wait(long timeout) 

导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。 
void wait(long timeout, int nanos) 

导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。 

以上这些方法是帮助线程传递线程关心的时间状态。

 

关于等待/通知，要记住的关键点是：必须从同步环境内调用wait()、notify()、notifyAll()方法。线程不能调用对象上等待或通知的方法，除非它拥有那个对象的锁。

wait()、notify()、notifyAll()都是Object的实例方法。与每个对象具有锁一样，每个对象可以有一个线程列表，他们等待来自该信号（通知）。线程通过执行对象上的wait()方法获得这个等待列表。从那时候起，它不再执行任何其他指令，直到调用对象的notify()方法为止。如果多个线程在同一个对象上等待，则将只选择一个线程（不保证以何种顺序）继续执行。如果没有线程等待，则不采取任何特殊操作。

 

下面看个例子就明白了：

/** 
* 计算输出其他线程锁计算的数据 
*/ 
public class ThreadA { 
    public static void main(String[] args) { 
        ThreadB b = new ThreadB(); 
        //启动计算线程 
        b.start(); 
        //线程A拥有b对象上的锁。线程为了调用wait()或notify()方法，该线程必须是那个对象锁的拥有者 
        synchronized (b) { 
            try { 
                System.out.println("等待对象b完成计算。。。"); 
                //当前线程A等待 
                b.wait(); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
            System.out.println("b对象计算的总和是：" + b.total); 
        } 
    } 
}

 

/** 
* 计算1+2+3 ... +100的和 
*/ 
public class ThreadB extends Thread { 
    int total; 

    public void run() { 
        synchronized (this) { 
            for (int i = 0; i < 101; i++) { 
                total += i; 
            } 
            //（完成计算了）唤醒在此对象监视器上等待的单个线程，在本例中线程A被唤醒 
            notify(); 
        } 
    } 
}

 

等待对象b完成计算。。。 
b对象计算的总和是：5050 

Process finished with exit code 0 

解释：主线程中的b和线程任务中的this是一个东西，属于临界资源，因此二者将需要进行互斥访问，主线程中的同步代码块先于线程run（）中的同步代码块运行，因此先获得锁，但是却在随后的代码中调用wait放弃了锁，这样线程任务获得锁并进行累加。线程任务完成累加后调用notify重新唤醒了主线程并且由其打印累加结果。

千万注意：

当在对象上调用wait()方法时，执行该代码的线程立即放弃它在对象上的锁。然而调用notify()时，并不意味着这时线程会放弃其锁。如果线程仍然在完成同步代码，则线程在移出之前不会放弃锁。因此，只要调用notify()并不意味着这时该锁变得可用。

二、多个线程在等待一个对象锁时候使用notifyAll()

  在多数情况下，最好通知等待某个对象的所有线程。如果这样做，可以在对象上使用notifyAll()让所有在此对象上等待的线程重出等待区，返回到可运行状态。

 

下面给个例子：

/** 
* 计算线程 
*/ 
public class Calculator extends Thread { 
        int total; 

        public void run() { 
                synchronized (this) { 
                        for (int i = 0; i < 101; i++) { 
                                total += i; 
                        } 
                } 
                //通知所有在此对象上等待的线程 
                notifyAll(); 
        } 
}

 

/** 
* 获取计算结果并输出 
* 
* @author leizhimin 2008-9-20 11:15:22 
*/ 
public class ReaderResult extends Thread { 
        Calculator c; 

        public ReaderResult(Calculator c) { 
                this.c = c; 
        } 

        public void run() { 
                synchronized (c) { 
                        try { 
                                System.out.println(Thread.currentThread() + "等待计算结果。。。"); 
                                c.wait(); 
                        } catch (InterruptedException e) { 
                                e.printStackTrace(); 
                        } 
                        System.out.println(Thread.currentThread() + "计算结果为：" + c.total); 
                } 
        } 

        public static void main(String[] args) { 
                Calculator calculator = new Calculator(); 

                //启动三个线程，分别获取计算结果 
                new ReaderResult(calculator).start(); 
                new ReaderResult(calculator).start(); 
                new ReaderResult(calculator).start(); 
                //启动计算线程 
                calculator.start(); 
        } 
}

 

运行结果：

Thread[Thread-1,5,main]等待计算结果。。。 
Thread[Thread-2,5,main]等待计算结果。。。 
Thread[Thread-3,5,main]等待计算结果。。。 
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException: current thread not owner 
  at java.lang.Object.notifyAll(Native Method) 
  at threadtest.Calculator.run(Calculator.java:18) 
Thread[Thread-1,5,main]计算结果为：5050 
Thread[Thread-2,5,main]计算结果为：5050 
Thread[Thread-3,5,main]计算结果为：5050 

Process finished with exit code 0 

 

运行结果表明，程序中有异常，并且多次运行结果可能有多种输出结果。这就是说明，这个多线程的交互程序还存在问题。究竟是出了什么问题，需要深入的分析和思考，下面将做具体分析。

实际上，上面这个代码中，我们期望的是读取结果的线程在计算线程调用notifyAll()之前等待即可。 但是，如果计算线程先执行，并在读取结果线程等待之前调用了notify()方法，那么又会发生什么呢？这种情况是可能发生的。因为无法保证线程的不同部分将按照什么顺序来执行。幸运的是当读取线程运行时，它只能马上进入等待状态----它没有做任何事情来检查等待的事件是否已经发生。  ----因此，如果计算线程已经调用了notifyAll()方法，那么它就不会再次调用notifyAll()，----并且等待的读取线程将永远保持等待。这当然是开发者所不愿意看到的问题。

  因此，当等待的事件发生时，需要能够检查notifyAll()通知事件是否已经发生。

  通常，解决上面问题的最佳方式是利用某种循环，该循环检查某个条件表达式，只有当正在等待的事情还没有发生的情况下，它才继续等待。 

在上例ReaderResult的main函数里的calculator.start(); 如果先于new ReaderResult(calculator).start();运行则会出现上述的问题，及还没有wait呢notify就已经被调用，试利用上述技巧解决这个问题。

//将上例中的ReaderResult类修改为：

public class ReaderResult extends Thread {

Calculator c;

public ReaderResult(Calculator c) {

this.c = c;

}

public void run() {

synchronized (c) {

while (c.total == 0) {

try {

c.wait();

} catch (InterruptedException e1) {

e1.printStackTrace();

}

}

System.out.println(Thread.currentThread() + "计算结果为：" + c.total);

}

}

public static void main(String[] args) {

Calculator calculator = new Calculator();

calculator.start();

// 启动三个线程，分别获取计算结果

new ReaderResult(calculator).start();

new ReaderResult(calculator).start();

new ReaderResult(calculator).start();

// 启动计算线程

}

三、并发协作的经典案例-生产者消费者模型

  对于多线程程序来说，不管任何编程语言，生产者和消费者模型都是最经典的。就像学习每一门编程语言一样，Hello World！都是最经典的例子。

实际上，准确说应该是“生产者-消费者-仓储”模型，离开了仓储，生产者消费者模型就显得没有说服力了。

对于此模型，应该明确一下几点：

1、生产者仅仅在仓储未满时候生产，仓满则停止生产。

2、消费者仅仅在仓储有产品时候才能消费，仓空则等待。

3、当消费者发现仓储没产品可消费时候会通知生产者生产。

4、生产者在生产出可消费产品时候，应该通知等待的消费者去消费。

此模型将要结合java.lang.Object的wait与notify、notifyAll方法来实现以上的需求。这是非常重要的。

 

/** 
* Java线程：并发协作-生产者消费者模型 
*/ 
public class Test { 
        public static void main(String[] args) { 
                Godown godown = new Godown(30); 
                Consumer c1 = new Consumer(50, godown); 
                Consumer c2 = new Consumer(20, godown); 
                Consumer c3 = new Consumer(30, godown); 
                Producer p1 = new Producer(10, godown); 
                Producer p2 = new Producer(10, godown); 
                Producer p3 = new Producer(10, godown); 
                Producer p4 = new Producer(10, godown); 
                Producer p5 = new Producer(10, godown); 
                Producer p6 = new Producer(10, godown); 
                Producer p7 = new Producer(80, godown); 

                c1.start(); 
                c2.start(); 
                c3.start(); 
                p1.start(); 
                p2.start(); 
                p3.start(); 
                p4.start(); 
                p5.start(); 
                p6.start(); 
                p7.start(); 
        } 
} 

/** 
* 仓库 
*/ 
class Godown { 
        public static final int max_size = 100; //最大库存量 
        public int curnum;     //当前库存量 

        Godown() { 
        } 

        Godown(int curnum) { 
                this.curnum = curnum; 
        } 

        /** 
         * 生产指定数量的产品 
         * 
         * @param neednum 
         */ 
        public synchronized void produce(int neednum) { 
                //测试是否需要生产 
                while (neednum + curnum > max_size) { 
                        System.out.println("要生产的产品数量" + neednum + "超过剩余库存量" + (max_size - curnum) + "，暂时不能执行生产任务!"); 
                        try { 
                                //当前的生产线程等待 
                                wait(); 
                        } catch (InterruptedException e) { 
                                e.printStackTrace(); 
                        } 
                } 
                //满足生产条件，则进行生产，这里简单的更改当前库存量 
                curnum += neednum; 
                System.out.println("已经生产了" + neednum + "个产品，现仓储量为" + curnum); 
                //唤醒在此对象监视器上等待的所有线程 
                notifyAll(); 
        } 

        /** 
         * 消费指定数量的产品 
         * 
         * @param neednum 
         */ 
        public synchronized void consume(int neednum) { 
                //测试是否可消费 
                while (curnum < neednum) { 
                        try { 
                                //当前的生产线程等待 
                                wait(); 
                        } catch (InterruptedException e) { 
                                e.printStackTrace(); 
                        } 
                } 
                //满足消费条件，则进行消费，这里简单的更改当前库存量 
                curnum -= neednum; 
                System.out.println("已经消费了" + neednum + "个产品，现仓储量为" + curnum); 
                //唤醒在此对象监视器上等待的所有线程 
                notifyAll(); 
        } 
} 

/** 
* 生产者 
*/ 
class Producer extends Thread { 
        private int neednum;                //生产产品的数量 
        private Godown godown;            //仓库 

        Producer(int neednum, Godown godown) { 
                this.neednum = neednum; 
                this.godown = godown; 
        } 

        public void run() { 
                //生产指定数量的产品 
                godown.produce(neednum); 
        } 
} 

/** 
* 消费者 
*/ 
class Consumer extends Thread { 
        private int neednum;                //生产产品的数量 
        private Godown godown;            //仓库 

        Consumer(int neednum, Godown godown) { 
                this.neednum = neednum; 
                this.godown = godown; 
        } 

        public void run() { 
                //消费指定数量的产品 
                godown.consume(neednum); 
        } 
}

 

已经生产了10个产品，现仓储量为40 
已经生产了10个产品，现仓储量为50 
已经消费了50个产品，现仓储量为0 
已经生产了80个产品，现仓储量为80 
已经消费了30个产品，现仓储量为50 
已经生产了10个产品，现仓储量为60 
已经消费了20个产品，现仓储量为40 
已经生产了10个产品，现仓储量为50 
已经生产了10个产品，现仓储量为60 
已经生产了10个产品，现仓储量为70 

Process finished with exit code 0 

 

说明：

对于本例，要说明的是当发现不能满足生产或者消费条件的时候，调用对象的wait方法，wait方法的作用是释放当前线程的所获得的锁，并调用对象的notifyAll() 方法，通知（唤醒）该对象上其他等待线程，使得其继续执行。这样，整个生产者、消费者线程得以正确的协作执行。

notifyAll() 方法，起到的是一个通知作用，不释放锁，也不获取锁。只是告诉该对象上等待的线程“可以竞争执行了，都醒来去执行吧”。

 

本例仅仅是生产者消费者模型中最简单的一种表示，本例中，如果消费者消费的仓储量达不到满足，而又没有生产者，则程序会一直处于等待状态，这当然是不对的。实际上可以将此例进行修改，修改为，根据消费驱动生产，同时生产兼顾仓库，如果仓不满就生产，并对每次最大消费量做个限制，这样就不存在此问题了，当然这样的例子更复杂，更难以说明这样一个简单模型。

 

Java线程：线程的调度-守护线程

 

守护线程与普通线程写法上基本么啥区别，调用线程对象的方法setDaemon(true)，则可以将其设置为守护线程。

 

守护线程使用的情况较少，但并非无用，举例来说，JVM的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监控连接个数、超时时间、状态等等。

 

setDaemon方法的详细说明：

public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。    
  该方法必须在启动线程前调用。    

  该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。    


  参数： 
    on - 如果为 true，则将该线程标记为守护线程。    
  抛出：    
    IllegalThreadStateException - 如果该线程处于活动状态。    
    SecurityException - 如果当前线程无法修改该线程。 
  另请参见： 
    isDaemon(), checkAccess()

 

/** 
* Java线程：线程的调度-守护线程 
* 
* @author leizhimin 2009-11-4 9:02:40 
*/ 
public class Test { 
        public static void main(String[] args) { 
                Thread t1 = new MyCommon(); 
                Thread t2 = new Thread(new MyDaemon()); 
                t2.setDaemon(true);        //设置为守护线程 

                t2.start(); 
                t1.start(); 
        } 
} 

class MyCommon extends Thread { 
        public void run() { 
                for (int i = 0; i < 5; i++) { 
                        System.out.println("线程1第" + i + "次执行！"); 
                        try { 
                                Thread.sleep(7); 
                        } catch (InterruptedException e) { 
                                e.printStackTrace(); 
                        } 
                } 
        } 
} 

class MyDaemon implements Runnable { 
        public void run() { 
                for (long i = 0; i < 9999999L; i++) { 
                        System.out.println("后台线程第" + i + "次执行！"); 
                        try { 
                                Thread.sleep(7); 
                        } catch (InterruptedException e) { 
                                e.printStackTrace(); 
                        } 
                } 
        } 
}

 

后台线程第0次执行！ 
线程1第0次执行！ 
线程1第1次执行！ 
后台线程第1次执行！ 
后台线程第2次执行！ 
线程1第2次执行！ 
线程1第3次执行！ 
后台线程第3次执行！ 
线程1第4次执行！ 
后台线程第4次执行！ 
后台线程第5次执行！ 
后台线程第6次执行！ 
后台线程第7次执行！ 

Process finished with exit code 0

 

从上面的执行结果可以看出：

前台线程是保证执行完毕的，后台线程还没有执行完毕就退出了。

 

实际上：JRE判断程序是否执行结束的标准是所有的前台执线程行完毕了，而不管后台线程的状态，因此，在使用后台县城时候一定要注意这个问题。