java线程的基本方法：Thread类，Runnable接口。
线程的创建方法：Thread();Thread(String name);Thread（Runnable target）;Thread(Runnable target,String name);
启动线程的方法：void start();
线程休眠的方法：static void sleep(long millis); static void sleep(long millis，int nanos);
使其他线程等待当线程终止：void join();//其他线程要等待当前线程完成后才有机会拿到cpu
void join(long mills);//其他线程等待的时间上限是mills
void join(long mills，int nanos);//时间精确到纳秒
当前运行线程释放处理器资源：static void yield():
获取线程引用or 返回当前运行的线程引用：static Thread currentThread();
死锁：多线程并发过程中，任务通过yield();sleep();wait()方法会进入阻塞状态。从而可能发生这样的情况：某个任务在等待另一个任务，而后者又在等待别的任务，这样一直下去，直到这个链条上的任务又在等待第一个任务释放锁。这就形成了一个相互等待的循环，没有那个线程能够继续。这被称之为死锁。
死锁模型：哲学家吃饭问题：一共有 5 个哲学家。这些哲学家将花部分时间思考，花部分时间就餐。因为他们很穷，所以只能买 5 根筷子。他们围坐在桌子的周围，每人之间放一根筷子。当一个哲学家要就餐的时候，这个哲学家必须同时得到左边和右边的筷子。如果一个哲学家左边或者右边已经得到筷子，那么这个哲学家就必须等待，直至可得到必须的筷子。
publicclassChopstick {//筷子的默认属性 没有被使用privateboolean taken =false;//同步方法 使用筷子publicsynchronizedvoidtake()throws InterruptedException {while (taken){
wait();
}
taken =true;
}publicsynchronizedvoiddrop(){
taken =false;/*
* notify表示唤醒一个线程，，notifyAll也表示唤醒一个线程，但它会notify所有的线程，具体唤醒哪一个线程，由jvm来决定
* notify和notifyall在主要的效果区别是notify用得不好容易导致死锁，
* */
notifyAll();
}
}import java.util.Random;import java.util.concurrent.TimeUnit;/**
* Created by dell on 2018/4/9.
* 任何两个哲学家都不能使用同一根筷子。也就是不能同时 taken() 同一个筷子。另外如果一个 Chopstick 被一个哲学家获得，
* 那么另一个哲学家可以 wait()，直到当前的这根筷子的持有者调用 drop() 结束使用。
*/publicclassPhilosopherimplementsRunnable {private Chopstick left;private Chopstick right;//哲学家的编号privatefinalint id;//哲学家沉思的时间间隔单元privatefinalint ponderFactor;private Random random =new Random(47);/**
* 构造方法
*/protectedPhilosopher(Chopstick left, Chopstick right,int id,int ponderFactor) {super();this.left = left;this.right = right;this.id = id;this.ponderFactor = ponderFactor;
}/**
* 沉思或就餐
*/publicvoidpause()throws InterruptedException {if (ponderFactor ==0)return;
TimeUnit.MICROSECONDS.sleep(random.nextInt(ponderFactor *200));
}@Overridepublicvoidrun() {try {while (!Thread.interrupted()) {
System.out.println(this +"沉思");
pause();
System.out.println(this +"开始拿左边的筷子");
left.take();
System.out.println(this +"开始拿右边的筷子");
right.take();
System.out.println(this +"开始就餐");
pause();
left.drop();
right.drop();
}
}catch (InterruptedException e) {
System.out.println("当前线程被中断了");
e.printStackTrace();
}
}@Overridepublic StringtoString() {return"Philosopher{" +"id=" + id +'}';
}
}在哲学家的任务中，每个哲学家都是不断的思考和吃饭。如果 ponderFactor 不为 0，则 pause() 就会休眠一会。通过这样的方法你会看到哲学家会思考一段时间。然后尝试着去获取左边和右边的筷子，随后再在吃饭上花掉一段随机的时间，之后重复此过程。
由此，建立死锁。
publicclass DeadLock {publicstaticvoidmain(String[] args){int ponder =5;int phiSize =5;
ExecutorService service = Executors.newCachedThreadPool();
Chopstick[] chopsticks =new Chopstick[phiSize];for (int i=0;i<phiSize;i++){
chopsticks[i] =new Chopstick();
}for (int i=0;i<phiSize;i++){//每个哲学家都会持有他左边和右边的筷子对象
service.execute(new Philosopher(chopsticks[i],chopsticks[ (i+1)%phiSize],i,ponder));
}
System.out.println("执行结束");
service.shutdown();
}
}执行结果
Philosopher{id=4}开始拿左边的筷子
Philosopher{id=3}沉思
Philosopher{id=4}开始拿右边的筷子
Philosopher{id=2}开始就餐
Philosopher{id=3}开始拿左边的筷子
Philosopher{id=2}沉思
Philosopher{id=1}开始就餐
Philosopher{id=3}开始拿右边的筷子
Philosopher{id=2}开始拿左边的筷子
Philosopher{id=1}沉思
Philosopher{id=2}开始拿右边的筷子
Philosopher{id=0}开始就餐
Philosopher{id=0}沉思
Philosopher{id=0}开始拿左边的筷子
Philosopher{id=1}开始拿左边的筷子
Philosopher{id=1}开始拿右边的筷子
Philosopher{id=0}开始拿右边的筷子这个程序表示每一个哲学家都有可能要表示进餐，从而等待其临近的 Philosopher 放下他们的 Chopstick。这将会使得程序死锁。
当以下四个条件同时满足时，就会发生死锁：
1.互斥条件。任务使用的资源中至少有一个是不能共享的。
2.至少有一个任务必须持有一个资源，并且正在等待获取一个当前被别的任务持有的资源。也就是说必须是拿着一根筷子等待另一个筷子。
3.资源不能被任务抢占，任务必须把资源释放当做普通事件。你不能抢别人手里的筷子。
4.必须有循环等待，这时一个任务等待其他任务所持有的资源，后者又在等待另一个任务所持有的资源，这样循环下去直到有一个任务等待第一个任务所持有的资源，使得大家都被锁住。
因为要发生死锁所有这些条件必须满足；所以要防止死锁的话只需要破坏其中一个就可以。在程序中防止死锁的最容易的办法就是破坏第四个循环条件。
修正死锁版本如下：
publicclass Fixed {publicstaticvoidmain(String[] args) {int ponder =5;int philSize =5;
ExecutorService service = Executors.newCachedThreadPool();
Chopstick[] chopsticks =new Chopstick[philSize];for (int i =0; i < philSize; i++) {
chopsticks[i] =new Chopstick();
}for (int i =0; i < philSize; i++) {if (i < philSize -1) {
service.execute(new Philosopher(chopsticks[i], chopsticks[(i +1) % philSize], i, ponder));
}else {
service.execute(new Philosopher(chopsticks[0], chopsticks[i], i, ponder));
}
}
System.out.println("执行结束");
service.shutdown();
}
}Java线程池ExecutorService
new Thread的弊端如下：
1. 每次new Thread新建对象性能差。
2. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
3. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
1. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
2. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
3. 提供定时执行、定期执行、单线程、并发数控制等功能。
Java通过Executors提供四种线程池
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
ExecutorService 的submit（） 与execute（）区别
接收的参数不一样 submit（）可以接受runnable和callable 有返回值，execute（）接受runnable 无返回值，、submit方便处理Exception。
shotdown（） showdownNow（）区别
这两个方法都可以用来关闭 ExecutorService。
shutdown() 方法在终止前允许执行以前提交的任务，
shutdownNow() 方法阻止等待任务启动并试图停止当前正在执行的任务。在终止时执行程序没有任务在执行，也没有任务在等待执行，并且无法提交新任务。关闭未使用的 ExecutorService 以允许回收其资源。
一般分两个阶段关闭 ExecutorService。第一阶段调用 shutdown 拒绝传入任务，然后调用 shutdownNow（如有必要）取消所有遗留的任务。
Runnable（）与Callable（）区别
callable用法和runnable一样，对应开启线程的是call方法，该方法有一个泛型返回值类型，可以任意指定返回值类型。
runnable接口的run方法实现的是没有返回值的并发编程。