1、继承Thread类创建线程类
public class FirstThreadTest extends Thread {
public void run(){
System.out.println("这里是线程的执行方法");
}
public static void main(String[] args) {
//获得线程
FirstThreadTest thread = new FirstThreadTest();
System.out.println("线程名称为："+thread.getName());
//启动线程
thread.start();
System.out.println("main方法也是一个线程："+Thread.currentThread().getName());
}
}执行结果：
线程名称为：Thread-0
main方法也是一个线程：main
这里是线程的执行方法2、通过Runnable接口创建线程类
（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体；
（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象；
（3）调用线程对象的start()方法来启动该线程。
public class RunnableThreadTest implements Runnable {
public void run() {
System.out.println("这里是线程方法");
System.out.println("线程名为：" + Thread.currentThread().getName());
}
public static void main(String[] args) {
System.out.println("main方法线程：" + Thread.currentThread().getName());
RunnableThreadTest rtt = new RunnableThreadTest();
new Thread(rtt, "新线程1").start();
new Thread(rtt, "新线程2").start();
}
}执行结果
main方法线程：main
这里是线程方法
线程名为：新线程1
这里是线程方法
线程名为：新线程2两种线程创建的具体区别：http://www.cnblogs.com/whgw/archive/2011/10/03/2198506.html（扩展性和资源共享性）
多线程并发
多线程并发出现问题主要涉及到两个方面：多线程共享数据同步问题和数据因并发产生不一致问题；
1、多线程共享数据同步问题
如下代码：
/**
* 两个工人一起搬砖
*/
public class Banzhuan {
public static void main(String[] args) {
// 一个工厂
Factory factory = new Factory();
/**
* p1线程和p2线程都是由factory这个实例创建的
* 那么p1调用外部类的getZhuanTou()方法就相当于调用的是factory这个实例的getZhuanTou(),同样的，p2调用的也是factory这个实例的getZhuanTou().
* 那么这里就出现了两个线程同时访问factory的getZhuanTou()方法。
* 而factory的getZhuanTou()方法又对zhuanTou这个属性进行了zhuanTou--操作。
* 换句话说，两个线程同时访问了factory的数据zhuanTou.这时候就可能产生线程安全问题。
*/
// 同一个工厂的两个工人
Person p1 = factory.getPerson();
Person p2 = factory.getPerson();
p1.start();
p2.start();
}
}
// 工厂
class Factory {
int zhuanTou = 20;// 一共20块砖头
public int getZhuanTou() {
if (zhuanTou == 0) {
throw new RuntimeException(Thread.currentThread().getName()+ ",没有砖头搬了!");
}
Thread.yield();
return zhuanTou--;
}
// 工人
class Person extends Thread {
// 不停的搬砖
public void run() {
while (true) {
// 获取线程名（工人名） 及 剩下砖头数
System.out.println(getName() + "搬了第" + getZhuanTou() + "块砖头");
// 当线程的run方法中出现了异常，且我们没有 解决，那么该线程终止并死亡。但不会影响 当前进程中的其他线程。
Thread.yield();
}
}
}
// 获取工人
public Person getPerson() {
return new Person();
}
}多次运行结果：
这里并不是每次都会出错，要多运行几次，就会可能碰到多种错误，比如搬到了同一块砖，比如少搬一块砖，比如搬完到了0然后还有继续搬……
原因是：比如现在还剩15块砖头，工人p1搬第15块砖头的时候正拿到手上，但是还没有登记减少一块砖头（即还没有运行zhuanTou–），这个时候工人p2也去拿砖，然后登记的时候一看还剩15块砖头，实际呢只剩14块了……
解决方法：
synchronized：当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。
所以将getZhuanTou（）方法改成如下就可以了
public int getZhuanTou() {
synchronized (this) {
if (zhuanTou == 0) {
throw new RuntimeException(Thread.currentThread().getName()+",没有砖头搬了!");
}
Thread.yield();
return zhuanTou--;
}
}为啥不将这个关键词锁在方法那呢？尽量将锁在范围最小的地方，这样运行的效率更快。
2、数据因并发产生不一致问题
参考：https://my.oschina.net/clopopo/blog/149368
ThreadLocal：为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象。
首先，ThreadLocal 不是用来解决共享对象的多线程访问问题的，一般情况下，通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。各个线程中访问的是不同的对象；
另外，说ThreadLocal使得各线程能够保持各自独立的一个对象，并不是通过ThreadLocal.set()来实现的，而是通过每个线程中的new 对象的操作来创建的对象，每个线程创建一个，不是什么对象的拷贝或副本。
再次，注意每一个线程都保存一个对象的时候(非基本类型数据)应该是new一个新对象而不是引用一个对象，如下：
private static ThreadLocal<Index> local = new ThreadLocal<Index>() {
@Override
protected Index initialValue() {
return new Index(); //注意这里
}
};案例代码：
public class ThreadLocalTest {
//创建一个Integer型的线程本地变量
public static final ThreadLocal<Integer> local = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0;
}
};
public static void main(String[] args) throws InterruptedException {
Thread[] threads = new Thread[5];
for (int j = 0; j < 5; j++) {
threads[j] = new Thread(new Runnable() {
@Override
public void run() {
//获取当前线程的本地变量，然后累加5次
int num = local.get();
for (int i = 0; i < 5; i++) {
num++;
}
//重新设置累加后的本地变量
local.set(num);
System.out.println(Thread.currentThread().getName() + " : "+ local.get());
}
}, "Thread-" + j);
}
for (Thread thread : threads) {
thread.start();
}
}
}运行结果：
Thread-0 : 5
Thread-4 : 5
Thread-2 : 5
Thread-1 : 5
Thread-3 : 5
--------------------------------------------------------------------------------------------------3、总结：
ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别:
1、synchronized关键字主要解决多线程共享数据同步问题，ThreadLocal使用场合主要解决多线程中数据因并发产生不一致问题；
2、synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享；
synchronized和ThreadLocal比较：http://blog.csdn.net/huyongl1989/article/details/8088841
线程池
当有许多请求需要去处理的时候，如果只是单独的一个人去处理，可想而知那会让后面在排队的人等多久，这样就需要线程池，有请求过来了就到线程池里面取出一条线程去处理它，处理完成就把它收回到线程池里面，然而自己实现 一个功能强大的线程池也并非易事，在java1.5之后专门提供了线程池的类库。
Java通过Executors接口提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程；
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待；
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行；
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行；
下面简单看一下newFixedThreadPool这种线程池：
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.submit(new Runnable() {
public void run() {
try {
System.out.println(Thread.currentThread().getName()+"---->"+index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}运行：
pool-1-thread-1—->0
pool-1-thread-3—->2
pool-1-thread-2—->1
pool-1-thread-3—->3
pool-1-thread-2—->5
pool-1-thread-1—->4
pool-1-thread-3—->6
pool-1-thread-1—->8
pool-1-thread-2—->7
pool-1-thread-3—->9
因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
fixedThreadPool.submit(Runnable task)或者execute方法会调用线程的run方法；
线程池参考地址：http://blog.csdn.net/u012385190/article/details/52486393