目录
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.非动态的同步办法，同步监视器是this
3、动态的同步办法，同步监视器是以后类自身。继承自Thread.class2、Lock类
lock: 在java.util.concurrent包内。共有三个实现：
1、ReentrantLock
2、ReentrantReadWriteLock.ReadLock
3、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指令是一个原子性操作。
五、线程是如何调度的呢？
调度策略：
工夫片：线程的调度采纳工夫片轮转的形式
抢占式：高优先级的线程抢占CPU
Java的调度办法：
1.对于同优先级的线程组成先进先出队列（先到先服务），应用工夫片策略
2.对高优先级，应用优先调度的抢占式策略
线程的优先级：
等级：
MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5办法：
getPriority():返回线程优先级
setPriority(int newPriority):扭转线程的优先级
留神：高优先级的线程要抢占低优先级的线程的cpu的执行权。不是肯定，仅是从概率上来说的，高优先级的线程更有可能被执行。并不意味着只有高优先级的线程执行完当前，低优先级的线程才执行。
六、线程分类？
1.守护线程（是服务线程，程序运行时在后盾提供的一种通用服务的线程，如垃圾回收线程，异样解决线程）
2.用户线程（平时应用的用来解决逻辑的线程）
若JVM中都是守护线程，以后JVM将退出。（形象了解，唇亡齿寒）
七、其它
java virtual machine（JVM）：java虚拟机内存构造：
发表回复