1、创建多线程
1、继承Thread类，并重写run()方法
class MyThread extends Thread{
@Override
public void run() {
}
}
其中run()方法是线程的执行体，该线程想要完成的任务，都有在这里面定义
2、实现Runnable接口
Runnable runnable=new Runnable() {
@Override
public void run() {
}
};
//以runnable对象作为Thread对象的target
Thread thread=new Thread(runnable);
Thread对象负责执行其target的run()方法，即最终Runnable 对象的run()方法要作为线程的执行体
public class Thread implements Runnable {
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
@Override
public void run() {
if (target != null) {
target.run();
}
}
}
3、Callable、Future、FutureTask，可以实现在任务结束之后，返回结果
Callable提供了call()方法作为线程的执行体，call()方法有返回值，可以抛出异常。
public interface Callable<V> {
V call() throws Exception;
}
但是Callable不是Runnable接口的子接口，所以不能直接作为Thread对象的target。
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
//获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}
可以看出FutureTask最终继承了Runnable接口和Future接口。所以它即可以直接作为Thread对象的target使用，又可以作为Future得到Callable的返回值。如下可以看出，FutureTask实现了Runnable接口的run() 方法，并在run() 里调用了Callable的call()方法：所以，call()方法将作为线程的执行体。
public class FutureTask<V> implements RunnableFuture<V> {
...
public FutureTask(Callable<V> callable) {
...
this.callable = callable;
}
public void run() {
...
Callable<V> c = callable;
V result;
result = c.call();
set(result);
}
}
** 三种方式的优缺点？**
1、线程类实现Callable、Runnable接口，还可以继承其他类；如果已经继承Thread类，就不能再继承其他类了
2、使用Callable、Runnable接口，多个线程可以共享同一个target对象，非常适合多个线程，处理同一份资源的情况
3、使用Callable，有返回值
2、线程的生命周期
在线程的生命周期中，它要经过新建（ｎｅｗ）、就绪（ｒｕｎｎａｂｌｅ）、运行（ｒｕｎｎｉｎｇ）、阻塞（ｂｌｏｃｋ）、死亡（ｄｅａｄ）五种状态。
新建的线程调用start()方法，进入就绪状态，就绪状态下的线程获得了CPU，进入运行状态，此时开始执行run()方法。在发生如下情况时，线程将进入阻塞状态：
- 线程调用sleep()方法，主动放弃所占用的处理器资源
- 线程调用了一个阻塞式IO方法，在该方法返回之前，该线程将被阻塞
- 线程试图获得一个同步监听器，但该同步监听器正在被其他线程持有
- ．．．
当前线程被阻塞后，其他线程就可以获得执行的机会；被阻塞的线程会下合适的时候，进入就绪状态。
３、控制线程
１、join线程
当在一个线程调用其他线程的join()后，调用线程将被阻塞，直到其他线程（join线程）被执行完为止
Thread thread=new Thread("");
thread.join();
２、线程睡眠sleep
让当前线程暂停一段时间，并进入阻塞状态，可以调用Thread类的静态sleep()方法：在其sleep时间段内，该线程不会获得执行的机会
Thread.sleep(3000);
３、线程让步，yield
让当前线程暂停，但不会阻塞该线程，只是将该线程进入就绪状态：让系统的线程调度器重新调度一次。
只有优先级和当前线程相同，或者比当前线程高，处于就绪状态的线程才能获得执行机会。
Thread.yield();
sleep()方法拥有更好的移植性，通常不建议使用yield()方法控制并发线程的执行。
４、线程同步synchronized
Java关键字，是用来进行同步的。可以修饰代码块，或者方法。
／／ 多线程并发修改一个对象的时候，可能会引起问题。
１、同步代码块
线程在开始执行同步代码块之前，必须先获得对同步监视器（ｏｂｊ）的锁定。
synchronized (obj){
//同步代码块
}
同步监视器可以是一个对象，也可以是一个类T，如下
synchronized (T.class){
//同步代码块
}
任何时刻，只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完毕后，该线程会释放对同步监视器的锁定；
注意：
1、如果同步监视器是一个对象，当多个线程访问该对象的同步代码块时，有些线程会被阻塞，但是如果不同线程访问的是不同对象的同步代码，不会阻塞；
2、如果同步监视器是一个类，代表锁定的是一个类，当多个线程访问该类不同对象的的同步代码块时，有些线程依然会被阻塞。
２、同步方法
使用synchronized 来修饰某个方法，它的同步监视器默认是当前对象
public synchronized void ｘｘ(){}
注意： synchronized关键字也可以修饰静态方法，此时它的同步监视器是类，当多个线程访问该类不同对象的的同步代码块时，有些线程依然会被阻塞。
３、释放同步监视器
任何线程在进入同步代码块／同步方法之前。必须先获得对同步监视器的锁定，那么什么时候会释放对同步监视器的锁定呢？
- 执行结束
- 遇到了break、return
- 遇到了Error、Exception
- 当前线程在执行同步代码块／同步方法时，执行了同步监视器对象的ｗａｉｔ（）方法，则当前线程暂停，并释放同步监视器
注意：当前线程在执行同步代码块／同步方法时，调用了Thread.sleep()、Thread.yield()方法，当前线程不会释放同步监视器
同步是以降低程序的运行效率为代价的，因此应该尽量减少同步的内容。
- 不要对线程安全类的所有方法进行同步，只对那些会改变竞争（共享）资源的方法进行同步
- 通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。
４、volatile关键字
４、线程通信
５、线程池
参考：疯狂Java讲义
