线程是进程中辛勤劳作者，所以用好多线程就显得十分必要
创建线程
-
重写run方法，创建Thread对象start起来
new Thread(){ @Override public void run() { super.run(); System.out.println("Thread run"); }; }.start(); -
用Thread的构造器Thread(Runnable target)创建出一个Thread对象，start起来。
new Thread(new Runnable() { @Override public void run() { System.out.println("Runnable run"); }; }).start();
那么，问题来了，如果有一哥们，既要重写Thread类中的run方法，又要用构造器Thread(Runnable target)来创建Thread对象会发生什么事呢？
new Thread(new Runnable() { @Override public void run() { System.out.println("Runnable run"); } }){ @Override public void run() { super.run(); System.out.println("Thread run"); } }.start();
不用多说看，运行结果
Runnable run Thread run
两个都会执行哦，为什么呢？答案就在super.run()
@Override public void run() { if (target != null) { target.run(); } }
target是什么？，target就是Thread(Runnable target)传进来的Runnable，也就是说，如果重写了Thread的run方法，在run方法中有调用super.run()则会先执行Runnable中的run方法，再执行重写run的super.run()之下的方法
线程的状态
接下来我们分别来看看线程在运行的时候不同状态的切换
临时阻塞
- 线程一旦启动run方法就会加入CPU执行队列中，进入等待CPU执行的状态.这个时候如果CPU没有执行该线程而去执行其他任务，则该线程进入了临时阻塞状态，如果CPU的执行权切换到该线程，则继续执行run方法。
- 还可以在得到执行权的时候调用
Thread.yeild()语句，释放执行权。
冻结
- Thread#sleep()方法：这个方法会使线程冻结，如果执行到的代码块具有原子性，冻结的时候不会释放锁。sleep时间到，则线程回到运行状态。
- Thread#suspend()方法和Thread#resume()方法：当线程调用
suspend方法时，与sleep一样，但需要用resume来唤醒线程，目前该方法已弃用。容易造成死锁，下面会介绍。 - Object#waite()方法和Object#notify()方法：这两个方法时
Object的方法,我们知道，代码块如果具备原子性，需要用一个锁对象，而这个锁对象可以是任意对象。所以线程在执行具有原子性的代码块时，可以调用Object类的wait()方法,来释放该线程所持有的锁，并且使线程冻结。如果需要唤醒线程，则需要让其他线程执行原子性代码块时，调用锁对象的notify()或者nofityAll()方法：notify表示随机唤醒冻结线程池里面的任一线程，notifyAll表示唤醒冻结线程池中的所有线程。利用锁对象的这两个特性，可以用来设计多线程的同步机制，下面会介绍。需要注意的是，如果Object的这几个方法不是作为锁对象的时候调用就会java.lang.IllegalMonitorStateException。
消亡
-
run()方法结束，自然而然线程也就等待被回收了。可以使用volatile修饰的标记位。 - 使用
stop()。确实能退出，但是不安全，官方已弃用。例如，当线程执行一段具有原子性的代码，执行到一半的情况下退出，是可以释放锁，但是造成了原子性的代码没执行部分。stop的线程会抛error:java.lang.ThreadDeath,可用try run方法中的代码块来catch Throwable. - 使用
interrupt()方法，可分为两种情况- 线程处于冻结状态，例如使用了
Thread.sleep()方法,如果sleep时间还没到，这个时候调用Thread#interrupt()则会抛InterruptedException，然后继续执行run方法直到退出。 - run方法中使用
while(true), 则这个标志位用isInterrupted()方法来得到。这个时候调用Thread#interrupt()，Thread#isInterrupted()返回false，run方法结束
- 线程处于冻结状态，例如使用了
死锁
范例
public class DeadLock {
private static Object lock1 = new Object();
private static Object lock2 = new Object();
public static void main(String[] args) {
new MyThread1().start();
new MyThread2().start();
}
private static class MyThread1 extends Thread {
private String nameString = "MyThread1 ";
@Override
public void run() {
while (true)
synchronized (lock1) {//1
System.out.println(nameString + "get loack1");
synchronized (lock2) {//2
System.out.println(nameString + "get loack2");
System.out.println(nameString + "release loack2");
}
System.out.println(nameString + "release loack1");
}
}
}
private static class MyThread2 extends Thread {
private String nameString = "MyThread2 ";
@Override
public void run() {
while (true)
synchronized (lock2) {//3
System.out.println(nameString + "get loack2");
synchronized (lock1) {//4
System.out.println(nameString + "get loack1");
System.out.println(nameString + "release loack1");
}
System.out.println(nameString + "release loack2");
}
}
}
}
运行结果：
MyThread1 get loack1
MyThread1 get loack2
MyThread1 release loack2
MyThread1 release loack1
MyThread1 get loack1
MyThread2 get loack2
上面的打印怎么来的呢？首先MyThread1启动,进入while(true)代码块，拿着lock1进入代码块1，接着又拿着lock2进入代码块2，代码块2执行完之后释放lock2，代码块1也执行完了，释放lock1，这时候两个锁lock1,lock2都没有被任一线程持有，这个时候MyThread2启动了，MyThread2也进入了while(true)代码块，到这一步，两个线程同时死循环执行while(true)里面的代码，那么，就存在，MyThread1持有lock1进入代码块1，MyThread2持有lock2进入代码块3，由于MyThread1要进入代码块2，需要持有lock2，但是lock2已经被MyThread2持有，所以MyThread1阻塞，等待lock2被释放，而MyThread2要进入代码块4，需要持有lock1，但lock1被阻塞的MyThread1持有，由于没有锁lock1，所以MyThread2也阻塞了，两个线程都因等待而阻塞，就算等待天荒地老，需要的锁也不会到来，造成两个线程都无法继续运行下去，这就是死锁。
死锁的必要条件
- 互斥条件：一个资源每次只能被一个进程使用。
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
- 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系
ps:出自《操作系统》
这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。
线程间的同步
主要就是用线程运行状态与线程冻结两个状态的切换来控制线程间的同步，我们来做一道面试题：请用线程A，B，C三个线程来依次打印上午，中午，下午，各打印10次。这道题的解法就是线程间的同步机制。
public class ThreadDemo {
/**
* 控制哪个线程执行
*/
private static int which = 0;
public static void main(String[] args) {
//分别创建三个线程
MyThread[] threads = new MyThread[] { new MyThread("A", "早上"),
new MyThread("B", "中午"), new MyThread("C", "晚上") };
for (int i = 0; i < threads.length; i++) {
//设置线程的编号
threads[i].setIndex(i);
//启动线程
threads[i].start();
}
}
private static class MyThread extends Thread {
/**
* 线程名字
*/
private String tName;
/**
* 需要打印的内容
*/
private String mPString;
/**
* 线程编号
*/
private int idx;
public MyThread(String name, String string) {
this.tName = name;
this.mPString = string;
}
public void setIndex(int i) {
this.idx = i;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (MyThread.class) {
while (this.idx != which) {//如果到了我的编号，跳出while执行打印
try {
//如果不到我的编号，我就继续睡觉
MyThread.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(this.tName + ":" + this.mPString + ":"
+ (i + 1));
which = ++which % 3;//打印完毕，编号++
MyThread.class.notifyAll();//唤醒所有沉睡的线程
}
}
}
}
}
打印结果符合预期，开启三个线程，瞬间走到了for循环内，这个时候三个线程要抢夺MyThread.class这个锁，假如线程线程2抢到了，进到while中去发现，咦，which=0,我不是0，我把锁扔了睡觉去了。这时候线程3有可能抢到锁，但结果跟线程2一样，只有线程1抢到锁才会跳出while去执行打印，打印完毕，++which，然后唤醒所有沉睡的线程，这个时候，唤醒所有沉睡的线程，线程1同步代码块走完，又到了三个线程抢锁的过程，只有序号对的线程才可以执行打印，所以就可以实现在指定情况下指定线程做指定任务，这就是线程的同步机制，从这里看以看出可以用锁对象的notify，notifyAll，wait来进行线程间的通信。
还可以用JDK1.5提供的Lock来替代sychronized代码块，用Condition的await(冻结，释放锁)，signal(唤醒)方法来替代Object#wait和Object#notify，效率更高，这边就不介绍了。
如果仅仅针对这道题，还有更简便的做法，修改MyThread#run里面内容如下：
for (int i = 0; i < 10; i++) {
while (this.idx != which) {
Thread.yield();//如果我不该执行就放弃执行权
}
System.out.println(this.tName + ":" + this.mPString + ":"
+ (i + 1));
which = ++which % 3;
}
输出的内容一样.
