1、Java使用Thread类代表线程。
所有的线程对象必须是Thread类或其子类的实例。
当线程继承Thread类时，直接使用this即可获取当前线程，Thread对象的getName()方法返回当前线程的名字，因此可以直接调用getName()方法返回当前线程的名字。
Thread.currentThread()：该方法总是返回当前正在执行的线程对象。
2、创建线程方式1：继承Thread类创建线程类
这种方式创建线程的步骤一般为：
1》定义Thread类的子类，并重写该类的run()方法，该方法作为线程的线程执行体。
2》创建Thread子类的实例，即线程对象。
3》调用线程对象的start()方法启动线程。
举个例子：
public class extendsThread extends Thread{
...
@Override
public void run(){
...
//do something
System.out.println(this.getName());
}
public static void main(String[] agrs){
//创建并启动第一个线程
new extendsThread().start();
//创建并启动第二个线程
new extendsThread().start();
}
}
3、创建线程方式2：实现Runnable接口
这种方式创建线程的步骤一般为：
1》定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2》创建Runnable接口实现类的实例，并将该实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。本质是Thread对象负责执行实现类对象的run()方法体。
3》调用线程对象的start()方法来启动该线程。
举个例子：
public class ImplRunnable implements Runnable{
...
@Override
public void run(){
...
//do something
System.out.println(Thread.currentThread().getName());
}
public static void main(String agrs){
...
System.out.println(Thread.currentThread().getName());
ImplRunnable target=new ImplRunnable();
//创建并启动第一个线程
new Thread(target,"Thread1").start();
//创建并启动第二个线程
new Thread(target,"Thread2").start();
}
}
4、使用Callable和Future创建线程：创建有返回值的线程
这种方式创建线程的步骤一般为：
1》创建Callable接口的实现类，并实现call()方法，该方法作为线程执行体，且该方法有返回值。然后创建该实现类的实例。
2》使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
3》使用FutureTask对象作为Thread对象的target创建并启动新线程。
4》调用FutureTask对象的get()方法获取子线程执行结束后的返回值。
举个例子：
public class ImplCallable implements Callable<Integer>{
...
@Override
public Integer call(){
...
//do something
System.out.println(Thread.currentThread().getName());
//return a value.
return 1;
}
public static void main(String[] agrs) throws InterruptedException, ExecutionException{
...
//创建并启动一个线程
FutureTask<Integer> target=new FutureTask<Integer>(new ImplCallable());
new Thread(target,"Thread3 with value.").start();
//获取返回值
System.out.println(target.get());
}
}
5、线程的生命周期
线程进入阻塞状态：
线程的死亡：
当主线程结束时，其他线程不受任何影响，并不会随之结束。一旦子线程启动起来之后，它就拥有和主线程相同的地位，它不会受主线程的影响。可以调用线程对象的isAlive()方法，当线程处于就绪、运行、阻塞三种状态时，该方法返回true；当线程处于新建、死亡两种状态时，该方法返回false。不要试图对一个已经死亡的线程调用start()方法使它重新启动，死亡的线程不能再次作为线程执行。
6、控制线程
1》join()：线程。Thread的静态方法。
A线程调用B线程的join()方法，A线程将被阻塞，直至B线程执行结束。join()方法有如下三种重载方式：
1>join()：等待被join的线程执行完毕。
2>join(long millis)：等待被join的线程的事时间最长为millis毫秒，如果millis毫秒被join的线程依然没有结束，则不再等待。
3>join(long millis，int nanos)：等待被join的线程的时间最长为millis毫秒加nanos毫秒。（一般计算机硬件、操作系统本身无法做到这么精确）。
2》setDaemon(true)：后台线程、守护线程、精灵线程
如果所有的前台线程都死亡了，后台线程也会自动死亡。调用Thread对象的setDaemon(true)方法可以将指定线程设置成后台线程。
Thread还提供了isDaemon()方法，用于判断指定线程是否为后台线程。
前台线程创建的子线程默认是前台线程，后台线程创建的子线程默认是后台线程。
3》sleep()：让线程睡眠。Thread的静态方法。
在指定的睡眠时间内，即使系统中没有其他线程可执行，处于sleep()中的线程也不会执行。sleep()方法通常用来暂停线程。
4》yield()：线程让步。Thread的静态方法。可以让线程暂停，但不会阻塞线程，线程会进入就绪状态，有可能立即又得到执行。当线程执行yield()方法后，优先级与之相等或者比它高的线程才会得到执行的机会。
比较：
5》改变线程的优先级
每个线程默认的优先级与创建它的父线程的优先级相同。默认情况下，main线程具有普通优先级。
Thread提供了setPriority(int newPriority)、getPriority()方法来设置和返回指定线程的优先级，其中setPriority(int newPriority)方法的参数可以是一个整数，范围1~10，值越大优先级越高。Thread也提供了三个静态常量设置的值：
7、线程同步：方式（1）synchronized的同步代码块、同步方法；方式（2）同步锁（Lock或ReadWriteLock接口的实现类）。
1》同步代码块：
//其中的obj就是同步监视器。
//线程在执行到下面的代码块的时候，必须先获得对同步监视器的锁定。
//任何时刻只能有一个线程可以获得同步监视器的锁定，同步代码块执
//行结束，同步监视器自动被释放锁定。
sychronized(obj){
...
}
2》同步方法：
使用sychronized修饰的某个方法（可能是实例方法，也可能是静态方法）。
1>修饰实例方法：无需显式指定同步监视器，同步方法的同步监视器就是this，即调用该方法的实例对象。
2>修饰静态方法：。。。
==》注意：sychronized可以修饰代码块、成员方法。但是不能修饰构造器、成员变量等。
==》为了减少线程安全问题带来的性能影响：
1>不要对线程安全类的所有方法都进行同步，只对那些会改变竞争资源的方法进行同步（可以参考哪些资源会被改变）。
2>如果可变类有两种环境：单线程、多线程环境。可以考虑对该类提供两个版本，在不同的环境中使用不同的版本。
（典型单线程、多线程线程安全版本：StringBuilder（非线程安全版本）是单线程环境下使用；StringBuffer（线程安全版本）在多线程环境下使用）
释放同步监视器的锁定，这个不能显式地控制，一般的时机为：
可大概总结为线程要从同步代码块、同步方法的代码块中退出（*或正常执行结束），这时候就会自动释放同步监视器。
3》同步锁（Lock）：
Lock对象充当同步对象。
1）Java 5提供了Lock、ReadWriteLock两个根接口，并为：
1>Lock==>ReetrantLock（可重入锁）实现类：
2>ReadWriteLock==>ReetrantReadWriteLock（可重入读写锁）实现类：提供了Writing、ReadingOptimistic、Reading三种锁模式。
可重入锁，指的是一个线程可以对已被加锁的ReetrantLock / ReetrantReadWriteLock对象再次加锁，ReetrantLock / ReetrantReadWriteLock对象会维持一个计数器来追踪lock()方法的嵌套调用。线程在每次调用lock()加锁后，必须显式调用unlock()来释放锁，所以一段被锁保护的代码可以调用另一个被相同锁保护的方法。
2）Java 8新增StampedLock类，在大多数场景中可以替代ReetrantReadWriteLock（可重入读写锁）。
常用的锁是ReetrantLock（可重入锁），其一般使用格式：
public class A{
//定义锁对象
private final ReentrantLock lock=new ReentrantLock();
...
public void method(){
//加锁对象
lock.lock();
try{
//需要保证线程同步的代码
...
}
finally{
//释放锁
lock.unlock();
}
}
}
总结：同步代码块、同步方法使用的是与资源竞争相关的、隐式的同步监视器，且强制要求加锁和锁释放要出现在一个块结构中，而且获得了多个锁时，它们必须以相反的顺序释放，且必须在与所有锁被获取时相同的范围内释放所有锁。
==》死锁：
两个线程相互等待对方释放同步监视器时就会发生死锁，简单的例子A等待B的筷子吃面然后才能空出盘子，但B在等待A的盘子盛面吃了才可以给A筷子，相互之间等待需要的资源，就形成了死锁。出现了死锁，所有线程处于阻塞态，无法继续。
8、线程通信
1》传统的线程通信
Object类提供了wait()、notify()、notifyAll()三个方法，这三个方法并不属于Thread类，而是属于Object类。且三个方法必须由同步监视器对象来调用，可分为两种情况：
关于上面的wait()、notify()、notifyAll()三个方法：
使用举例：
public class A{
...
public sychronized void getMoney(){
try{
if(!flag){
wait();
}
else{
...
flag=false;
notifyAll();
}
}
catch{
...
}
}
public sychronized void setMoney(){
try{
if(!flag){
wait();
}
else{
...
flag=true;
notifyAll();
}
}
catch{
...
}
}
}
2》使用Condition控制线程通信
这种情况针对不使用sychronized关键字来保证同步（即不是同步代码块或者同步方法的方式），而是使用Lock对象来保证同步，则系统中不存在隐式的同步监视器，也就不能使用上面的三个方法（wait()、notify()、notifyAll()）进行线程间通信了。
针对使用Lock对象保证同步的情况，Java提供了Condition类来保持协调。
使用Condition可以让那些已经得到Lock对象却无法继续执行的线程释放Lock对象，也可以唤醒其他处于等待的线程。
使用举例：
public class A{
//定义锁对象
private final Lock lock=new ReentrantLock();
//指定Lock对象的对应的Condition
private final Condition cond=lock.new Condition();
...
public void getMoney(){
//加锁
lock.lock();
try{
if(!flag){
cond.await();
}
else{
...
flag=false;
cond.signalAll();
}
}
catch{
...
}
finally{
//释放锁
lock.unlock();
}
}
public void setMoney(){
//加锁
lock.lock();
try{
if(!flag){
cond.await();
}
else{
...
flag=true;
cond.signalAll();
}
}
catch{
...
}
finally{
//释放锁
lock.unlock();
}
}
}
3》使用阻塞队列（BlockingQueue）控制线程通信
Java 5提供了一个BlockingQueue接口，Queue的子接口，主要用作线程同步工具。特征：当生产者试图往BlockingQueue放入元素时，如果队列已满，则线程被阻塞；如果消费者线程试图从BlockingQueue取元素时，如果队列已空，则线程被阻塞。
。。。详细使用参考相关的API。
9、线程组合未处理的异常