目录
1、什么是线程、多线程、并行、并发？2、为什么应用多线程？3、怎么创立线程？4、怎么保障线程平安？5、线程如何调度的？6、线程分类？7、其它一、什么是线程、多线程？
首先咱们先理解下，程序、过程：程序：是一组计算机能辨认和执行的指令，运行于电子计算机上，满足人们某种需要的信息化工具。过程：正在运行的一个应用程序，是一个动静的过程，有它本身的产生，存在和沦亡的过程。(领有独立的内存空间)(例如：运行一个word.exe软件，就是一个过程)线程：过程可进一步细化为线程，是一个程序外部的一条执行办法，有本人独立的工作内存(栈)和共享内存(堆)。（从宏观角度上了解线程是并行运行的，然而从宏观角度上剖析却是串行运行的，即一个线程一个线程的去运行，当零碎只有一个CPU时，线程会以某种程序执行多个线程，咱们把这种状况称之为线程调度。工夫片即CPU调配给各个程序的运行工夫(很小的概念)）多线程：指的是这个过程运行时产生了不止一个线程。并行：指两个或多个事件在同一时刻点产生。(计算机系统中有多个CPU，则这些能够并发执行的程序便可被调配到多个处理器上，实现多任务并行执行，即利用每个处理器来解决一个可并发执行的程序，这样，多个程序便能够同时执行，因为是宏观的，所以大家在应用电脑的时候感觉就是多个程序是同时执行的。)并发：指两个或多个事件在同一时间段内产生。（在单CPU零碎中，每一时刻却仅能有一道程序执行（工夫片），故宏观上这些程序只能是分时地交替执行。）二、为什么要应用多线程？
用线程只有一个目标，那就是更好的利用cpu的资源，因为所有的多线程代码都能够用单线程来实现。三、怎么创立线程？
1、继承Thread类
步骤:1):定义一个类A继承于java.lang.Thread类.2):在A类中笼罩Thread类中的run办法.3):咱们在run办法中编写须要执行的操作---->run办法里的,线程执行体.4):在main办法(线程)中,创立线程对象,并启动线程.留神：启动线程，必须用start()办法，这样才能够创立线程，不可间接调用run()办法，这样无奈创立线程，只是你在main办法调用了run()办法，都只是main线程执行，没有创立新线程。生产者与消费者例子(继承Thread版)：
package com.example.gxw.Thread; import android.view.Window; /** * * 创立三个窗口卖票，总票数为100张，应用继承自Thread形式 * 用动态变量保障三个线程的数据独一份 * * 存在线程的平安问题，有待解决 * * */ public class ThreadDemo extends Thread{ public static void main(String[] args){ window t1 = new window(); window t2 = new window(); window t3 = new window(); t1.setName("售票口1"); t2.setName("售票口2"); t3.setName("售票口3"); t1.start(); t2.start(); t3.start(); } } class window extends Thread{ //将其加载在类的动态区，所有线程共享该动态变量 private static int ticket = 100; @Override public void run() { while(true){ if(ticket>0){ System.out.println(getName()+"以后售出第"+ticket+"张票"); ticket--; }else{ break; } } } }2、实现Runnable接口
步骤:1):定义一个类A实现于java.lang.Runnable接口,留神A类不是线程类.2):在A类中笼罩Runnable接口中的run办法.3):咱们在run办法中编写须要执行的操作(run办法里的,线程执行体).4):在main办法(线程)中,创立线程对象， 并将A实现类做参传给线程结构器,而后通过start()办法启动线程.生产者与消费者例子(实现Runnable版)：
package com.example.gxw.Thread; public class ThreadDemo01 { public static void main(String[] args){ window1 w = new window1(); //尽管有三个线程，然而只有一个窗口类实现的Runnable办法，因为三个线程共用一个window对象，所以主动共用100张票 Thread t1=new Thread(w); Thread t2=new Thread(w); Thread t3=new Thread(w); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } } class window1 implements Runnable{ private int ticket = 100; @Override public void run() { while(true){ if(ticket>0){ System.out.println(Thread.currentThread().getName()+"以后售出第"+ticket+"张票"); ticket--; }else{ break; } } } }3、实现Callable接口
步骤:1):定义一个类A实现于java.util.concurrent.Callable接口(JDK5新增).2):在A类中笼罩Callable接口中的call办法.3):咱们在call办法中编写须要执行的操作.4):在main办法(线程)中： 1、创立实现Callable接口的实现类 2、创立FutureTask的对象 3、将callable接口实现类的对象作为传递到FutureTask的结构器中 4、创立Thread对象，将FutureTask的对象作为参数传递到Thread类的结构器中 5、通过Thread对象的start()办法启动线程. 6、通过FutureTask的对象调用办法get能够获取线程中的call的返回值。学习例子：
package com.example.gxw.Thread;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;/** * 创立线程的形式三：实现callable接口。---JDK 5.0新增 *是否多线程？否，就一个线程 * * 比runable多一个FutureTask类，用来接管call办法的返回值。 * 实用于须要从线程中接管返回值的模式 * * //callable实现新建线程的步骤： * 1.创立一个实现callable的实现类 * 2.实现call办法，将此线程须要执行的操作申明在call（）中 * 3.创立callable实现类的对象 * 4.将callable接口实现类的对象作为传递到FutureTask的结构器中，创立FutureTask的对象 * 5.将FutureTask的对象作为参数传递到Thread类的结构器中，创立Thread对象，并调用start办法启动（通过FutureTask的对象调用办法get获取线程中的call的返回值） * * *///实现callable接口的call办法class NumThread implements Callable{ private int sum=0;// //能够抛出异样 @Override public Object call() throws Exception { for(int i = 0;i<=100;i++){ if(i % 2 == 0){ System.out.println(Thread.currentThread().getName()+":"+i); sum += i; } } return sum; }}public class ThreadNew { public static void main(String[] args){ //new一个实现callable接口的对象 NumThread numThread = new NumThread(); //通过futureTask对象的get办法来接管futureTask的值 FutureTask futureTask = new FutureTask(numThread); Thread t1 = new Thread(futureTask); t1.setName("线程1"); t1.start(); try { //get返回值即为FutureTask结构器参数callable实现类重写的call的返回值 Object sum = futureTask.get(); System.out.println(Thread.currentThread().getName()+":"+sum); } catch (ExecutionException e) { e.printStackTrace(); } catch (InterruptedException e) { e.printStackTrace(); } }}4、线程池
java中常常须要用到多线程来解决一些业务，咱们十分不倡议单纯应用继承Thread或者实现Runnable接口的形式来创立线程，那样势必有创立及销毁线程消耗资源、线程上下文切换问题。同时创立过多的线程也可能引发资源耗尽的危险，这个时候引入线程池比拟正当，不便线程工作的治理。应用线程池的形式：
背景：常常创立和销毁，使用量特地大的资源，比方并发状况下的线程，对性能影响很大。思路：提前创立好多个线程，放入线程池之，应用时间接获取，应用完放回池中。能够防止频繁创立销毁，实现反复利用。相似生存中的公共交通工具。（数据库连接池）益处：进步响应速度（缩小了创立新线程的工夫）升高资源耗费（反复利用线程池中线程，不须要每次都创立）便于线程治理corePoolSize:外围池的大小maximumPoolSize:最大线程数keepAliveTime：线程没有工作时最多放弃多长时间后会终止JDK 5.0 起提供了线程池相干API：ExecutorService 和 Executors。ExecutorService:真正的线程池接口，常见子类ThreadPoolExecutor。void execute(Runnable coommand):执行工作/命令，没有返回值，个别用来执行Runnable。Futuresubmit(Callable task):执行工作，有返回值，个别又来执行Callable。void shutdown（）：敞开连接池。线程池代码：
ExecutorService e = Executors.newCachedThreadPool(); ExecutorService e = Executors.newSingleThreadExecutor(); ExecutorService e = Executors.newFixedThreadPool(3); // 第一种是可变大小线程池，依照工作数来调配线程， // 第二种是单线程池，相当于FixedThreadPool(1) // 第三种是固定大小线程池。 // 而后运行 e.execute(new MyRunnableImpl());5、JDK7新增Fork/Join框架
6、JDK8新增并行流
并行流是jdk8的新个性之一，思维就是将一个程序执行的流变为一个并发的流，通过调用parallel()办法来实现。并行流将一个流分成多个数据块，用不同的线程来解决不同的数据块的流，最初合并每个块数据流的处理结果。并行流默认应用的是公共线程池ForkJoinPool，他的线程数是应用的默认值，依据机器的核数，咱们能够适当调整线程数的大小。线程数的调整通过以下形式来实现：System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "100");例子：
public class Test4 { private static List<FileInfo> fileList= new ArrayList<FileInfo>(); public static void main(String[] args) { System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "100"); createFileInfo(); long startTime=System.currentTimeMillis(); fileList.parallelStream().forEach(e ->{ try { Thread.sleep(1); } catch (InterruptedException f) { f.printStackTrace(); } }); long endTime=System.currentTimeMillis(); System.out.println("jdk8并行流耗时："+(endTime-startTime)+"ms"); } private static void createFileInfo(){ for(int i=0;i<30000;i++){ fileList.add(new FileInfo("测试对象" + i)); } }}四、怎么保障线程平安？
首先咱们先理解下，什么是线程平安？
线程平安问题是指，多个线程对同一个共享数据进行操作时，线程没来得及更新共享数据，从而导致另外线程没失去最新的数据，从而产生线程平安问题。而且线程平安须要听从三概念：1、原子性 即一个操作或者多个操作 要么全副执行并且执行的过程不会被任何因素打断，要么就都不执行。2、可见性 可见性是指当多个线程拜访同一个变量时，一个线程批改了这个变量的值，其余线程可能立刻看失去批改的值。3、有序性 即程序执行的程序依照代码的先后顺序执行。例如：一人上单人厕所，但没有上锁，这时第二人也进入，就导致难堪的事产生了。
怎么解决呢，有以下几种形式：
1、同步锁(synchronized关键字)
1>、办法加锁
应用同步办法，对办法进行synchronized关键字润饰将同步代码块提取进去成为一个办法，用synchronized关键字润饰此办法。对于runnable接口实现多线程，只须要将同步办法用synchronized润饰而对于继承自Thread形式，须要将同步办法用static和synchronized润饰，因为对象不惟一（锁不惟一）。2>、同步代码块（须要同步监视器，也就是锁做参）
原理是：当线程开始执行同步代码块前，必须先取得对同步代码块的锁定。并且任何时刻只能有一个线程能够取得对同步监视器的锁定，当同步代码块执行实现后，该线程会开释对该同步监视器的锁定。其中的锁，在非静态方法中可为this，在静态方法中为以后类自身。同步代码块：
synchronized(Object s){ //须要被同步的代码块}留神，synchronized能够润饰办法，润饰代码块，然而不能润饰结构器、成员变量等。
总结：
1.同步办法依然波及到同步监视器，只是不须要咱们显示的申明。2.非动态的同步办法，同步监视器是this3、动态的同步办法，同步监视器是以后类自身。继承自Thread.class2、Lock类
lock: 在java.util.concurrent包内。共有三个实现：1、ReentrantLock2、ReentrantReadWriteLock.ReadLock3、ReentrantReadWriteLock.WriteLock次要目标是和synchronized一样， 两者都是为了解决同步问题，解决资源争端而产生的技术。性能相似但有一些以下区别：lock更灵便，能够自在定义多把锁的加锁解锁程序（synchronized要依照先加的后解程序）提供多种加锁计划：lock 阻塞式, trylock 无阻塞式, lockInterruptily 可打断式， 还有trylock的带超时工夫版本。实质上和监视器锁（即synchronized是一样的）能力越大，责任越大，必须管制好加锁和解锁，否则会导致劫难。和Condition类的联合，性能会更高。ReentrantLock：
步骤：1.先new一个实例 static ReentrantLock r=new ReentrantLock();2.加锁 r.lock()或r.lockInterruptibly(); (此处也是个不同，后者可被打断。 当a线程lock后，b线程阻塞，此时如果是lockInterruptibly，那么在调用b.interrupt()之后，b线程退出阻塞，并放弃对资源的争抢，进入catch块。 （如果应用后者，必须throw interruptable exception 或catch))3、开释锁 r.unlock() （必须做！何为必须做呢，要放在finally外面。 以避免异样跳出了失常流程，导致劫难。 这里补充一个小知识点，finally是能够信赖的：通过测试，哪怕是产生了OutofMemoryError，finally块中的语句执行也可能失去保障。）ReentrantReadWriteLock：
可重入读写锁（读写锁的一个实现） ReentrantReadWriteLock lock = new ReentrantReadWriteLock()ReadLock r = lock.readLock();WriteLock w = lock.writeLock();两者都有lock,unlock办法。写写，写读互斥；读读不互斥。能够实现并发读的高效线程平安代码优先应用程序：
Lock类 > 同步代码块 > 同步办法
总结：Synchronized与lock的异同？
雷同：二者都能够解决线程平安问题不同：synchronized机制在执行完相应的代码逻辑当前，主动的开释同步监视器lock须要手动的启动同步（lock()），同时完结同步也须要手动的实现（unlock()）（同时以lock的形式更为灵便）3、原子类（AtomicInteger、AtomicBoolean……）
首先先理解下什么是原子性：
如果把一个事务可看作是一个程序,它要么残缺的被执行,要么齐全不执行。这种个性就叫原子性而应用原子类就能够保障原子性的操作，等同于synchronized
Java 的原子类都寄存在并发包 java.util.concurrent.atomic 下
根本类型：
应用原子的形式更新根本类型AtomicInteger：整形原子类AtomicLong：长整型原子类AtomicBoolean：布尔型原子类数组类型：
应用原子的形式更新数组里的某个元素AtomicIntegerArray：整形数组原子类AtomicLongArray：长整形数组原子类AtomicReferenceArray：援用类型数组原子类援用类型：
AtomicReference：援用类型原子类AtomicStampedReference：原子更新援用类型里的字段原子类AtomicMarkableReference ：原子更新带有标记位的援用类型对象的属性批改类型：
AtomicIntegerFieldUpdater：原子更新整形字段的更新器AtomicLongFieldUpdater：原子更新长整形字段的更新器AtomicStampedReference：原子更新带有版本号的援用类型。该类将整数值与援用关联起来，可用于解决原子的更新数据和数据的版本号，以及解决应用 CAS 进行原子更新时可能呈现的 ABA 问题。4、volatile关键字（只有在保障原子性的前提下才能够保障线程平安）
这个尽管是一个关键字，但波及很多，还是想详细描述下这段。
volatile关键字作用：
1）保障了不同线程对这个变量进行操作时的可见性，即一个线程批改了某个变量的值，这新值对其余线程来说是立刻可见的。2）禁止进行指令重排序。针对作用的可见性，具体解释：
每个线程都有独立的高速缓存内存，在读取共享变量时，为了提高效率，防止频繁去物理内存读取值，都会读取之后存储到高速缓存内存，而后呢，这样就可能会呈现了线程平安问题，所以才有了线程平安的解决形式。那volatile是怎么解决的呢？1、读取形式更改：当共享变量A加上volatile关键字时，这个操作，就会通知所有线程，你们高速缓存区保留的共享变量A，曾经有效了，你们只有去物理内存去读取才能够。2、批改值形式更改：用volatile关键字会强制线程将批改的值立刻写入物理内存。针对作用的禁止指令重排序，具体解释：
1）当程序执行到volatile变量的读操作或者写操作时，在其后面的操作的更改必定全副曾经进行，且后果曾经对前面的操作可见；在其前面的操作必定还没有进行； 2）在进行指令优化时，不能将在对volatile变量拜访的语句放在其前面执行，也不能把volatile变量前面的语句放到其后面执行。例如：
因为flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2后面，也不会讲语句3放到语句4、语句5前面。然而要留神语句1和语句2的程序、语句4和语句5的程序是不作任何保障的。
并且volatile关键字能保障，执行到语句3时，语句1和语句2必然是执行结束了的，且语句1和语句2的执行后果对语句3、语句4、语句5是可见的。
讲到这里，怎么实现线程平安呢？
下面有讲到volatile能够保障可见性和被批改的变量的有序性，那能够实现原子性？
先看上面例子：
public class Test { public volatile int inc = 0; public void increase() { inc++; } public static void main(String[] args) { final Test test = new Test(); for(int i=0;i<10;i++){ new Thread(){ public void run() { for(int j=0;j<1000;j++) test.increase(); }; }.start(); } while(Thread.activeCount()>1) //保障后面的线程都执行完 Thread.yield(); System.out.println(test.inc); }}大家想一下这段程序的输入后果是多少？兴许有些敌人认为是10000。然而事实上运行它会发现每次运行后果都不统一，都是一个小于10000的数字。
可能有的敌人就会有疑难，不对啊，下面是对变量inc进行自增操作，因为volatile保障了可见性，那么在每个线程中对inc自增完之后，在其余线程中都能看到批改后的值啊，所以有10个线程别离进行了1000次操作，那么最终inc的值应该是1000*10=10000。
这外面就有一个误区了，volatile关键字能保障可见性没有错，然而下面的程序错在没能保障原子性。可见性只能保障每次读取的是最新的值，然而volatile没方法保障对变量的操作的原子性。
首先咱们要晓得自增操作是不具备原子性的，它包含读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会宰割开执行，就有可能导致上面这种状况呈现：
如果某个时刻变量inc的值为10，
线程1对变量进行自增操作，线程1先读取了变量inc的原始值，而后线程1被阻塞了；
而后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，因为线程1只是对变量inc进行读取操作，而没有对变量进行批改操作，所以不会导致线程2的工作内存中缓存变量inc的缓存行有效，所以线程2会间接去主存读取inc的值，发现inc的值时10，而后进行加1操作，并把11写入工作内存，最初写入物理内存。
而后线程1接着进行加1操作，因为曾经读取了inc的值，留神此时在线程1的工作内存中inc的值依然为10，所以线程1对inc进行加1操作后inc的值为11，而后将11写入工作内存，最初写入物理内存。
那么两个线程别离进行了一次自增操作后，inc只减少了1。
那是不是解决原子性，就能够实现线程平安了呢？
答案：是的。
有以下几种形式提供原子性，即可实现线程平安：
1、synchronized
public class Test { public int inc = 0; public synchronized void increase() { inc++; } public static void main(String[] args) { final Test test = new Test(); for(int i=0;i<10;i++){ new Thread(){ public void run() { for(int j=0;j<1000;j++) test.increase(); }; }.start(); } while(Thread.activeCount()>1) //保障后面的线程都执行完 Thread.yield(); System.out.println(test.inc); }}2、采纳Lock
public class Test { public int inc = 0; Lock lock = new ReentrantLock(); public void increase() { lock.lock(); try { inc++; } finally{ lock.unlock(); } } public static void main(String[] args) { final Test test = new Test(); for(int i=0;i<10;i++){ new Thread(){ public void run() { for(int j=0;j<1000;j++) test.increase(); }; }.start(); } while(Thread.activeCount()>1) //保障后面的线程都执行完 Thread.yield(); System.out.println(test.inc); }}3、采纳原子类AtomicInteger：
public class Test { public AtomicInteger inc = new AtomicInteger(); public void increase() { inc.getAndIncrement(); } public static void main(String[] args) { final Test test = new Test(); for(int i=0;i<10;i++){ new Thread(){ public void run() { for(int j=0;j<1000;j++) test.increase(); }; }.start(); } while(Thread.activeCount()>1) //保障后面的线程都执行完 Thread.yield(); System.out.println(test.inc); }}在java 1.5的java.util.concurrent.atomic包下提供了一些原子操作类，即对根本数据类型的 自增（加1操作），自减（减1操作）、以及加法操作（加一个数），减法操作（减一个数）进行了封装，保障这些操作是原子性操作。atomic是利用CAS来实现原子性操作的（Compare And Swap），CAS实际上是利用处理器提供的CMPXCHG指令实现的，而处理器执行CMPXCHG指令是一个原子性操作。
五、线程是如何调度的呢？
调度策略：
工夫片：线程的调度采纳工夫片轮转的形式抢占式：高优先级的线程抢占CPUJava的调度办法：1.对于同优先级的线程组成先进先出队列（先到先服务），应用工夫片策略2.对高优先级，应用优先调度的抢占式策略线程的优先级：
等级：MAX_PRIORITY:10MIN_PRIORITY:1NORM_PRIORITY:5办法：
getPriority():返回线程优先级setPriority(int newPriority):扭转线程的优先级留神：高优先级的线程要抢占低优先级的线程的cpu的执行权。不是肯定，仅是从概率上来说的，高优先级的线程更有可能被执行。并不意味着只有高优先级的线程执行完当前，低优先级的线程才执行。
六、线程分类？
1.守护线程（是服务线程，程序运行时在后盾提供的一种通用服务的线程，如垃圾回收线程，异样解决线程）2.用户线程（平时应用的用来解决逻辑的线程）若JVM中都是守护线程，以后JVM将退出。（形象了解，唇亡齿寒）七、其它
java virtual machine（JVM）：java虚拟机内存构造：