什么是线程？讲个故事给你听，让你没法去背这个题，地址：https://blog.csdn.net/java_wxid/article/details/94131223
有几种实现方式？
继承Thread类
实现Runnable接口
实现Callable接口
线程池方式
优缺点
1.继承Thread类
优点 、代码简单 。
缺点 、该类无法集成别的类。
2.实现Runnable接口
优点 、继承其他类。 同一实现该接口的实例可以共享资源。
缺点 、代码复杂
3.实现Callable
优点 、可以获得异步任务的返回值
4.线程池 、实现自动化装配，易于管理，循环利用资源。
代码实现案例：
继承Thread类，并重写里面的run方法 class A extends Thread{ public void run(){ for(int i=1;i<=100;i++){ System.out.println("-----------------"+i); } } } A a = new A(); a.start(); 实现Runnable接口，并实现里面的run方法 class B implements Runnable{ public void run(){ for(int i=1;i<=100;i++){ System.out.println("-----------------"+i); } } } B b = new B(); Thread t = new Thread(b); t.start(); 实现Callable class A implements Callable<String>{ public String call() throws Exception{ //... } } FutureTask<String> ft = new FutureTask<>(new A()); new Thread(ft).start(); 线程池 ExcutorService es = Executors.newFixedThreadPool(10); es.submit(new Runnable(){//任务}); es.submit(new Runnable(){//任务}); ... es.shutdown();
问题扩展
在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？
整体上来说Lock是synchronized的扩展版，Lock提供了无条件的、可轮询的(tryLock方法)、定时的(tryLock带参方法)、可中断的(lockInterruptibly)、可多条件队列的(newCondition方法)锁操作。另外Lock的实现类基本都支持非公平锁(默认)和公平锁，synchronized只支持非公平锁，当然，在大部分情况下，非公平锁是高效的选择。
线程池的实现原理：https://blog.csdn.net/java_wxid/article/details/101844786
JUC并发包：
volatile的三大特性：https://blog.csdn.net/java_wxid/article/details/97611028
CompareAndSwap底层原理：https://blog.csdn.net/java_wxid/article/details/97611037
AtomicReference原子引用：https://blog.csdn.net/java_wxid/article/details/97611046
CountDownLatch倒计时器：https://blog.csdn.net/java_wxid/article/details/99168098
CyclicBarrier循环栅栏：https://blog.csdn.net/java_wxid/article/details/99171155
Semaphore信号灯：https://blog.csdn.net/java_wxid/article/details/99174538
ThreadLocal与Lock和Synchronize区别
ThreadLocal与Lock和Synchronize区别
ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。ThreadLocal采用了“以空间换时间”的方式，为每一个线程都提供了一份变量，因此可以同时访问而互不影响。
synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。同步机制采用了“以时间换空间”的方式，仅提供一份变量，让不同的线程排队访问。
如果一个代码块被synchronized关键字修饰，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待直至占有锁的线程释放锁。事实上，占有锁的线程释放锁一般会是以下三种情况之一：
占有锁的线程执行完了该代码块，然后释放对锁的占有；
占有锁线程执行发生异常，此时JVM会让线程自动释放锁；
占有锁线程进入 WAITING 状态从而释放锁，例如在该线程中调用wait()方法等。
synchronized 是Java语言的内置特性，可以轻松实现对临界资源的同步互斥访问。那么，为什么还会出现Lock呢？试考虑以下三种情况：
Case 1 ：
在使用synchronized关键字的情形下，假如占有锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，那么其他线程就只能一直等待，别无他法。这会极大影响程序执行效率。因此，就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间 (解决方案：tryLock(long time, TimeUnit unit)) 或者 能够响应中断 (解决方案：lockInterruptibly())），这种情况可以通过 Lock 解决。
Case 2 ：
我们知道，当多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作也会发生冲突现象，但是读操作和读操作不会发生冲突现象。但是如果采用synchronized关键字实现同步的话，就会导致一个问题，即当多个线程都只是进行读操作时，也只有一个线程在可以进行读操作，其他线程只能等待锁的释放而无法进行读操作。因此，需要一种机制来使得当多个线程都只是进行读操作时，线程之间不会发生冲突。同样地，Lock也可以解决这种情况 (解决方案：ReentrantReadWriteLock) 。
Case 3 ：
我们可以通过Lock得知线程有没有成功获取到锁 (解决方案：ReentrantLock) ，但这个是synchronized无法办到的。
上面提到的三种情形，我们都可以通过Lock来解决，但 synchronized 关键字却无能为力。事实上，Lock 是 java.util.concurrent.locks包 下的接口，Lock 实现提供了比 synchronized 关键字 更广泛的锁操作，它能以更优雅的方式处理线程同步问题。也就是说，Lock提供了比synchronized更多的功能。但是要注意以下几点：
1）synchronized是Java的关键字，因此是Java的内置特性，是基于JVM层面实现的。而Lock是一个Java接口，是基于JDK层面实现的，通过这个接口可以实现同步访问；
2）采用synchronized方式不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而 Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致死锁现象。
关于读写锁：https://blog.csdn.net/java_wxid/article/details/99165717
