线程杂谈之一

按照java6的docs解释，线程是一个正在执行的程序。

每个线程都优先级，高优先级的线程会优于低优先级的线程先执行，当一个正在运行的线程创造了另一个线程时，这俩个线程的优先级，一样。

关于thread本身的一些方法，本文列举了几个常用的函数。

 

1 wait：按照thinking in java的描述，wait允许我们将线程置于“睡眠”状态，同时有又积极的等待条件发生变化，只有在一个

2 notify：或者是notifyall发生变化后，线程才会被唤醒，同时检查条件是否发生变化。也就是如果一个线程中的某个资源wait了，

这个线程就一直处于等待状态，直到在其他地方改资源被notify，如果等待的线程获得了该资源的锁，则从之前开始的地方继续

向下执行。

notify vs notifyAll: notifyAll使所有原来等待该资源的线程全部notify，退出之前的wait状态，变成等待该对象上的锁，一旦对象被解锁，所有的已经退出wait，被notifyAll的线程就回去竞争，然后一个个执行完毕；

notify相对于notifyall，按照等待的顺序，只会有一个继续从上一次wait的位置往下执行，而剩下的，没有得到通知的，就会继续处于wait状态。

3 关于 run和start：

这里找了一个例子：

package thread;

public class MyThread extends Thread { 
    public void run(){ 
        for(int i=0;i<10;i++){ 
            System.out.println("mythread running"); 
        } 
    } 
    public static void main(String[] args) { 
        MyThread t=new MyThread(); 
    //  t.start(); 
     t.run();
      System.out.println("main end");
    } 
}

 

如果用run则结果是先mythread running ,然后是main end

如果是start,则是先main end 然后是mythread running

原因是如果你用了run，则实际上是一个本地方法的调用，而不是开启了一个线程

 

我这里给出了一个综合了start ,wait ,notify的生产者和消费者的例子：

 

 

package thread;

public class Food {

    public static transient boolean hasFood = true;

    public static void main(String[] args) {
        Food cargo = new Food();
        new Thread(new Customer(cargo)).start();
        new Thread(new Producer(cargo)).start();
    }
}
class Producer implements Runnable {
    public Food cargo;

    public Producer(Food cargo) {
        this.cargo = cargo;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (cargo) {
                if (!cargo.hasFood) {
                    System.out.println("I produce food");
                    cargo.hasFood=true;
                    cargo.notify();
                } else {
                    try {
                        cargo.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}
class Customer implements Runnable {

    public Food cargo;

    public Customer(Food cargo) {
        this.cargo = cargo;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            synchronized (cargo) {
                if (cargo.hasFood) {
                    cargo.hasFood = false;
                    System.out.println("I eat Food");
                    cargo.notify();
                } else {
                    try {
                        cargo.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

 4yeield:java6给出的解释是

Causes the currently executing thread object to temporarily pause and allow other threads to execute.

在这里，需要引入一个 thread quantum的概念。qunatum指的是一个线程运行的一断时间，在这个时间段之后，操作系统会检查是否有另外的，同样优先级别的线程需要进入运行状态，如果一个线程完成了他的quantum，并且没有其他的线程和他的一样高，操作系统会重新分配一个qunatum给这个线程。

在java5中，, Thread.yield() calls the Windows API call Sleep(0),这条指令可以让正在执行的线程放弃当前的quantum，根据优先级别丢在了与该线程有同样优先级的队列的最后，换句话说，其他正在运行的，有相同优先级的线程有机会在下一个cpu时间执行。当被yield的线程开始执行时，它会重新获得一个全新的quantum。

在java6， thread.yield 用了windows的switchtothread，这个方法可以让该线程放弃现在的时间片，等到再执行时，线程可以从那个被打断的时间开始继续执行，而不是获得一个完整的quantum。