java中的多线程+手写死锁+线程池

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 根筷子。他们围坐在桌子的周围，每人之间放一根筷子。当一个哲学家要就餐的时候，这个哲学家必须同时得到左边和右边的筷子。如果一个哲学家左边或者右边已经得到筷子，那么这个哲学家就必须等待，直至可得到必须的筷子。

public class Chopstick {
    //筷子的默认属性 没有被使用
    private boolean taken = false;
    //同步方法 使用筷子
    public synchronized void take() throws InterruptedException {
        while (taken){
            wait();
        }
        taken = true;
    }
    public synchronized void drop(){
        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() 结束使用。
 */
public class Philosopher implements Runnable {
    private Chopstick left;
    private Chopstick right;
    //哲学家的编号
    private final int id;
    //哲学家沉思的时间间隔单元
    private final int ponderFactor;
    private Random random = new Random(47);

    /**
     * 构造方法
     */
    protected Philosopher(Chopstick left, Chopstick right, int id, int ponderFactor) {
        super();
        this.left = left;
        this.right = right;
        this.id = id;
        this.ponderFactor = ponderFactor;
    }

    /**
     * 沉思或就餐
     */
    public void pause() throws InterruptedException {
        if (ponderFactor == 0) return;
        TimeUnit.MICROSECONDS.sleep(random.nextInt(ponderFactor * 200));
    }

    @Override
    public void run() {
        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();
        }
    }

    @Override
    public String toString() {
        return "Philosopher{" +
                "id=" + id +
                '}';
    }
}

在哲学家的任务中，每个哲学家都是不断的思考和吃饭。如果 ponderFactor 不为 0，则 pause() 就会休眠一会。通过这样的方法你会看到哲学家会思考一段时间。然后尝试着去获取左边和右边的筷子，随后再在吃饭上花掉一段随机的时间，之后重复此过程。
由此，建立死锁。

public class DeadLock {
    public static void main(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.必须有循环等待，这时一个任务等待其他任务所持有的资源，后者又在等待另一个任务所持有的资源，这样循环下去直到有一个任务等待第一个任务所持有的资源，使得大家都被锁住。
因为要发生死锁所有这些条件必须满足；所以要防止死锁的话只需要破坏其中一个就可以。在程序中防止死锁的最容易的办法就是破坏第四个循环条件。

修正死锁版本如下：

public class Fixed {
    public static void main(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方法实现的是没有返回值的并发编程。