创建线程的三种方式：
- 继承Thread类
语法：public class A extends Thread{}
案例：A a=new A();a.start();
- 实现Runnable接口
语法：public class A implements Runnable{}
案例：A a=new A();Thread t=new Thread(a);t.start()
- 实现了Callable接口（有返回值的线程）
语法：public class CallableDemo implements Callable
案例：
ExecutorService es = Executors.newSingleThreadExecutor(); //创建线程池
CallableDemo calTask=new CallableDemo();//创建Callable对象任务
Future future =es.submit(calTask);//提交任务并获取执行结果
future.get()//输出返回来的值
线程安全之“锁”：
01-synchronized
synchronized保证代码具有原子性和可见性，可见性保证每次读取到的是最新值，原子性保证在整个操作过程中确保代码执行的原子性，不可分割。
02-ReentrantLock
ReentrantLock是一个可重入的互斥锁，又被称为“独占锁”。顾名思义，ReentrantLock锁在同一个时间点只能被一个线程锁持有；而可重入的意思是，ReentrantLock锁，可以被单个线程多次获取。
“公平锁”和“非公平锁”：ReentrantLock分为“公平锁”和“非公平锁”。它们的区别体现在获取锁的机制上是否公平。“锁”是为了保护竞争资源，防止多个线程同时操作线程而出错，ReentrantLock在同一个时间点只能被一个线程获取(当某线程获取到“锁”时，其它线程就必须等待)；ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下，线程依次排队获取锁；而“非公平锁”在锁是可获取状态时，不管自己是不是在队列的开头都会获取锁。
使用方式:
创建锁对象：Lock lock = new ReentrantLock();
锁代码：lock.lock();.......锁的内容；.......lock.unlock();
常用方法:
（1）尝试获取锁：boolean locked = lock.tryLock();//根据locked值去判定执行什么样的代码
（2）尝试超时：boolean locked=lock.tryLock(5, TimeUnit.SECONDS);//尝试获取lock锁对象5秒
（3）可打断：lock.lockInterruptibly(),线程在请求lock并被阻塞时(t1占用了lock锁对象，t2请求被阻塞)，如果此时t2被t3线程interrupt（t2.interrupt()），则“此t2线程会被唤醒并被要求处理InterruptedException”。
通俗理解：
（1）lock(), 拿不到lock就不罢休，不然线程就一直block。 比较无赖的做法。不能被打断
（2）tryLock()，马上返回，拿到lock就返回true，不然返回false。 比较潇洒的做法。
带时间限制的tryLock()，拿不到lock，就等一段时间，超时返回false。比较聪明的做法。
（3）lock.lockInterruptibly()请求锁，请求不到也会一直请求，但是可以被其他线程打断，打断后处理InterruptedException异常，即执行catch和finally代码块
03-synchronized和ReentrantLock的区别
（1）synchronized的锁是自动释放的，而ReentrantLock得lock需要手动释放（lock.unlock()）；
（2）使用synchronized锁定的话如果遇到异常，jvm会自动释放锁，但是lock必须手动释放锁，因此经常在finally中进行锁的释放；
（3）ReentrantLock更具灵活性
常见线程池：
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。
01-newFixedThreadPool(6)
案例：ExecutorService service = Executors.newFixedThreadPool(6);
解读：来一个任务，创建一个线程，线程启动后不会销毁，上限是6个。当线程被占用完时，所有任务都被放在一个队列中进行等待，等待线程被释放。
02-newCachedThreadPool()
案例：ExecutorService service = Executors.newCachedThreadPool();
解读：刚开始一个线程都没有，来一个任务就起一个线程，当来新任务时发现有空闲的线程，就直接使用空闲的，不再新起线程了（线程空闲1min就自动销毁）；当来新任务时发现没有空闲的线程，此时便启动一个新的线程，保证在等待区任务队列中的任务个数永远为0；
03-newSingleThreadExecutor()
案例：ExecutorService service = Executors.newSingleThreadExecutor();
解读：线程池永远只有一个线程。保证任务的先后执行顺序，只有第一个任务执行完，才能执行第二个任务。线程起来后永远不结束。
04-newScheduledThreadPool(4);
案例：ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
解读：执行定时的任务。线程是可以复用的，第一个线程来了，执行完后，来第二个线程，这时候就直接用已存在的空闲线程。定时容器装任务，线程启动后就不会销毁。service.scheduleAtFixedRate(task, 0, 500, TimeUnit.MILLISECONDS);第一个tast立即执行，没隔500mms执行一次任务。
05-newWorkStealingPool();
案例：ExecutorService service = Executors.newWorkStealingPool();
解读：工作窃取，每个线程维护自己的等待队列，当自己队列为空时，会去偷其他线程队列中的任务。
06-new ForkJoinPool()
作用：将一个任务进行拆分处理，并将处理后的结果进行汇总
案例：
ForkJoinPool fjp = new ForkJoinPool();
执行分块的类，需要extends RecursiveTask或RecursiveAction，其中：AddTask extends RecursiveAction：无返回值；AddTask extends RecursiveTask ：有返回值，通过task.join()加入主线程汇总求和。
分块：AddTask task = new AddTask(0, nums.length);
执行分块计算：fjp.execute(task);
解读：工作窃取，每个线程维护自己的等待队列，当自己队列为空时，会去偷其他线程队列中的任务。