关于java:Java多线程学习笔记一-初遇篇

别后不知君远近。触目苍凉多少闷。渐行渐远渐无书，水阔鱼沉何处问。
夜深风竹敲秋韵。万叶千声皆是恨。故欹单枕梦中寻，梦又不成灯又烬。《玉楼春·别后不知君远近》欧阳修
最近挺喜爱的一首诗。

大学外面学过的《操作系统》和《计算机组成原理》、JVM，在多线程这一点无奈造成一个整体，就只是简略停留在会用，大略了解这个阶段，我是很不喜爱这种感觉，于是就打算重写学习一下线程，让本人的知识点成体系。

该何对待线程?

该如何对待线程呢？咱们还是须要先看过程，咱们来回顾一下操作系统的历史，在很久之前操作系统只能反对跑一个程序，也就是说你不能在听歌的时候，看文档。那个时候还没有过程这个概念，很快随着科学技术的倒退，咱们能够在内存中加载更多的程序，这个时候再用程序这个概念去涵盖运行中的程序就有点不适合了，因为有可能存在一个程序跑多份，因而咱们须要一个概念来形容运行中的程序，也就是过程。

在没有线程之前，过程是操作系统调度的根本单位，过程是一个具备肯定的独立性能的程序在一个数据汇合上的一次动静执行过程, 涵盖了程序执行所须要的的资源和执行流程。这么说可能有点形象，举一个例子，我写了一个求两个数中最大值的程序，接管两个数，而后输入最大值，这个就是执行流程。在没有线程之前，一个过程中只有一个执行流程。

咱们这里从两个方面来了解过程:

• 从资源组合的角度: 过程把一组相干的资源组合起来，形成了一个资源平台(环境)，包含地址空间(代码段、数据段)、关上的文件等各种资源、
• 从运行的角度: 代码在这个资源平台上的一条执行流程(线程)。

总结一下:

线程是过程外部的一条执行流程(开销比拟小)，再艰深一点就是干活的最小单元。

线程也不是只是齐全是执行流程，也须要肯定的耗费，也须要有本人独享的资源，Java 平台开启一个线程大抵须要耗费 1M 的内存。除此之外还有操作系统方面的开销，也就是咱们说的上下文切换。咱们晓得古代计算机上没有线程可能独占 CPU，线程占用 CPU 的工夫，咱们称之为工夫片，每个线程所能分到工夫片是十分小的，那么随之而来的问题就是线程中的执行流程执行了一半，工夫片耗尽了，CPU 去执行另一个线程了，那么再轮到这个线程时，咱们必定是不心愿再次重头执行的，这个时候零碎是保留了线程的执行进度的，咱们能够了解为存档，再执行到这个线程的时候，就会读档，这个读档的过程咱们个别称之为上下文切换。老是说我大学上操作系统课程的时候，过后这个代码量还比拟少，我还感觉这个概念比拟难以了解，起初写的代码多了，就忽然了解了，所以说程序是了解计算机的桥梁啊。

从零开始学习 Java 平台的线程

java 平台上的代码与线程

Java 中任何一段代码总是执行某个线程之中，执行以后代码的线程就被称为以后线程，这和咱们上文探讨的是统一的，即线程是过程外部的一条执行流程，干活的最小单元。Thread.currentThread()能够返回以后线程，Java 程序员十分相熟的 main 办法就是被 main 线程来执行。

public class ThreadDemo {public static void main(String[] args) {System.out.println(Thread.currentThread().getName());
    }
}

写到这里可能有同学会问呢，下面你不是说，线程是过程外部的一条执行流程嘛，那这么多线程都属于哪一个过程啊，当你启动 main 办法的时候事实上是启动了一个虚拟机过程。

public class ThreadDemo {public static void main(String[] args) throws InterruptedException {
        // 让 main 线程睡 10 秒, 不然 main 办法执行结束,JVM 过程也完结了
        // 这段代码是以后代码的执行线程沉睡 10 秒,main 办法被 main 线程所执行
        // 趁他沉睡, 咱们用工作管理器去查看后盾的过程
        TimeUnit.SECONDS.sleep(10);
    }
}

有同学可能会问，你不还没启动啊，为什么就会有两个 JVM 过程了啊，我应用 IDEA 是一个 java 语言编写的，他启动当然是一个 JVM 过程，通过形容咱们能够看到 IDEA 应用的是 Open JDK，另一个是被其余服务所应用，像 maven。
如果你不信的话，咱们上图

咱们启动了 ThreadDemo 之后，就会多出一个 java.exe,

如何创立一个线程

Java 平台下咱们该如何创立一个线程呢，或者说 main 办法中此时有一个执行单元 (就是一个办法) 比拟耗时，咱们心愿将这个比拟耗时的办法放入一个线程和 main 线程交替执行。一般来说 Java 平台下创立线程有两种形式:

• 创立一个类，继承 Thread 类，重写 Thread 类的 run 办法。
• 创立一个类，实现 Runnable 接口，重写接口中的 run 办法。

public class ThreadDemo01 extends Thread{
    // 咱们说的最小执行单元
    @Override
    public void run() {System.out.println("继承形式创立的线程");
        System.out.println("继承形式创立的线程"+"我是比拟耗时的操作.....");
    }
}

public class ThreadDemo02 implements Runnable {
    @Override
    public void run() {System.out.println("接口方式创立的线程");
        System.out.println("接口方式创立的线程"+"我是比拟耗时的操作.....");
    }
}

我确实创立了两个线程，此时这两个线程出于新建状态，那咱们该如何启动这两个线程呢？还是通过 Thread 类，假如是继承形式创立的线程，咱们间接在对应的代码，调用 start 办法即可。如果是接口方式创立的线程，那么就须要将这个执行单元当做参数传递给 Thread 的类，像上面这样:

 public static void main(String[] args) throws Exception {ThreadDemo01 thread01 = new ThreadDemo01();
        thread01.start();
        ThreadDemo02 threadDemo02 = new ThreadDemo02();
        Thread thread02 = new Thread(threadDemo02);
        thread02.start();}

通过 start()办法, 咱们启动了这个线程，然而启动就未必代表这个线程能够马上被执行，这取决线程调度器的调度，由操作系统所决定。由此咱们引出线程的生命周期状态，事实上咱们上文曾经暗示过了，执行流程的开始到完结。

线程的状态，都在图里了，一图胜千言:

下面曾经呈现了一些线程类罕用的 API，兴许你还不晓得用途是什么，不必放心，正是上面要介绍的。

Thread 类罕用的 API

演示:

ThreadDemo01 thread01 = new ThreadDemo01();
    thread01.start();
    // 礼让
    Thread.yield();
    // 主线程沉睡 10 秒
    TimeUnit.SECONDS.sleep(10);
    // 礼让
    // 这是主线程调用线程 thread01 的 join 办法, 那 thread01 运行结束, 主线程的代码才会继续执行。thread01.join();

线程两种创立形式的区别

从面向对象编程的角度来看: 创立 Thread 的子类是一种基于继承的技术, 以 Runnable 接口为实例为结构器参数间接通过 new 创立 Thread 实例是一种基于组合的技术。我记得在大学的《软件工程导论》课程中如同讲过慎用继承，继承毁坏封装来着，所以个别咱们举荐用过 Runnable 形式来创立线程，更为书面化的形容是组合绝对于继承来说，其类与类之间的耦合性更低，因而它也更加灵便。个别咱们咱们认为组合是优先选用的技术，也就是咱们常说的面向接口编程。

艰深的讲你用继承的形式创立线程，那这个类曾经根本和线程绑定了，不好复用。

用 Runnable 形式创立线程，从对象共享的角度来说，多个线程就能够同时执行这一个执行单元，而用第二种，假如你想多个线程多做这一件事，那你就得建多个类，这是很间接的益处。

Java 平台下不拘一格的线程

你可能曾经听过一些对于线程的名词了，父线程、子线程、垃圾回收线程等等，这里咱们将对这些名词进行对立的解释，以不便后文的探讨，
依照线程是否阻止 Java 虚拟机失常进行)，咱们能够将 Java 中的线程 (Daemon Thread) 和用户线程(User Thread, 也称为非守护线程)。咱们探讨的简略些，JVM 只有在其所有的用户线程都运行完结能力失常进行，即用户线程不执行完，JVM 不进行(咱们探讨的是比较简单的)，JVM 的垃圾回收线程就是一个守护线程，咱们这样想假如你写了一个简略的算法，没开线程，然而跑完了，垃圾回收线程还在跑，这不是很奇怪吗？

Java 平台中的线程不是孤立的，线程与线程之间器重存在一些分割。假如线程所执行的代码创立了线程 B，那么习惯上咱们称线程 B 为线程 A 的子线程，相应的咱们称线程 A 为线程 B 的父线程。

线程平安

计算机存储系统

咱们对线程的探讨也要落到硬件上，既要实践也要联系实际。

可能一些人的眼里，程序的执行是这样的，程序加载进内存，CPU 读取内存的指令执行，这是一个相当毛糙的模型，尽管内存的读写速度曾经很快了，可是绝对于 CPU 来说还是不够看，如果 CPU 间接从内存中加载指令并执行，那么计算机系统的效率绝对于当初来说会慢上几个量级，计算机的存储系统采取了更聪慧的设计，即在处理器和较大较慢的存储设备(比方内存(有材料称为主存，这两个是同义语))。实际上，每个计算机系统中的存储设备都被组织成了一个存储器层次结构，如下图所示。

在这个层次结构中，从上至下，设施的访问速度越来越慢，容量越来越大，并且每字节的造价越来越便宜。存储器的层次结构的次要思维就是上一层的存储器作为低一层存储器的高速缓存。

缓存不统一、处理器优化、指令重排简介

一般来说古代 CPU 都是多核的，你很难找到单核的 CPU, 咱们钻研的根本单位也是多核 CPU，CPU 始终在计算工作，咱们下面将线程视作一个执行单元，这个执行单元当被线程器调度器选中的时候，零碎会将该执行单元所需的资源从内存逐渐加载到 CPU 的寄存器中，一般来说典型的流程是依据存储构造，CPU 会先从寄存器找，找不到会从 L1 缓存，L1 找不到从 L2 缓存 ….。
计算结果最终会被写入到 L3 缓存，再由 L3 缓存移入内存中。假如是两个线程呢，共享一个变量，这就可能会呈现缓存不统一的状况，因为可能第一个线程在实现计算之后，还来得及将计算结果刷新到主存，另一个线程被调配到了另一个外围上执行，读取的还是还未更新的变量，这就是缓存不统一问题。

有同学可能会问单核 CPU 没有缓存不统一问题，那是不是在单核 CPU 上，多线程就是没问题的啊？单核 CPU 确实不会呈现缓存不统一的问题，CPU 将某块内存加载到缓存后，不同线程在拜访雷同的物理地址的时候，都会映射到雷同的缓存地位，这样即便产生线程的切换，缓存依然不会生效。然而回忆一下咱们下面探讨的上下文切换，线程 A 执行一半后，工夫片耗尽，线程外部的寄存器会保留现场，也就是咱们上文说的存档，后果还没从缓存中刷新到主存，只是暂存于线程外部。而后 B 线程开始执行，CPU 中顺次从缓存中加载共享变量，咱们权且假设线程 A 的计算结果还没刷新至缓存，而后线程 B 接着计算，仍然会存在问题。

下面提到的在 CPU 和主存之间减少缓存，在多核多线程的场景下会存在缓存一致性问题。除此之外为了减速程序的执行，个别的高级语言的编译器还会对程序对应的指令进行重排，编译器重排之后，CPU 为了减速执行也不肯定会按编译器重排后的指令按序执行，也就是乱序执行。乱序执行和乱序执行会牵扯到操作系统和硬件执行的常识，不是本篇探讨的重点，这两个点咱们目前只做简略介绍，前面会联合例子或者专门开一篇文章来讲。

缓存不统一、乱序执行、指令重排序各位可能会感到有些生疏，然而如果我说原子性、有序性、可见性可能各位就会相对来说相熟一点了，咱们将下面的缓存不统一、乱序执行、指令重排序形象进去就是原子性、有序性、可见性。
可能你还是有点懵，不过不必焦急，这三个概念咱们会联合例子，进行一一介绍。

原子性 与 可见性

上面是一个用两个线程买票的例子:

public class TicketSell implements Runnable {
    // 总共一百张票
    private int total = 2000;
    @Override
    public void run() {while (total > 0) {System.out.println(Thread.currentThread().getName() + "正在售卖:" + total--);

        }
    }
}

 public static void main(String[] args) {TicketSell ticketSell = new TicketSell();
        Thread a =  new Thread(ticketSell, "a");
        Thread b = new Thread(ticketSell, "b");
        a.start();
        b.start();}

运行后果截图:

先说一下，不同的操作系统调度机制不同，如果你运行和我一样的代码，跑不出和一样的后果，也在情理之中。兴许你的是呈现 a 和 b 都卖了 1998 这张票，兴许是其余的。一般来说咱们都会认为这是不失常的，因为咱们认为两个线程应该是合作干活，不应该呈现两个线程同时卖一张票的后果，为什么咱们会有这种想当然呢？咱们先不落实的具体的计算机上，咱们先将这个卖票放在事实场景来剖析，同样做一个比拟毛糙的假设，还没有平凡的程序员们为他们做售票零碎，是两个卖票员在一个房间里两个售票口，有一张桌子下面放了一堆票，有人来卖票员去桌子上看，还有没有票，有的话，将票递给乘客。

这其中其实就暗含了售票员在取票的时候是不能够被打断的，不存在说拿了一半这种状况，也就是原子性，还有就是售票员 A 在拿了一张票之后，售票员 B 再去拿票之后立马能看售票员拿票之后的后果，也就是可见性。咱们潜意识外面多线程共享一个变量的时候，拿票操作是原子性的，拿票之后，另一个线程也能马上可能看到上一个线程的操作后果。

下面的运行后果中呈现两个线程同时卖出第 2000 张票的起因就在于，尽管是两个线程共享两千张票，然而拿票过程是能够被打断的，比方 a 线程刚进来，读取到以后的票数，工夫片耗尽了，轮到 b 线程了，b 线程也进来开始读取以后的票数。在比方一个拿票动作，在线程看来分成三步，第一步读取票数(从内存中将变量加载到缓存中)、第二步 CPU 执行递增操作第三步将执行后的后果刷新到主存中，也是能够打断的。如果是多核 CPU，线程 a 执行完计算，线程 b 能够读取到该线程的更新后果，那么咱们就称这个线程对该共享变量的更新对其余线程可见。

Java 语言标准规定，父线程在启动子线程之前对共享变量的更新对于子线程来说是可见的。

有序性

绝对于原子性、可见性来说，有序性相对来说略微有点难以了解，因为有序性相对来说更面向机器，贴近硬件，难以被感知。
程序构造是结构化编程中的一种根本构造，它示意咱们心愿某个操作必须先于另外一个操作得以执行。另外两个操作即使是能够用任意一种程序执行，然而反馈在代码上两个操作也总是有先后顺序。然而在多核处理器的环境下，这种操作执行程序可能是没有保障的，编译器可能扭转两个操作的先后顺序；处理器可能不是齐全依照指标代码所指定的程序执行指令，另外，一个处理器上执行的多个操作，从其余处理器的角度来看其程序可能与指标代码指定的程序不统一。这种景象，咱们称之为重排序。

JIT 编译器简介

一图胜千言:

咱们晓得咱们的程序最终还是要被 CPU 执行的，一个 java 程序首先要变成字节码，而后被在运行的时候由 JIT(Just-In-Time)编译器将字节码翻译老本地机器代码，如果某段代码被调用的次数适度，也就是热点代码，JIT 编译器就会将该段代码翻译老本地代码并缓存起来，下次运行的时候就无须再翻译。
对于有序性的一个经典例子:

TicketSell ticketSell = new TicketSell();

产生对象通常状况下是三步:

1. 由 JVM 调配 TicketSell 实例所须要的的内存空间，并取得一个指向该空间的援用。

用伪码来示意就是 objRef = allocate(TicketSell.class);

1. 调用 TicketSell 类的构造函数初始化 objRef 援用指向的 TicketSell 实例。
2. 将 TicketSell 实例援用 objRef 赋值给实例变量 ticketSell

JIT 编译器(JVM 中负责将字节码解释成对应平台字节码的一个组件)，并不是每次都是按上述程序去生成对应的机器码，在产生对象比拟频繁的状况下，程序可能是 1,3,2。如果是这种状况调用的因为调用对应对象的办法可能就会呈现问题，认为对象还没有齐全被初始化。

《Java 多线程编程实战指南》的 JITReorderingDemo 就跑进去了指令重排序，从设计上来看非常的精美，用到了线程合作的常识，本篇咱们不讲线程同步与线程合作，相识篇 (我写博客个别雷同的主题大多都拆成三篇: 初遇、相识、甚欢) 讲，每一篇博客都有对应的主题，讲完线程同步和线程合作，会专门开一篇博客讲 JITReorderingDemo 的设计思维
下载地址如下:
http://www.broadview.com.cn/b…
事实上不仅能跑进去，咱们也能够通过一些工具看 JIT 编译器生成的机器码来证实，有一款工具叫 hsdis，下载地址如下:
https://github.com/liuzhengya…
有兴致的同学能够本人下载下来玩一玩。
我记得我之前在学习单例模式的时候，测试指令重排序，测不进去，起因可能在于并发还是有点小吧。

为了解决这些问题

为了解决线程平安问题，Java 在引入线程的同时也引入了线程同步机制:

• 锁(乐观锁、乐观锁、读写锁、显示锁)
• volatile 禁止重排序和保障可见性

为了让线程们之间更好的配合工作，Java 也引入一套相干类:

• wait/notify
• 条件变量
• 倒计时协调器(CountDownLatch)
• 栅栏(CyclicBarrier)
• 信号量
• 线程中断机制

总结一下

• 多线程的益处

不少多线程入门可能会通知你，引入多线程是为了充分利用多核处理器的资源，我认为这是一种谬误的说法，因为在没有多线程之间，多过程照样是并发执行的，照样也是充沛的利用了多核处理器的资源，我认为更间接的劣势是绝对于多过程，多线程共享变量更为简略，创立线程绝对于过程更节俭资源，这才是更间接的起因，我记得大学期间，学习操作系统的时候，也是将线程拎进去讲的。

• 如何对待线程

线程是一个执行单元，负责执行对应的工作，在没有线程之间，过程是最小的执行单元，在引入线程之后，过程的位置产生了变动，过程原来的执行逻辑被挪动到了线程身上，在没有线程之前，过程就像只有老板的公司，在有了线程之后，老板就将活转移到了打工人身上。

• Java 平台下如何创立线程

最根本的有两种: 继承 Thread，重写 run 办法，在 Runable 办法外面写你想委托线程做的事件。
实现 Runnable 接口，重写 run 办法，而后将 Runnable 实现类的实例当做参数传递给 Thread 类的构造函数

参考资料:

• 《Java 多线程编程实战指南》黄文海 著
• 再有人问你 Java 内存模型是什么，就把这篇文章发给他。
• 启动一个最简略的 Java main 程序时，有多少个线程被创立
• cpu 缓存与多线程
• Java 线程和操作系统线程的关系
• 如何通俗易懂地介绍「即时编译」（JIT），它的长处和毛病是什么？
• 操作系统_清华大学(向勇、陈渝)