基本概念
线程是一个程序内部的顺序控制流

Java的线程是通过java.lang.Thread类来实现的。main函数是一个主线程，用户可以通过创建Thread的实例来创建新的线程。每一个线程都必须实现run方法。通过Thread类的start方法来启动一个线程。

两种方式实现，一种是线程类实现Runnable接口；二种就是定义一个Thread的子类并重写其run方法。

public class TestThread1 {public static void main(String args[]) {Runner1 r = new Runner1();r.start();//r.run();//Thread t = new Thread(r);//t.start();for(int i=0; i<100; i++) {System.out.println("Main Thread:------" + i);}}
}//class Runner1 implements Runnable {class Runner1 extends Thread {public void run() {for(int i=0; i<100; i++) {  System.out.println("Runner1 :" + i);}}
}

以下是几个线程控制的基本方法

用stop或者其他方法直接切断线程是很暴力的是很不好的，这里介绍一种比较好的结束线程的办法。巧妙的用到一个flag。

public class TestThread4 {  public static void main(String args[]){Runner4 r = new Runner4();Thread t = new Thread(r);t.start();for(int i=0;i<100000;i++){if(i%10000==0 & i>0)System.out.println("in thread main i=" + i);}System.out.println("Thread main is over");r.shutDown();//t.stop();}
}class Runner4 implements Runnable {private boolean flag=true;public void run() {int i = 0;while (flag==true) {System.out.print(" " + i++);    }}public void shutDown() {flag = false;}
}

线程同步
线程同步这个问题很重要，会衍生很多锁的问题。也是两种方式上锁，一种是直接在方法上上锁，另一种就是锁对象。

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的线程");//}}
}

死锁
假如两个线程都需要两个资源才能完成，A线程把a资源锁定等待b资源，B线程把b资源锁定等待a资源。这样就会形成死锁，所以我们要把锁定义到最大化就是锁定整个对象，就是专业术语说锁的粒度要尽量大。

public class TT implements Runnable {int b = 100;public synchronized void m1() throws Exception{//Thread.sleep(2000);b = 1000;Thread.sleep(5000);System.out.println("b = " + b);}public void m2() throws Exception{Thread.sleep(2500);b = 2000;}public void run() {try {m1();} catch(Exception e) {e.printStackTrace();}}public static void main(String[] args) throws Exception {TT tt = new TT();Thread t = new Thread(tt);t.start();tt.m2();System.out.println(tt.b);}
}

这个程序段输出的结果是
2000
b = 2000
这段程序也是先进的m2。

package yanning;public class TT implements Runnable {int b = 100;public synchronized void m1() throws Exception{System.out.println(2);//Thread.sleep(2000);b = 1000;Thread.sleep(5000);System.out.println("b = " + b);}public synchronized void m2() throws Exception {System.out.println(1);Thread.sleep(2500);b = 2000;}public void run() {try {m1();} catch(Exception e) {e.printStackTrace();}}public static void main(String[] args) throws Exception {TT tt = new TT();Thread t = new Thread(tt);t.start();tt.m2();System.out.println(tt.b);}
}

这段代码输出的结果是
1
2000
2
b = 1000

package yanning;public class TT implements Runnable {int b = 100;public synchronized void m1() throws Exception{//System.out.println(2);//Thread.sleep(2000);b = 1000;Thread.sleep(5000);System.out.println("b = " + b);}public synchronized void m2() throws Exception {//System.out.println(1);Thread.sleep(2500);b = 2000;}public void run() {try {m1();} catch(Exception e) {e.printStackTrace();}}public static void main(String[] args) throws Exception {TT tt = new TT();Thread t = new Thread(tt);t.start();tt.m2();System.out.println(tt.b);}
}

这一段代码执行结果是
1000
b = 1000
锁是锁住了，但是tt那个线程执行的快一些，先进入了m2。

所以说线程同步是一个很复杂的问题，我们得仔细推敲。而且我个人觉得跟电脑的运行速度还是有关系的。其他线程可以自由访问没有加同步的任何方法，并且会产生数据不一致的现象。如果要保护好某一类的同步对象，必须要对该对象所有的方法考虑加不加同步，加了同步很有可能效率会变低，不加同步很有可能造成数据不一致的现象。

优先级
我的理解就是CPU优先让哪个线程执行嘛，比较单CPU其实是假的多线程，就是因为CPU运算速度比较快，所以就一个线程让你执行一下，就像是多线程在执行一样。

生产者与消费者问题【经典问题】

public class ProducerConsumer {public static void main(String[] args) {SyncStack ss = new SyncStack();Producer p = new Producer(ss);Consumer c = new Consumer(ss);new Thread(p).start();new Thread(c).start();}
}class WoTou {int id; WoTou(int id) {this.id = id;}public String toString() {return "WoTou : " + id;}
}class SyncStack {int index = 0;WoTou[] arrWT = new WoTou[6];public synchronized void push(WoTou wt) {while(index == arrWT.length) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}this.notifyAll();       arrWT[index] = wt;index ++;}public synchronized WoTou pop() {while(index == 0) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}this.notifyAll();index--;return arrWT[index];}
}class Producer implements Runnable {SyncStack ss = null;Producer(SyncStack ss) {this.ss = ss;}public void run() {for(int i=0; i<20; i++) {WoTou wt = new WoTou(i);ss.push(wt);
System.out.println("生产了：" + wt);try {Thread.sleep((int)(Math.random() * 200));} catch (InterruptedException e) {e.printStackTrace();}           }}
}class Consumer implements Runnable {SyncStack ss = null;Consumer(SyncStack ss) {this.ss = ss;}public void run() {for(int i=0; i<20; i++) {WoTou wt = ss.pop();
System.out.println("消费了: " + wt);try {Thread.sleep((int)(Math.random() * 1000));} catch (InterruptedException e) {e.printStackTrace();}           }}
}