程序进入内存时，即变成一个进程，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位

进程三个特征：

　　独立性：进程是系统中独立存在的实体，拥有自己独立的资源，有自己私有的地址空间，没有经过进程本身允许的情况下，一个用户进程不能直接访问其他进程的地址空间

　　动态性：进程与程序的区别在于，程序是静态的指令集合，而进程是正在系统中活动的指令集合，进程中加入的时间概念，进程有自己的生命周期和各种不同的状态，程序不具备这些

　　并发性：多个进程可以在单个处理器上并发执行，多个进程间不会互相影响

并发和并行：

　　并行是同一时刻，多个指令在多个处理器上同时执行

　　并发指在同一时刻只有一条指令执行，但多个进程指令被快速轮换，宏观上被同时执行

并发方式：

　　共用式的多任务操作策略

　　抢占式多任务操作策略：效率更高更常用

多线程：

　　扩展了多进程，使得同一个进程可以同时并发处理多个任务。

　　线程thread也被称为轻量级进程，是进程的执行单元，类似进程在操作系统中的地位，线程在程序中是独立的，并发的执行流，进程初始化后，主线程就被创立。

　　线程是进程的组成部分，一个进程有多个线程，一个线程必须有一个父进程，线程可以有自己的堆栈，自己的程序计数器和局部变量，但不能拥有系统资源，与父进程的其他线程共享该进程的全部资源。

　　线程是独立运行的，不知道进程中其他线程的存在，执行时抢占式的

　　一个线程可以创建和撤销另一个线程，同一个进程中多个线程可以并发执行

多线程编程优点：

　　进程间不能共享内存，线程间非常容易

　　系统创建进程要为该进程重新分配系统资源，但创建线程代价很小，多线程来实现多任务并发比多进程效率高

　　Java内置了多线程功能支持，简化了多线程编程

线程的创建和启动：

　　1.继承Thread类创建线程类:

　　　　定义Thread类的子类，并重新run()方法，创建Thread子类的实例，调用线程对象的start()启动线程

　　　　Thread.currentThread：Thread类的静态方法，总是返回当前正在执行的线程对象

　　　　getName()：Thread类的实例方法，返回调用该方法的线程名称

　　　　获得当前线程对象可以用this

　　　　不能共享线程类的实例变量

　　2.实现Runnable接口创建线程类：

　　　　定义Runnable接口的实现类，并重新run()方法，创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread才是真正的线程对象

　　　　SecondThread implements Runnable{}

　　　　SecondThread st = new SecondThread();

　　　　new Thread(st).start();

　　　　new Thread(st,"第二个线程名称").start();

　　　　获得当前线程对象必须使用Thread.currentThread()

　　　　可以共享线程类的实例变量，因为线程对象只是线程类的target

　　3.使用Callable和Future创建线程：

　　　　java5后开始支持，模仿C#的任何方法都可以做线程执行体

　　　　Runnable接口增强版，Callable接口提供一个call()方法，可以作为线程载体，功能比run()强大：

　　　　　　call()可以有返回值，

　　　　　　call()可以声明抛出异常

　　　　提供一个Callbale对象作为Thread的target，线程执行体就是该Callable对象的call()方法

　　　　Callable不是Runnable接口的子接口，所以Callable对象不能直接作为Thread的target，call()方法还有返回值，所以call()方法不是直接被调用，而是作为线程执行体被调用

　　　　Future接口代表Callable接口里call()方法的返回值，提供了FutureTask实现类，该实现类实现了Futrue接口，也实现了Runnable接口，即可以作为target：

　　　　Futrue接口里控制它关联的Callable任务的公有方法：

　　　　　　boolean cancel(boolean mayInterruptRunning)：试图取消该Future关联的Callable任务

　　　　　　V get()：返回Callable任务里的call()方法的返回值，调用该方法会导致程序阻塞，必须等子线程结束偶才会得到返回值

　　　　　　V get(long timeout, TimeUnit unit)：返回Callable任务里call()方法的返回值，让程序最多阻塞timeout和unit指定的时间，如果指定时间后Callable任务依然没有返回值，将会抛出TimeoutException异常

　　　　　　boolean isCancelled()：如果在Callable任务完成前取消，则返回true

　　　　　　boolean isDone()：如果Callable任务已完成，则返回true

　　　　创建线程步骤：

　　　　　　创建Callable接口的实现类，并实现call()方法，该call()仿作将作为线程执行体且该call()方法有返回值。再创建Callable实现类的实例，可以使用Lambda表达式创建Callable对象

　　　　　　使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值

　　　　　　使用FutureTask对象作为Thread对象的target创建并启动新线程

　　　　　　调用FutureTask对象的get()方法来获得子线程执行后的返回值

　　　　使用Lambda表达式来创建Callable对象，无需创建Callable实现类和对象：

　　　　　　FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>()->{...});

三种创建线程方式对比：

　　通过继承Thread类后者实现Runnable、Callable接口都可以实现多线程，实现Runnable接口和实现Callable接口方式基本相同，只是Callable接口的方法有返回值，可以抛出异常。两者归为一种，实现接口方式。

　　采用实现接口方式创建多线程优缺点：

　　优点：

　　　　线程类只是实现了Runnable接口或者Callable接口，还可以继承其他类

　　　　多个线程可以共享一个target对象，非常适合多个相同线程来处理同一份资源，可以将CPU、代码和数据分开，形成清晰的模型，较好的体现了面向对象思想

　　缺点：

　　　　编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法

　　采用继承Thread类创建多线程优缺点：

　　优点：

　　　　编写简单，访问当前线程直接使用this即可

　　缺点：

　　　　因为已经继承了Thread类，所以不能再继承其他父类

线程的生命周期：

　　有新建New，就绪Runnable，运行Running，阻塞Block，死亡Death五种状态

　　线程多次在运行和阻塞状态切换

　　线程被创建后，进入新建状态，和普通对象一样，仅仅被分配内存，初始化成员变量。

　　调用start()方法后，进入就绪状态，java虚拟机会为其创建方法调用栈和程序计数器，此时并没有开始运行，只表示可以运行，何时开始运行取决于JVM里的线程调度器

　　处于就绪态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态，处于运行状态的线程数量取决于几个处理器，最高不超多处理器数量

　　抢占式的系统为每个线程分配时间片，用完则剥夺该线程资源，让其他线程获得机会。当发生如下情况时，线程将进入阻塞状态：

　　　　线程调用sleep()方法主动放弃所占用的处理器资源

　　　　线程调用了一个阻塞式I/O方法，在该方法返回之前，该线程被阻塞

　　　　线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有，

　　　　线程在等待某个通知notify

　　　　程序调用了线程的suspend()方法将该线程挂起，这方法容易导致死锁，要避免

　　阻塞线程在合适时候进入就绪状态，不是运行状态，必须等待线程调度器再次调用它

　　对的解除阻塞状态，进入就绪状态措施：

　　　　调用sleep()方法的线程经过的指定时间

　　　　线程调用I/O方法已经返回

　　　　线程成功获得了试图取得的同步监视器

　　　　线程正在等待通知时，其他线程发出了一个通知

　　　　处于挂起状态的线程被调用了resume()恢复方法

　　线程有阻塞只能进入就绪状态，无法直接进入运行态

　　就绪态和运行态之间的转换通常不受程序控制，而是有系统线程调度所决定，就绪态得到处理器资源，进入运行态，失去处理器资源或者调用yield()方法可以让运行态的线程转入就绪态

　　线程结束后，进入死亡态：

　　　　run()或者call()方法执行完成，线程正常结束

　　　　线程抛出一个未捕获的Exception或者Error

　　　　直接调用该线程的stop()方法来结束该线程，容易导致死锁，避免使用

　　线程对象的boolean isAlive()方法：线程处于就绪，运行，阻塞三种状态，返回true，处于新建，死亡两种状态，返回false

　　不能对死亡的线程调用start()，也不能对新建状态的线程调用两次start()，都会报报IllegalThreadStateException异常

控制线程：

　　join线程：

　　　　Thread提供了让一个线程等待另一个线程完成的方法，当在某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到join()方法加入的线程执行完为止

　　　　join通常由使用线程的程序调用，以将大问题分为小问题，每个小问题分配一个线程，每个小问题都得到处理后，再调用主线程来进一步操作

　　　　三种重载方式：join()，join(long millis)，join(long millis, int nanos)

　　daemon线程：

　　　　在后台运行，为其他线程提供服务，叫做后台线程，又被称为守护线程，精灵线程，JVM的垃圾回收线程就是典型的后台线程

　　　　特征：如果所有前台线程死亡，后台线程会自动死亡

　　　　调用Thread对象的setDaemon(true)方法可以将指定线程设置成后台线程，必须在start()前调用，否则IllegalThreadStateException

　　　　isDaemon()：判断指定线程是否为后台线程

　　sleep线程：

　　　　让当前线程暂停一段时间，并进入阻塞状态

　　　　两种重载形式：static void sleep(long millis)，static void sleep(long millis, int nanos)

　　　　Thread.sleep(1000)

　　yield让步线程：

　　　　让当前线程暂停，但不进入阻塞，只是将线程转入就绪状态

　　　　yield()只是让当前线程暂停一下，让线程调度器重新调度一次，完全有可能yield暂停后，又被调度出来重新执行

　　　　yield后，只有优先级大于等于当前线程的，处于就绪状态的线程，才会获得执行机会

　　　　Thread.yield()

　　sleep和yield区别：

　　　　sleep方法暂停线程后，会给其他线程执行机会，不会理会其他线程的优先级，但yield方法只会给优先级相同或者更高的线程执行机会

　　　　sleep方法会将线程转入阻塞状态，直到经过阻塞时间才会进入就绪态，但yield方法强制将线程转入就绪态，因为完成可能yield暂停后，又立刻开始执行

　　　　sleep方法声明抛出InterruptedException异常，所以调用sleep方法要么捕捉该异常，要么显式抛出该异常，但yield方法没有声明抛出任何异常

　　　　sleep方法比yield方法具有更好的移植性，通常不建议使用yield方法来控制并发的线程执行

改变线程优先级：

　　Thread提供了setPriority(int pri)，getPriority()方法来设置和返回指定线程的优先级，setPriority方法参数可以是1到10之间的整数，也可以使用以下三个静态常量：

　　　　MAX_PRIORITY：10

　　　　MIN_PRIORITY：1

　　　　NORA_PRIORITY：5

　　改变主线程优先级：

　　　　Thread.currentThread().setPriority(6);

　　具体优先级层数和系统有关，所以避免使用具体数字，使用三个静态常量

线程同步：

　　同步代码块：

　　　　synchronized(obj){。。。同步代码块。。。}，obj即为同步监视器，线程执行同步代码块之前，必须获得对同步监视器的锁定

　　　　java允许使用任何对象作为同步监视器，但一般使用可能被并发访问的共享资源充当同步监视器

　　同步方法：

　　　　使用synchronized关键字修饰的方法

　　　　对于synchronized修饰的实例方法，无需指定同步监视器，同步方法的同步监视器是this，也就是调用该方法的对象

　　　　不要对线程安全类的所有方法都同步，只对会改变竞争资源的方法同步

　　　　对于可变类，如果有两种运行环境：单线程和多线程，应该提供两种版本，StringBuilder和StringBuffer就是为了照顾单线程和多线程所提供的类，单线程用StringBuilder保证性能，多线程用StringBuffer保证安全

　　释放同步监视器的锁定：

　　　　程序无法显式的释放同步监视器的锁定

　　　　以下情况会释放同步监视器的锁定：

　　　　　　当前线程的同步方法，同步代码块执行结束，当前线程释放同步监视器

　　　　　　当前线程的同步方法，同步代码块中遇到break，return终止了该代码块、方法的执行，当前线程释放同步监视器

　　　　　　当前线程的同步方法，同步代码块出现了未处理的Error或Exception，导致异常结束，当前线程释放同步监视器

　　　　　　当前线程的同步方法，同步代码块程序执行了同步监视器对象的wait()方法，当前线程暂停，当前线程释放同步监视器

　　　　以下情况线程不会释放同步监视器：

　　　　　　线程的同步方法，同步代码块时，程序调用了Thread.sleep()，Thread.yield()方法来暂停当前线程的执行，当前线程不会释放同步监视器

　　　　　　线程的同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，当前线程不会释放同步监视器

　　同步锁：

　　　　java5开始，java提供了一种更强大的同步机制——通过显式定义同步锁对象Lock来实现同步

　　　　Lock比起同步监视器更灵活，有Lock，ReadWriteLock两个根接口，并分别提供了ReentranceLock，ReentranceReadWriteLock两个实现类

　　　　使用：

　　　　　　class X{

　　　　　　　　private final ReentranceLock lock = new ReentranceLock();

　　　　　　　　public void m(){

　　　　　　　　　　lock.lock();　　//加锁

　　　　　　　　　　try{...需要保证线程安全的代码...}

　　　　　　　　　　finally{lock.unlock();}　　//释放锁

　　　　　　　　}　　

　　　　　　}

　　　　通常建议使用try/finally来确保锁被释放

　　死锁：

　　　　有主线程和副线程，主线程有A对象锁，等待对B对象加锁，副线程有B对象锁，等待对A对象加锁，两个线程互相等待对方先释放，构成死锁

　　　　不推荐使用suspend，容易死锁

线程通信：

　　传统的线程通信（对于synchronized实现同步）：

　　　　Object类提供的wait()，notify()，notifyAll()三个方法，注意不是Thread类的方法，是Object类

　　　　　　对于synchronized修饰的同步方法，因为该类的默认实例this就是同步监视器，所以可以直接调用三个方法

　　　　　　对于synchronized修饰的同步代码块，同步监视器是synchronized后面的对象，必须使用该对象来调用这三个方法

　　　　wait()：导致当前线程等待，知道其他线程调用该同步监视器的nofity方法或者notifyAll方法来唤醒线程，三种重载，有参数的即指定时间。会释放锁定

　　　　notify()：唤醒在此同步监视器上等待的单个线程，如果有多个线程在等待，则随机唤醒其中一个，只有在当前线程放弃锁定，即使用wait方法后，才可以执行被唤醒的线程

　　　　nofifyAll()：唤醒在此同步监视器上等待的所有线程，同样只有当前线程放弃锁定，才能执行被唤醒的线程

　　使用Condition控制线程通信（对于Lock实现同步）：

　　　　使用Lock实现同步的线程，不存在隐式的同步监视器，所以无法使用wait，notify，notifyAll。对于此情况，java提供了Condition类来保持协调

　　　　Condition可以让得到Lock对象但无法继续执行的线程释放Lock对象，也可以唤醒其他处于等待的线程

　　　　Condition实例被绑定在Lock对象上，获得特定Lock实例的Condition实例，调用Lock对象的newCondition()方法即可：

　　　　　　private final Condition con = lock.newCondition();

　　　　　　cond.await();

　　　　Condition类提供了三个方法：

　　　　　　await()：类似于wait()，导致当前线程等待，直到其他线程调用该Condition的signal或者signalAll

　　　　　　signal()：唤醒在此Lock对象上等待的单个线程，多个则随机唤醒一个，只有当前线程放弃对该Lock对象的锁定后，才可以执行被唤醒的线程

　　　　　　signalAll()：唤醒所有线程，只有当前线程放弃对该Lock对象的锁定后，才可以执行被唤醒的线程

　　使用BlockingQueue阻塞队列控制线程通信：

　　　　特征：当生产者线程试图向BlockingQueue中放入元素时，如果该队列已满，则该线程被阻塞；当消费者线程试图从BlockingQueue中取出元素时，如果该队列已空，则该线程被阻塞

　　　　BlockingQueue提供两个支持阻塞的方法：

　　　　　　put(E e)：尝试把e放入BlockingQueue中，如满则阻塞

　　　　　　take()：尝试从BlockingQueue的头部取出元素，如空则阻塞

　　　　BlockingQueue继承了Queue接口，可以使用Queue接口中的方法，分为三组：

　　　　　　在队列尾部插入元素：add(E e), offer(E e), put(E e)，当队列已满，分别会抛出异常，返回false，阻塞队列

　　　　　　在队列头部删除并返回被删除的元素：remove(),poll(),take()，当队列为空，分别会抛出异常，返回false，阻塞队列

　　　　　　在队列头取出但不删除元素：element(),peek()，当队列为空，分别会抛出异常，返回false

　　　　BlockingQueue有五个实现类：ArrayBlockingQueue,LinkedBlockingQueue,PriorityBlockingQueue,SynchronizedBlockingQueue,DelayBlockingQueue

　　使用管道pipe通信

　　通过volatile使用while轮询

线程组和线程的未处理异常：

　　java使用ThreadGroup表示线程组，可以对同一批线程进行管理。没显式指定线程属于哪个线程组，则属于默认线程组。在默认情况下，子线程和创建他的线程处于同一个线程组。一旦加入线程组后，线程一直属于该线程组，直到死亡，不能更改

　　ThreadGroup定义了非常有用的方法：void uncaughtException(Thread t, Throwable e)，该方法可以处理该线程组内部任意线程所抛出的未处理异常

线程池：

　　与数据库连接池类似，线程池在系统启动时即创建大量的空闲线程，程序将一个Runnable或者Callable对象传给线程池，线程池就启动一个线程来执行他们的run()或者call()方法，执行结束后，线程不会死亡，而是返回线程池中成为空闲状态

　　线程池可以有效控制系统中并发线程的数量，大量并发线程会导致系统性能急剧下降甚至崩溃，而线程池的最大线程参数可以控制系统中并发线程数不超过此数

　　java5前，必须手动实现线程池，java5后，java支持内建线程池，新增了一个Executors工厂类生产线程池，该工厂类包含以下几个静态工厂方法创建线程池：

　　　　ExecutorService newCachedThreadPool()：创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中

　　　　ExecutorService newFixedThreadPool(int nThreads)：创建一个可重用的，具有固定线程数的线程

　　　　ExecutorService newSingleThreadPool()：创建一个只有单线程的线程池，相当于调用newFixedThreadPoll(1)

　　　　ScheduledExecutorService newScheduledThreadPool(int n)：创建具有指定线程数的线程池，可以在指定延迟后执行线程任务

　　　　ScheduledExecutorService newSingleThreadScheduledExecutor()：相当于newScheduledThreadPoll(1)

　　java8新增，利用多CPU并行能力，生成的是后台线程池：

　　　　ExecutorService newWorkStealingPool(int parallelism)：创建持有足够的线程的线程池来支持给定的并行级别，该方法会使用多个队列来减少竞争

　　　　ExecutorService newWorkStealingPool()：newWorkStealingPoll()的简化版本，按cpu个数来设置并行级别

　　ScheduledExecutorService是ExecutorService的子类，可以在指定延迟后执行线程任务

　　ExecutorService代表尽快执行线程，只要线程池中有空闲线程，就立即执行任务，程序只要将一个Runnable对象或者Callable对象（代表线程任务）提交给该线程池，线程池会尽快执行该任务

　　三个方法：

　　　　Futrue<?> submit(Runnable task)：一个Runnable对象提交给线程池，线程池有空将会执行Runnable代表的任务。Future对象代表Runnable任务的返回值，但run()犯法没有返回值，所以Future对象在run方法执行结束后返回null

　　　　<T>Future<T> submit(Runnable task, T result)：其他同上，但result显式指定线程执行结束后的返回值，Futrue对象在run方法执行后返回result

　　　　<T>Future<T> submit(Callable task)：其他同上，Future代表Callable对象里call()方法的返回值

　　使用线程池执行线程任务步骤：

　　　　调用Executors类的静态工厂方法创建一个ExecutorService对象，该对象代表一个线程池

　　　　创建Runnable实现类或者Callable实现类的实例，作为线程执行任务

　　　　调用ExecutorService对象的submit()方法来提交线程执行任务

　　　　当不想提交任务时，调用ExecutorService对象的shutdown()方法来关闭线程池

　　通过线程池来执行任务，不通过启动线程：

　　　　ExecutorService pool = Executors.newFixedThreadPoll(6);

　　　　Runnable target = ()->{...}　　//用Lambda表达式创建Runnable对象

　　　　pool.submit(target);

　　　　pool.submit(target);

　　　　pool.shutdown();

　　ForkJoinPool：将一个任务拆分成多个小任务，最终再合并

线程相关类：

　　ThreadLocal类：

　　　　java5后引入了泛型支持：ThreadLocal<T>，可以简化多线程编程时的并发访问

　　　　线程局部变量，就是为每一个使用该变量的线程都提供一个变量值的副本，使每一个线程都可以独立改变自己的副本，而不会和其他线程副本冲突，就好像每一个线程都完全拥有该变量一样

　　　　三个public方法：

　　　　　　T get()：返回此线程局部变量中当前线程的值

　　　　　　void remove()：删除此线程局部变量中当前线程的值

　　　　　　void set()：设置此线程局部变量中当前线程副本的值

　　　　private ThreadLocal<String> tl= new ThreadLocal<>(); tl.get();

　　　　解决多线程对同一变量的访问冲突，从另一个角度解决并发访问，不是通过锁，从而不用进行同步

　　　　不能代替同步机制，两者面向的问题领域不同。如果多个线程需要共享资源，以达到线程之间通信功能，使用同步机制，如果仅仅需要隔离多个线程之间的共享冲突，可以使用ThreadLocal

　　包装线程不安全的集合：Collections的类方法

　　线程安全的集合类：

　　　　以Concurrent开头的集合类

　　　　以CopyOnWrite开头的集合类

　　　　VSHE四个类

obj.wait()和Thread.sleep()都需要进行异常捕捉