JAVA多线程

进程：程序一次动态执行的过程
线程：程序中的代码段
java实现多线程有两种方式，A、实现Runable接口；B、继承Thread类。对多CPU来说，线程可以提高系统性能，但是对多CPU而言，由于CPU需要在不同线程之间切换，所以并不一定可以提高性能（切换耗费大）。多线程最大的好处是实现并发。就好比做饭，单线程情况下是你先做米饭，然后在一旁等待米饭煮熟之后再炒菜，多线程就是你把米什么的搞好之后，就让它慢慢煮，同时自己炒菜。显然后者比前者节省更多的时间。
看了一下JDK，Thread类有几个方法比较重要，下面简单说明一下：
1、Thread.start()：将该线程放到线程队列，等待JVM执行该线程的run方法
2、Thread.yield()：线程调度器，可以通知CUP，让CUP执行其他线程
3、Thread.sleep(long millis)：让线程进入休眠状态
4、wait()：让线程进入等待状态
其中sleep和wait的区别在于，休眠之后，线程可以继续执行，而wait之后，必须通过notify或者notifyAll()来唤醒线程。
下面是个简单的生产者和消费者的例子：

package com.yf.multithreads;
/////

//这是个Thread例子。需要注意的是：
//wait() 必须在synchronized 函数或者代码块里面
//wait()会让已经获得synchronized 函数或者代码块控制权的Thread暂时休息，并且丧失控制权
//这个时候，由于该线程丧失控制权并且进入等待，其他线程就能取得控制权，并且在适当情况下调用notifyAll()来唤醒wait()的线程。
//需要注意的是，被唤醒的线程由于已经丧失了控制权，所以需要等待唤醒它的线程结束操作，从而才能重新获得控制权。
//
//所以wait()的确是马上让当前线程丧失控制权，其他的线程可以乘虚而入。
//
//所以wait()的使用，必须存在2个以上线程，而且必须在不同的条件下唤醒wait()中的线程。
//
//
//以下的例子：
//ProductStack 是一个生产者跟消费者共享的同步机制，这个机制决定了什么情况生产者要wait()，什么情况消费者要wait()
//可以把ProductStack看作一个产品仓库。当产品仓库满的时候，生产者线程需要wait()，从而放弃对产品仓库的控制。
//这个时候消费者线程就可以进来了而取得仓库的控制权。一旦消费者消费了产品，那么仓库就不满了。
//这个时候消费者线程就要notifyAll()生产者线程，让等待的生产者线程唤醒。
//但是生产者被唤醒后不能马上进行生产，因为它在wait()的时候已经丧失了对仓库的控制权，所以就需要等待消费者线程结束操作，
//才能重新取得仓库的控制权，再进行生产。
//
//所以特别注意的是，notifyAll()并不是让当前线程马上让出控制权，而只是让其他wait()当中的线程唤醒而已，
//所以对不起，尽管我唤醒你，可你必须还是要等我用完仓库才能进来。这点必须清楚。
//
//相反，仓库如果空的时候，消费者线程就会wait()，然后等待生产者线程来生产产品，生产者进程乘虚而入后，让生产者线程生产产品
//并且唤醒消费者线程。这个情况跟上面就类似了。
//
///
public class ProducerConsumer {
	public static void main(String[] args) {
        ProductStack ps = new ProductStack();
        Producer p = new Producer(ps, "生产者1");
        Consumer c = new Consumer(ps, "消费者1");
        new Thread(p).start();
        new Thread(c).start();
   }
}
class Product {
    int id;

    private String producedBy = "N/A";

    private String consumedBy = "N/A";

    // 构造函数，指明产品ID以及生产者名字。
    Product(int id, String producedBy) {
         this.id = id;
         this.producedBy = producedBy;
    }

    // 消费，需要指明消费者名字
    public void consume(String consumedBy) {
         this.consumedBy = consumedBy;
    }

    public String toString() {
         return "Product : " + id + ", produced by " + producedBy
                    + ", consumed by " + consumedBy;
    }

    public String getProducedBy() {
         return producedBy;
    }

    public void setProducedBy(String producedBy) {
         this.producedBy = producedBy;
    }

    public String getConsumedBy() {
         return consumedBy;
    }

    public void setConsumedBy(String consumedBy) {
         this.consumedBy = consumedBy;
    }

}

//这个class就是仓库，是生产者跟消费者共同争夺控制权的同步资源
class ProductStack {
    int index = 0;

    Product[] arrProduct = new Product[6];

    // push使用来让生产者放置产品的
    public synchronized void push(Product product) {
         // 如果仓库满了
         while (index == arrProduct.length) // 这里本来可以用if(),但是如果catch
                                          // exception会出问题，让满的index越界
         {
               try {
                    // here, "this" means the thread that is using "push"
                    // so in this case it's a producer thread instance.
                    // the BIG difference between sleep() and wait() is, once
                    // wait(),
                    // the thread won't have the lock anymore
                    // so when a producer wait() here, it will lost the lock of
                    // "push()"
                    // While sleep() is still keeping this lock
                    // Important: wait() and notify() should be in "synchronized"
                    // block

                    System.out.println(product.getProducedBy() + " is waiting.");
                    // 等待，并且从这里退出push()
                    wait();
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
         }
         System.out.println(product.getProducedBy() + " sent a notifyAll().");

         // 因为我们不确定有没有线程在wait()，所以我们既然生产了产品，就唤醒有可能等待的消费者，让他们醒来，准备消费
         notifyAll();
         // 注意，notifyAll()以后，并没有退出，而是继续执行直到完成。
         arrProduct[index] = product;
         index++;
         System.out.println(product.getProducedBy() + " 生产了: " + product);
    }

    // pop用来让消费者取出产品的
    public synchronized Product pop(String consumerName) {
         // 如果仓库空了
         while (index == 0) {
               try {
                    // here will be the consumer thread instance will be waiting ,
                    // because empty
                    System.out.println(consumerName + " is waiting.");
                    // 等待，并且从这里退出pop()
                    wait();
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
         }

         System.out.println(consumerName + " sent a notifyAll().");
         // 因为我们不确定有没有线程在wait()，所以我们既然消费了产品，就唤醒有可能等待的生产者，让他们醒来，准备生产
         notifyAll();
         // 注意，notifyAll()以后，并没有退出，而是继续执行直到完成。
         // 取出产品
         index--;
         Product product = arrProduct[index];
         product.consume(consumerName);
         System.out.println(product.getConsumedBy() + " 消费了: " + product);
         return product;
    }
}

class Producer implements Runnable {
    String name;

    ProductStack ps = null;

    Producer(ProductStack ps, String name) {
         this.ps = ps;
         this.name = name;
    }

    public void run() {
         for (int i = 0; i < 20; i++) {
               Product product = new Product(i, name);
               ps.push(product);
               try {
                    Thread.sleep((int) (Math.random() * 200));
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
         }
    }
}

class Consumer implements Runnable {
    String name;

    ProductStack ps = null;

    Consumer(ProductStack ps, String name) {
         this.ps = ps;
         this.name = name;
    }

    public void run() {
         for (int i = 0; i < 20; i++) {
               Product product = ps.pop(name);
               try {
                    Thread.sleep((int) (Math.random() * 1000));
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
         }
    }
}