介绍
线程是操作系统的最小单位，一个进程可以创建多个线程。
线程有五种状态，分别是新建、就绪、运行、阻塞、死亡状态。
多线程可以提高执行效率，但是如果单线程可以完成的任务，使用多线程反而会增加不必要的开销，降低效率。例如将某个数加一百次，使用多线程反而会比单线程耗费的时间多。
创建线程
java创建线程有两种方法
- 继承Thread，重写run函数,调用start方法
package com.thread;
public class ExtendTreadTest extends Thread {
int i = 0;
public void run()
{
for(;i<100;i++){
System.out.println(getName()+" "+i);
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
new ExtendTreadTest().start();
new ExtendTreadTest().start();
}
}
- 实现Runnable接口，重写run函数，调用start方法
package com.thread;
import static java.lang.Thread.sleep;
public class ImplementRunnable implements Runnable {
int i = 0;
public void run()
{
for(;i<100;i++){
System.out.println(Thread.currentThread().getName()+" "+i);
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Thread thread = new Thread(new ImplementRunnable(), "test1");
thread.start();
Thread thread1 = new Thread(new ImplementRunnable(), "test2");
thread1.start();
}
}
JAVA允许继承一个类，并实现多个接口，所以通常应用中实现Runnable比较好。
线程间通信
volatile和synchornized关键字
volatile
volatile 会确保线程在每一次使用变量之前都会从共享内存中读取变量的值，然后然后放入自己的工作内存进行处理，处理完成后将新的值立即同步到内存，在这个期间，可能会有其他的线程也对该变量进行处理。所以volatile并不是线程安全的。
package com.thread;
public class Test {
public volatile int inc = 0;
public void increase() {
inc++;
System.out.println(inc);
}
public static void main(String[] args) {
final Test test = new Test();
for(int i=0;i<10;i++){
new Thread(){
public void run() {
for(int j=0;j<10000;j++)
test.increase();
};
}.start();
}
while(Thread.activeCount()>1) //保证前面的线程都执行完
Thread.yield();
System.out.println(test.inc);
}
}
例如上面的方法，期望的实验结果是100000，但是实际情况偶尔会出现小于100000的情况。是因为volatile没法保证对变量操作的原子性，inc++不是一个原子操作，就会导致结果出现问题。
解决的办法有使用synchronized，锁，以及将变量变为原子操作AtomicInteger。
总体来说，如果能保证对变量的操作是原子性的，那么使用volatile会是一个较好的办法。
参考：http://www.cnblogs.com/dolphin0520/p/3920373.html
synchornized
确保多线程对临界资源的互斥性访问的一种方式是使用synchornized。
例如上面的例子：
public synchornized void increase() {
inc++;
System.out.println(inc);
}
或者
public void increase() {
synchornized {
inc++;
System.out.println(inc);
}
}
上面的两个都是对类的对象做同步，而不是对类本身进行同步。每个线程必须共用一个对象才能够达到同步效果。
public void increase() {
synchornized(Test.class) {
inc++;
System.out.println(inc);
}
}
上面是对类本身进行同步，对于Test类，它只有一个类定义，同时只有一个线程可以访问increase方法。
在JAVA中，任意的一个对象都有自己的监视器，当这个对象由同步块或者同步方法调用的时候，执行的线程必须获取该对象的监视器,然后再进入同步块（方法），否则就会进入一个阻塞队列，等待线程退出监视器。
wait和notify以及notifyAll
1.调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）
2.调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程
3.调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程
package com.thread;
import static java.lang.Thread.sleep;
public class WaitNotify {
static boolean flag = true;
static Object lock = new Object();
public static void main(String[] args) {
Thread waitThread = new Thread(new Wait(), "waitThread");
waitThread.start();
try {
sleep(100);
} catch (Exception err) {
err.printStackTrace();
}
Thread notifyThread = new Thread(new Notify(), "notifyThread");
notifyThread.start();
}
static class Wait implements Runnable {
public void run() {
synchronized (lock) {
while (flag) {
try {
System.out.println(Thread.currentThread().getName() + " wait");
lock.wait();
} catch (InterruptedException e) {
}
}
}
System.out.println(Thread.currentThread().getName() + " run");
}
}
static class Notify implements Runnable {
public void run() {
synchronized (lock) {
try {
System.out.println(Thread.currentThread().getName() + " hold lock");
sleep(1000);
lock.notify();
flag = false;
} catch (InterruptedException e) {
}
}
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " run");
}
}
}
图中，waitThread首先获取了对象的锁，然后调用对象的wait（）方法，从而放弃了锁并进入等待队列WaitQueue中。NotifyThread随后获取了对象的锁，并调用对象的notify方法，将WaitThread从WaitQueue转移到了synchornizedQueue中，然后waitThread转变为了阻塞状态。NotifyThread释放了锁之后，WaitThread再次获得了锁并从wait（）方法中返回并继续执行。
参考：JAVA并发编程的艺术