Java编程思想目录（Bruce Eckel著）

第10章内部类

创建内部类
链接到外部类
使用.this和.new
内部类与向上转型
在方法和作用域内的内部类
匿名内
6.1 再访工厂方法
嵌套类
7.1 接口内部的类
7.2 从多层嵌套类中访问外部类的成员
为什么需要内部类
8.1 闭包与回调
8.2 内部类与控制框架
内部类的继承
内部类可以被覆盖吗
局部内部类
内部类标识符

内部类详解：https://www.cnblogs.com/dolphin0520/p/3811445.html

第15章泛型

与C++的比较
简单泛型
2.1 一个元组类库
2.2 一个堆栈类
2.3 RandomList
泛型接口
泛型方法
4.1 杠杆利用类型参数推断
4.2 可变参数与泛型方法
4.3 用于Generator的泛型方法
4.4 一个通用的Generator
4.5 简化元组的使用
4.6 一个Set实用工具
匿名内部类
构建复杂模型
擦除的神秘之处
擦除的补偿
边界
通配符

泛型类，泛型方法的使用实例
https://www.cnblogs.com/jpfss/p/9928747.html
边界通配符：extends和super
https://blog.csdn.net/qq_36898043/article/details/79655309

第21章并发

并发的多面性
1.1 更快地执行
1.2 改进代码设计
基本的线程机制
2.1 定义任务
Runnable接口：https://blog.csdn.net/yangyechi/article/details/88079983
2.2 Thread类
Thread类构造器接收Runnable对象；
继承Thread类并覆盖run方法；
2.3 使用Executor
Executor用于管理Thread对象；
CachedThreadPool，FixedThreadPool，SingleThreadPool
线程池介绍：https://www.cnblogs.com/liyus/p/10235942.html

    public static void main(String[] args) {
        // 不建议这样使用, 建议 new ThreadPoolExcutor(), 强制程序员理解其中各个参数的意思
        ExecutorService executorService = Executors.newCachedThreadPool();  
        for(int i=0; i<5; i++){
            executorService.execute(new TaskThread()); // thread对象或者runnable对象
        }
        executorService.shutdown(); // 不在接收任务
    }

2.4 从任务中产生返回值
Callalbe接口+Future对象：https://blog.csdn.net/zsj777/article/details/85089993
2.5 休眠
2.6 优先级
线程优先级：https://blog.csdn.net/weixin_37139197/article/details/81989749
2.7 让步
yield：https://www.cnblogs.com/chinaifae/articles/10373846.html
2.8 后台线程
https://blog.csdn.net/staticFinal_shuaibi/article/details/84865688
2.9 编码的变体
2.10 术语
2.11 加入一个线程
join：https://www.iteye.com/blog/uule-1101994
2.12 创建有响应的用户界面
2.13 线程组
2.14 捕获异常

共享受限资源
3.1 不正确地访问资源
3.2 解决共享资源竞争
Synchronized关键字的用法：https://www.cnblogs.com/fnlingnzb-learner/p/10335662.html
Synchronized关键字配合wait(), notify(), notifyAll()的使用：https://www.cnblogs.com/moongeek/p/7631447.html
Lock和Condition使用：https://www.cnblogs.com/renjianpiaoliu/p/9250444.html
Lock的实现原理：https://blog.csdn.net/w_s_h_y/article/details/77450166
复习Java内存模型：https://www.cnblogs.com/songpingyi/p/9121745.html
3.3 原子性与易变性
原子性与易变性介绍：https://blog.csdn.net/victorwux/article/details/80466853
volatile关键字原理：https://www.cnblogs.com/wildwolf0/p/11449506.html
3.4 原子类
Java当中的原子类：https://www.jianshu.com/p/b92f0b7da636
3.5 临界区
synchronized实现和Lock实现：https://www.jianshu.com/p/2089ef4d7f09
3.6 在其它对象上同步
3.7 线程本地存储
TheadLocal使用：https://www.zhihu.com/question/341005993/answer/793627819
终结任务
4.1 装饰性花园
4.2 在阻塞时终结
4.3 中断
4.4 检查中断
线程之间的协作
5.1 wait()与notifyAll()
5.2 notify()与notifyAll()
5.3 生产者与消费者
5.4 生产者-消费者队列
5.5 任务间使用管道进行输入/输出
死锁
新类库中的构件

CountDownLatch
https://www.cnblogs.com/cuglkb/p/8572239.html
CyclicBarrier
https://www.jianshu.com/p/333fd8faa56e
Semaphore
https://www.jianshu.com/p/ec637f835e08
Exchanger
https://www.jianshu.com/p/990ae2ab1ae0
DelayQueue
https://baijiahao.baidu.com/s?id=1664636679374249422&wfr=spider&for=pc
PriorityBlockingQueue
https://www.cnblogs.com/yuexiaoyun/p/12203101.html
ArrayBlockingQueue
https://blog.csdn.net/qq_17089617/article/details/80879994
LinkedBlockingQueue
https://www.jianshu.com/p/87d230bcc43c
SynchronousQueue
https://blog.csdn.net/yanyan19880509/article/details/52562039
ScheduledExecutor
https://www.jianshu.com/p/a39a89d28375

8.其它

手动实现线程池

public class MyThreadPool {

    //线程池中允许的最大线程数
    private static int MAXTHREDNUM = Integer.MAX_VALUE;
    //当用户没有指定时默认的线程数
    private int threadNum = 6;
    //线程队列，存放线程任务
    private List<Runnable> queue;

    private WorkerThread[] workerThreads;

    public MyThreadPool(int threadNum) {
        this.threadNum = threadNum;
        if (threadNum > MAXTHREDNUM)
            threadNum = MAXTHREDNUM;
        this.queue = new LinkedList<>();
        this.workerThreads = new WorkerThread[threadNum];
        init();
    }

    //初始化线程池中的线程
    private void init() {
        for (int i = 0; i < threadNum; i++) {
            workerThreads[i] = new WorkerThread();
            workerThreads[i].start();
        }
    }

    public void execute(Runnable task) {
        synchronized (queue) {
            queue.add(task);
            //提交任务后唤醒等待在队列的线程
            queue.notifyAll();
        }
    }

    private class WorkerThread extends Thread {

        private volatile boolean on = true;

        @Override
        public void run() {
            Runnable task = null;
            // 判断是否可以取任务
            try {
                while (on && !isInterrupted()) {
                    synchronized (queue) {
                        while (on && !isInterrupted() && queue.isEmpty()) {
                            queue.wait(1000);
                        }
                        if (on && !isInterrupted() && !queue.isEmpty()) {
                            task = queue.remove(0);
                        }

                        if (task != null) {
                            // 取到任务后执行
                            task.run();
                        }
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            task = null;// 任务结束后手动置空，加速回收
        }

        public void cancel() {
            on = false;
            interrupt();
        }
    }

    public void shutdown() {
        for (int i = 0; i < threadNum; i++) {
            workerThreads[i].cancel();
            workerThreads[i] = null;
        }
        queue.clear();
    }
}

Java编程思想目录（Bruce Eckel著）

第10章 内部类

第15章 泛型

第21章 并发

第10章内部类

第15章泛型

第21章并发