多线程

java中关于多线程的类：java.lang.Thread
方法：

public static void yield()
暂停当前正在执行的线程对象，并执行其他线程。

public final void join()
                throws InterruptedException
等待该线程终止。
抛出：
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。

public void interrupt()
中断线程。
如果当前线程没有中断它自己（这在任何情况下都是允许的），则该线程的 checkAccess 方法就会被调用，这可能抛出 SecurityException。

如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。

如果该线程在可中断的通道上的 I/O 操作中受阻，则该通道将被关闭，该线程的中断状态将被设置并且该线程将收到一个 ClosedByInterruptException。

如果该线程在一个 Selector 中受阻，则该线程的中断状态将被设置，它将立即从选择操作返回，并可能带有一个非零值，就好像调用了选择器的 wakeup 方法一样。

如果以前的条件都没有保存，则该线程的中断状态将被设置。

中断一个不处于活动状态的线程不需要任何作用。

抛出：
SecurityException - 如果当前线程无法修改该线程

public static void sleep(long millis,
                         int nanos)
                  throws InterruptedException
在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。
参数：
millis - 以毫秒为单位的休眠时间。
nanos - 要休眠的另外 0-999999 纳秒。
抛出：
IllegalArgumentException - 如果 millis 值为负或 nanos 值不在 0-999999 范围内。
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。
另请参见：
Object.notify()

public static boolean interrupted()
测试当前线程是否已经中断。线程的中断状态 由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。
线程中断被忽略，因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。

返回：
如果当前线程已经中断，则返回 true；否则返回 false。

public boolean isInterrupted()
测试线程是否已经中断。线程的中断状态 不受该方法的影响。
线程中断被忽略，因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。

返回：
如果该线程已经中断，则返回 true；否则返回 false。

---

锁

Lock lock = new ReentrantLock();
lock.lock();
try {
    <<使用共享资源>>
} finally {
    lock.unlock();
}

条件变量

ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();

lock.lock();
try {
    while (!<<条件为真>>)
        condition.await();
    <<使用共享资源>>
} finally {
    lock.unlock();
}

缓冲区的例子：

class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length) 
         notFull.await();
       items[putptr] = x; 
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0) 
         notEmpty.await();
       Object x = items[takeptr]; 
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   } 
 }

哲学家就餐：

package concurrent;

import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Philosopher extends Thread {

    private Philosopher left, right;
    private ReentrantLock table;
    private boolean eating;
    private Condition condition;
    private Random random;

    public Philosopher(ReentrantLock table) {
        this.table = table;
        eating = false;
        random = new Random();
        condition = table.newCondition();
    }

    public void setLeft(Philosopher left) {
        this.left = left;
    }

    public void setRight(Philosopher right) {
        this.right = right;
    }

    public void run() {
        try {
            while (true) {
                think();
                eat();
            }
        } catch (InterruptedException e) {
        }
    }

    public void eat() throws InterruptedException {
        table.lock();
        try {
            while (left.eating || right.eating) {
                condition.await();
            }
            eating = true;
        } finally {
            table.unlock();
        }
        Thread.sleep(random.nextInt(1000));
    }

    public void think() throws InterruptedException {
        table.lock();
        try {
            eating = false;
            left.condition.signal();
            right.condition.signal();
        } finally {
            table.unlock();
        }
        Thread.sleep(random.nextInt(1000));
    }
}