线程简介：
线程是一个程序内部的顺序控制流。
线程和进程的区别：
每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销。
线程可以看成是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器，线程切换的开销小。
多进程：
在操作系统中能同时运行的多个任务。
多线程：
在同一个应用程序中有多个顺序流同时执行。
Java的线程是通过java.lang.Thread类实现的；JVM启动时会有一个由主方法所定义的线程；可以通过创建Thread的实例来创建新的线程；每个线程都是通过某个特定的Thread对象所对应的run()方法来完成其操作的，run()方法称为线程体。
线程的创建与启动：
第一种：
1.定义线程类target实现Runnable接口（使用Runnable接口可以为多个线程提供共享数据），其中Runnable中只有一个方法public void run();
2.Thread my Thread = new Thread(target);
3.在实现Runnable接口的类的run()方法定义中可以使用Thread的静态方法（currectThread()方法用于获取当前线程的引用）。
第二种：
1.可以定义一个Thread的子类并重写其run()方法：class MyThread extends Thread{ public void run(){ } } ；
2.然后生成该类的对象。
线程状态的转换：
阻塞解除
<-----------------
调度 导致阻塞的事件
<---- ---->*阻塞状态
*创建 *就绪状态 *运行状态 *终止
----> ----> ---->
start 调度 运行结束
*标记为线程状态，箭头表示转换过程。
线程控制的基本方法：
isAlive() 判断线程是否还活着，即线程还未终止（上面的阻塞、就绪、运行三个状态）
getPriority() 获得线程的优先级
setPriority() 设置线程的优先级
Thread.sleep() 使当前线程进入休眠状态，并指定睡眠的毫秒数
join() 将当前线程与被调用该方法的线程合并，即等待该线程结束，在回复当前线程的运行
yield() 让出cpu，当前线程进入就绪队列等待调度
wait() 当前线程进入对象的wait pool
notify()/notifyAll() 唤醒对象的wait pool中的一个/所以等待线程
join的例子：
public class TestJoin {
public static void main(String[] args) {
MyThread2 t1 = new MyThread2("abcde");
t1.start();
try {
t1.join();
} catch (InterruptedException e) {}
for(int i=1;i<=10;i++){
System.out.println("i am main thread");
}
}
}
class MyThread2 extends Thread {
MyThread2(String s){
super(s);
}
public void run(){
for(int i =1;i<=10;i++){
System.out.println("i am "+getName());
try {
sleep(1000);
} catch (InterruptedException e) {
return;
}
}
}
}
只有执行完了t1的run()方法时才会继续执行main()方法。
Java的优先级别：
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照线程的优先级决定应调用哪个线程来执行；线程的优先级用数字来表示，范围从1到10，一个线程的缺省优先级是5。
Thread.MIN_PRIORITY = 1
Thread.MAX_PRIORITY = 10
Thread.NORM_PRIORITY = 5
线程同步：
在Java语言中，引入对象互斥锁的概念，保证共享数据操作的完整性；每个对象都对应于一个可以成为互斥锁的标记；这个标记保证在任意时刻，只有一个线程访问该对象；关键字synchronized用来与对象的互斥锁相联系；当某个对象的synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
synchronized的用法：
synchronized (this) {
}
synchronized还可以放在方法生声明中，表示整个方法为同步方法：
public synchronized void add(String name){
}
无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
public class TestSync implements Runnable {
Timer timer = new Timer();
public static void main(String[] args) {
TestSync test = new TestSync();
Thread t1 = new Thread(test);
Thread t2 = new Thread(test);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
public void run(){
timer.add(Thread.currentThread().getName());
}
}
class Timer{
private static int num = 0;
public synchronized void add(String name){
//synchronized (this) {
num ++;
try {Thread.sleep(1);}
catch (InterruptedException e) {}
System.out.println(name+", 你是第"+num+"个使用timer的线程");
//}
}
}
需要注意的是：
1.两个线程不可同时执行一个类中被声明了synchronized的方法；
2.当一个线程正在访问一个类的其中一个被声明为synchronized方法的方法的时候，其他线程可以访问该类中没有声明为synchronized的方法；
3.一个类中不可以同时有多个被声明为synchronized的方法被执行（一个对象只有一个互斥锁，需要等待另外一个线程释放互斥锁后才可以执行）。
Wait和sleep的区别：
Wait时，别的线程可以访问锁定的对象（调用wait的方法的时候必须锁定该对象）。
Sleep时，别的线程不可以访问锁定对象。
死锁的例子：
public class TestDeadLock implements Runnable {
public int flag = 1;
static Object o1 = new Object(), o2 = new Object();
public void run() {
System.out.println("flag=" + flag);
if(flag == 1) {
synchronized(o1) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
synchronized(o2) {
System.out.println("1");
}
}
}
if(flag == 0) {
synchronized(o2) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
synchronized(o1) {
System.out.println("0");
}
}
}
}
public static void main(String[] args) {
TestDeadLock td1 = new TestDeadLock();
TestDeadLock td2 = new TestDeadLock();
td1.flag = 1;
td2.flag = 0;
Thread t1 = new Thread(td1);
Thread t2 = new Thread(td2);
t1.start();
t2.start();
}
}