Java的Thread机制可以类比进程，可让几个操作同时执行，详情googl：time sharing。
线程架构图：代表一个线程持有CPU资源，代码资源和数据资源
Java中想让某种操作具有线程能力有两种方式：
extends Thread和implements Runnable，重载run 方法，在里面实现想要的操作：
请看码：
public class TestThread {
public static void main(String[] args) {
new TestThread().testThreadRun();
}
/**
* extends Thread 方式
*/
class T1 extends Thread{
private String name;
public T1(String name) {
this.name = name;
}
@Override
public void run() {
for (int i =0; i<10; i++) {
System.out.println(this.name + " print " + i);
}
}
}
/**
* implements Runnable 方式
*/
class T2 implements Runnable {
private String name;
public T2(String name) {
this.name = name;
}
@Override
public void run() {
for (int i =0; i<10; i++) {
System.out.println(this.name + " print " + i);
}
}
}
public void testThreadRun() {
T1 t1 = new T1("Oham");
T2 t2 = new T2("Lulu");
// 继承Thread的直接调用start， 线程进入Runnable状态
t1.start();
// 实现Runnable的对象需要作为new出的Thread对象的构造，由Thread对象start， 线程进入Runnable状态
new Thread(t2).start();
}
调用start后线程状态如下：
调用start后线程并不是立刻进入Running状态，而是可执行状态，等待CPU的调度，当得到CPU分配的时间片线程才能进入Running状态，这个过程是系统自身的过程，我们无法干涉（控制CPU分配时间片到某个线程）。
进入Running状态后线程执行run中的操作，当run执行完毕后线程进入死亡状态，无法再回到其他状态了，线程在非死亡状态时只能调用一次start方法。
-------------------------------------------------------------------------------------------------------------------------------------
暂停线程执行
1.sleep方法
正如其名，就是让Thread对象睡睡觉，此方法需要传入一个时长参数，单位为毫秒，表示过一段时间再恢复可执行状态，注意是可执行状态（Runnable），若指定时长为1秒，是指暂停时长为1秒，暂停完毕后进入可执行状态，等待CPU的调度，所以到执行状态（Running）其实已经超过一秒。
class TestSleep implements Runnable {
@Override
public void run() {
while (true) {
try {
System.out.print("**");
//调用sleep方法将使Thread进入“暂停”（blocked）状态
Thread.sleep(3000);
System.out.println("暂停3秒");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
2.yield方法，让某一执行当中的线程交出CPU时间片，进入可执行状态，不过可能又立刻被分配到CPU时间片。。。
修改前面的T1run方法：
class T1 extends Thread{
private String name;
public T1(String name) {
this.name = name;
}
@Override
public void run() {
for (int i =0; i<10; i++) {
System.out.println(this.name + " print " + i);
//让出当前执行线程的时间片，进入Runnable状态
Thread.yield();
}
}
}
试重新运行结果。。。不好评价。。。，可以把for的循环设置为10000试试，效果更佳。
3.join 有甲乙两个线程，要求甲线程必须等待乙线程执行玩后才能执行，这时我们用到join。
借书上一个例子：时间不早妈妈开始煮饭，于是进厨房开始准备，去发现米酒用完了，所以叫儿子去巷口士多买瓶米酒回来，等到买回来了妈妈才又开始煮饭，直至饭煮好。
这里的例子用到两个线程，mother和son，中间儿子去买酒，mother线程必须等待son线程执行完毕后才往下执行，这里就用到join，从方法字面理解，join——参与，也就是说son线程参与到mother线程当中，相当于把son线程的run操作放到mother线程的run操作中去，合并为一个线程操作（是相当于，其实里头还是两个线程，只是效果如是而已）。
package test;
public class MotherThread implements Runnable {
class SonThread implements Runnable {
@Override
public void run() {
System.out.println("儿子出门买米酒");
System.out.println("儿子出门需要5分钟");
try {
for(int i=1; i<=5; i++) {
Thread.sleep(1000);
System.out.print(i + "分钟 ");
}
} catch (InterruptedException e) {
System.err.println("儿子粗大事了");
}
System.out.println("\n儿子买酒回来了");
}
}
@Override
public void run() {
System.out.println("妈妈准备煮饭");
System.out.println("妈妈发现米酒用完");
System.out.println("妈妈叫儿子去买米酒");
Thread son = new Thread(new SonThread());
son.start();
System.out.println("妈妈等待儿子把米酒买回来");
try {
//son线程调用join是mother线程挂起进入Blocked状态，等待son线程执行run操作完毕
son.join();
} catch (InterruptedException e) {
System.err.println("发生异常");
System.err.println("妈妈中断煮饭");
System.exit(1);
}
System.out.println("妈妈开始煮饭");
System.out.println("饭煮好了");
}
public static void main(String[] args) {
new Thread(new MotherThread()).start();
}
}
状态图：
------------------------------------------------------------------------------------------------------------------------------------
同步处理
不同的线程之间，线程支配的资源：CPU资源，代码资源和数据资源，除了CPU外其他的都可以共用，代码是写好的，共用没问题，但数据共用就有问题了，因为不同的线程获得CPU时间片不可预计，当其中涉及到对数据操作时，对单个线程而言其数据已经造成混乱。
首先给共享代码，但没有共享数据的两个线程：
package test;
public class TestShare {
class ShareData implements Runnable {
int i;
@Override
public void run() {
while(i < 10) {
i++;
for(int j=0;j<10000000; j++);
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
public void goTest() {
//共享代码，没有共享数据
ShareData s1 = new ShareData();
ShareData s2 = new ShareData();
Thread t1 = new Thread(s1);
Thread t2 = new Thread(s2);
t1.setName("Oham");
t2.setName("Lulu");
t1.start();
t2.start();
}
public static void main(String[] args) {
new TestShare().goTest();
}
}
运行结果是对于单个线程而言依次打印出i 1至10。若将goTest改为:
public void goTest() {
//共享代码，共享数据
ShareData s = new ShareData();
Thread t1 = new Thread(s);
Thread t2 = new Thread(s);
t1.setName("Oham");
t2.setName("Lulu");
t1.start();
t2.start();
}
结果是对整个结果而言，i没有依次输出1至10。原因是两个线程争夺CPU时间片的结果把i在打印出之前或之时就已i++。就是因竞争CPU时间片说代码段被分割执行了。
为了防止多线程情形下代码被分割执行，这里需要锁机制——synchronized：
语法：
sychronized(要取得锁的对象)——问谁取得锁
｛要锁定保护的代码｝
修改上述run方法：
public void run() {
while(i < 10) {
//未取得锁的线程进入锁定池等待
synchronized (this) {
i++;
for(int j=0;j<10000000; j++);
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
从结果可以看出对于整体结果而言，i是依次输出1至10了，只是两个线程交互执行。
一点细节：受synchronized保护的代码段中，要访问的对象应该设置为private，否则可以通过其他的方式访问该对象了，这样synchronized好像失去了实质意义。
状态图：
如果一个线程要执行某段锁定的程序代码，但它没有取得指定的锁，那么该线程就会从执行状态进入锁定池中等待，当获取到锁后，它会转移到可执行状态（Runnable）。
Java的锁定机制若是滥用，很可能会造成系统进入死锁状态，如下图情况是死锁的一种：
预防死锁状态，Java有种Monitor Model的机制，除了预防死锁，还保证共用数据的一致状态。
看一个经典的生产者与消费者问题：
生产者生产东西，不可能无节制地生产下去，因为库存量的限制，所以未到达一定的库存量时，生产者会继续生产；当达到生产量时库存量时，生产者就等待消费者用掉库存，而消费者看到有库存的时候才会进行消费；如果库存量没有了，消费者就等待生产者生产出东西来。
Storage.java
package test;
public class Storage {
private int count; //记录库存量
private int size; //库存量上限
public Storage(int s) {
size = s;
}
/**
*供生产者调用，生产被执行时累加库存量
*/
public synchronized void addData(String producer) {
//检查库存量是否达到上限，如果是则此对象调用wait方法，
//持有该对象锁的Running状态的线程就进入等待状态（Wait pool）
while(count == size) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//通知其他正在等待的消费者，在wait pool中挑选任一线程，使其进入Lock Pool当中
this.notify();
count++;
System.out.println(producer + " make data count: " + count);
}
public synchronized void delData(String producer) {
//与addData相对，检查库存量是否为零，如果是则
//持有该对象锁的Running状态的线程就进入等待状态，
//顺便一提，此处用while是因为调用notify唤醒wait pool中的线程
//时是任意挑选的，且或是生产者，或是消费者被调醒，醒后又
//不会立刻执行。有可能别的线程先执行了，所以有必要再检查一次。
//（某一线程被wait，它的执行流程停在wait方法处，当被唤醒重新进入
//Running状态时，执行流程从wait调用之后开始，而不是重新来过一遍）
while(count == 0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
count--;
System.out.println(producer + " use data count: " + count);
}
}
Producer.java
package test;
public class Producer extends Thread {
private String name;
private Storage storage;
public Producer(String name, Storage storage) {
this.name = name;
this.storage = storage;
}
@Override
public void run() {
while(true) {
storage.addData(name);
try {
Thread.sleep((int)Math.random()*3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
Consumer.java
package test;
public class Consumer extends Thread {
private String name;
private Storage storage;
public Consumer(String name, Storage storage) {
this.name = name;
this.storage = storage;
}
@Override
public void run() {
while(true) {
storage.delData(name);
try {
Thread.sleep((int)Math.random()*3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
执行测试代码：
Storage storage = new Storage(5);
Producer p1 = new Producer("Oham", storage);
Producer p2 = new Producer("Lulu", storage);
Consumer c = new Consumer("Cancan", storage);
p1.start();
p2.start();
c.start();
注意：wait与notify必须在sychronized的代码块内调用，否则运行时抛java.lang.IllegalMonitorStateException。
wait是使得持有特定锁A的当前Running的线程进入wait pool，而notify是针对该特定锁A去notify，若是针对另外的锁B去notify，那么将不会去唤醒针对特定锁A的在wait pool当中的线程，而是唤醒另外的锁B对应的wait pool。
wait 与 notify 要用于相对而言的业务逻辑当中才能发挥Monitor Model的机制的作用，即一方wait的条件成立，另一方的notify条件必须成立，一方notify条件成立，另一方wait条件同时成立。如此才能预防死锁状态和保证共用数据的一致状态。
状态图：
