JavaSE高级线程
- 主要内容
- 教学目标
第1章多线程
第2章线程安全
第3章线程状态
第4章线程池方式
第5章死锁
第6章可见性
第7章原子性
第8章指令重排
第9章并发包

JavaSE高级线程

单元测试每个方法之前加上注解@Test @Before//在每个方法前先走 @After//在test之后走。 test不能写键盘输入类 JavaSE高级线程 - 图1

主要内容

多线程
- 重点内容，设计到多线程的开发都显得有点难理解。
- 多线程是Java的经典技术之一。多线程是未来高并发技术的基石，也是基础
线程安全
volatile关键字
原子性
并发包
死锁
线程池

教学目标

说出进程的概念
- 进程是运行中的程序。
说出线程的概念
- 线程是属于进程的，一个进程可以包含多个线程。
能够理解并发与并行的区别
- 并发：是一堆线程来抢占CPU执行自己！！
- 并行：同时有多个线程执行！！
能够开启新线程
- 调用start()方法。
能够描述Java中多线程运行原理
- 并发执行，出现随机性。
能够使用继承类的方式创建多线程
a.定义一个线程类继承Thread类。 b.重写Thread类的run()方法 c.创建线程类的对象。 d.调用线程类对象的start()方法启动线程
能够使用实现接口的方式创建多线程
a.定义一个线程任务类实现Runnable接口。重写run()方法 b.创建一个线程任务对象 c.把线程任务对象包装成一个线程对象 — public Thread(Runnable target) d.调用线程对象的start()方法启动线程。
能够说出实现接口方式的好处
实现接口以后，线程任务对象可以继续继承其他类或者继续实现其他接口，以后的功能可以扩展。实现接口适合做线程池。适合做资源共享操作
能够说出volatile关键字的作用
- 实现成员变量多个线程修改后的可见性。
能够说明volatile关键字和synchronized关键字的区别
- volatile修饰成员变量，实现变量的访问可见性，但是不能实现原子性。
- synchronized可以修饰方法和代码块，加锁机制，可以实现线程安全。加锁以后变量自然可见。
能够理解原子类的工作机制
- 基于CAS乐观锁。保证了安全性。
能够掌握原子类AtomicInteger的使用
- private AtomicInteger atomicInteger = new AtomicInteger(); int count = atomicInteger.incrementAndGet(); // 底层变量+1且返回！
能够描述ConcurrentHashMap类的作用
- 安全性高，线程安全的，综合性能好。
能够描述CountDownLatch类的作用
能够描述CyclicBarrier类的作用
能够表述Semaphore类的作用
能够描述Exchanger类的作用
能够描述Java中线程池运行原理
能够描述死锁产生的原因

第1章多线程

我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计？要解决上述问题,咱们得使用多进程或者多线程来解决.

1.1 并发与并行

并行：指两个或多个事件在同一时刻发生（同时执行）。
并发：指两个或多个事件在同一个时间段内发生(交替执行)。//CPU的交替使用

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

1.2 线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

简而言之：一个程序中至少有一个进程，一个进程可以包含多个线程。进程 JavaSE高级线程 - 图2

线程 JavaSE高级线程 - 图3

进程与线程的区别

进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。
多线程并不能提高运行速度，但可以提高运行效率，让CPU的使用率更高。
并且，如果多线程有安全问题的处理时，运算速度反而更低。

注意：下面内容为了解知识点 1:因为一个进程中的多个线程是并发运行的，那么从微观角度看也是有先后顺序的，哪个线程执行完全取决于 CPU 的调度，程序员是干涉不了的。而这也就造成的多线程的随机性。 2:Java 程序的进程里面至少包含两个线程，主进程也就是 main()方法线程，另外一个是垃圾回收机制线程。每当使用 java 命令执行一个类时，实际上都会启动一个 JVM，每一个 JVM 实际上就是在操作系统中启动了一个线程，java 本身具备了垃圾的收集机制，所以在 Java 运行时至少会启动两个线程。 3:由于创建一个线程的开销比创建一个进程的开销小的多，那么我们在开发多任务运行的时候，通常考虑创建多线程，而不是创建多进程。

线程调度:

分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

1.3 Thread类

线程开启我们需要用到了java.lang.Thread类，API中该类中定义了有关线程的一些方法，具体如下： 构造方法：//非常有用

public Thread():分配一个新的线程对象。
public Thread(String name):分配一个指定名字的新的线程对象。
public Thread(Runnable target):分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。

常用方法：

- public String getName():获取当前线程名称。
public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run():此线程要执行的任务在此处定义代码。

//下面两个可以类名点来调用
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
调用start（）方法 run（）自动执行。
不起名字有默认Thread01 Thread02 ….

翻阅API后得知创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式，方式一我们上一天已经完成，接下来讲解方式二实现的方式。

三种方式，第三种几乎不用，所以说1,2种

继承Thread类创建线程实现Runnable接口创建线程利用匿名对象创建线程

1.4 创建线程方式一__继承方式

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

代码如下： 测试类： public class Demo01 { public static void main(String[] args) { //创建自定义线程对象 MyThread mt = new MyThread(“新的线程！”); //开启新线程 mt.start(); //在主方法中执行for循环 for (int i = 0; i < 200; i++) { System.out.println(“main线程！”+i); } } } 自定义线程类： public class MyThread extends Thread { //定义指定线程名称的构造方法 public MyThread(String name) { //调用父类的String参数的构造方法，指定线程的名称 super(name); } public MyThread() { //不指定线程的名字,线程有默认的名字Thread-0 } /**

 * 重写run方法，完成该线程执行的逻辑
 */
@Override
public void run() {
    for (int i = 0; i < 200; i++) {
        System.out.println(getName()+"：正在执行！"+i);
    }
}

}

1.5 创建线程的方式二__实现方式

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

代码如下： public class MyRunnable implements Runnable{ @Override public void run() { for (int i = 0; i < 20; i++) { System.out.println(Thread.currentThread().getName()+” “+i); } } } public class Demo { public static void main(String[] args) { //创建自定义类对象线程任务对象 MyRunnable mr = new MyRunnable(); //创建线程对象 Thread t = new Thread(mr, “小强”); t.start(); for (int i = 0; i < 20; i++) { System.out.println(“旺财 “ + i); } } } 通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。 tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

Thread和Runnable的区别 总结： 实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程。

1.6 匿名内部类方式

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法： public class NoNameInnerClassThread { public static void main(String[] args) {
// new Runnable(){ // public void run(){ // for (int i = 0; i < 20; i++) { // System.out.println(“张宇:”+i); // } // }
// }; //—-这个整体相当于new MyRunnable()

    Runnable r = new Runnable(){
        public void run(){
            for (int i = 0; i < 20; i++) {
                  System.out.println("张宇:"+i);
            }
        }  
    };
    //将那一个整体赋值给r
    new Thread(r).start();
    for (int i = 0; i < 20; i++) {
          System.out.println("费玉清:"+i);
    }
   }

}

public class AnnoymousInnerClass { public static void main(String[] args) { /Thread t =new Thread() { @Override public void run() { super.run(); for (int i=0;i<10;i++) { System.out.println(Thread.currentThread().getName()+”实现”+i); } } }; t.setName(“junjun”); t.start(); }/ //彻底匿名的类型 new Thread() { @Override public void run() { super.run(); for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName() + “实现” + i); } } }.start(); }

}

public class RunnableAnnoymous { public static void main(String[] args) { /Thread t =new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 10; i++) System.out.println(Thread.currentThread().getName() + “实现” + i); } }); t.setName(“lili”); t.start();/ //彻底匿名的类型 new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 10; i++) System.out.println(Thread.currentThread().getName() + “实现” + i); } }).start(); } }

public class Aim { public static void main(String[] args) { Thread t =new Thread(() -> { for (int i = 0; i < 10; i++) System.out.println(Thread.currentThread().getName() + “实现” + i); }); t.setName(“lili”); t.start(); /new Thread(() -> { for (int i = 0; i < 10; i++) System.out.println(Thread.currentThread().getName() + “实现” + i); }).start();/ } }

1.7 两种创建线程方式的比较

继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现Runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。 Runnable接口对线程对象和线程任务进行解耦。 A：第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。 B：实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。 JavaSE高级线程 - 图5

1.8 练习线程+集合

1.得到一个随机的整数n，创建n个子线程对象； 2.要求在子线程中把当前线程的名称作为元素添加一个集合中； 3.当n个线程的名称都添加到集合中，遍历集合打印每个线程的名称； JavaSE高级线程 - 图6

package 日期4月14日作业;

import java.util.ArrayList; import java.util.Random;

public class ThreadAndArray { public static void main(String[] args) { Random ra = new Random(); int n = ra.nextInt(10) + 1; MyRunnable mr = new MyRunnable(n); for (int i = 0; i <= n; i++) { new Thread(mr, “线程” + i).start();

}
}

} class MyRunnable implements Runnable{//两个类是并列的 //private int currentIndex; private ArrayList list =new ArrayList();//成员属性是一个集合 private int n; public MyRunnable(int n)//含有一个参数的构造函数，给n赋值 { this.n =n; } @Override public void run() { list.add(Thread.currentThread().getName()); n—; if(n==0) { //集合中的元素添加完毕 /for (String s:list) { System.out.println(s); }/ // list.forEach(System.out::println); list.forEach(System.out::println);//原始 //由Lambda替换后为上 } } }

/* 结果：线程0 线程1 线程2 线程3 线程4 线程5 线程6

    进程已结束，退出代码 0

本次程序学到了输出Lambda表达式，用来遍历List集合 */

守护线程：

当进程中只剩下守护线程时，所有的守护线程强制终止 setDaemon(boolean on) on =true 时是守护线程 isDaemon（）测试这个线程是否是守护线程 main方法是守护线程测试守护线程要求 1使用内部类创建线程d，实现线程每隔一秒输出字符串“后台线程” 2，设置d为守护线程，并启动该线程 3，让main方法阻塞5秒，然后输出字符串“main方法结束啦’’ public class Daemon { public static void main(String[] args) { Thread d =new Thread(){ @Override public void run() { super.run(); System.out.println(“后台进程”); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }; d.setDaemon(true); d.start(); try { Thread.sleep(5000); System.out.println(“主线程结束啦”); } catch (InterruptedException e) { e.printStackTrace(); } } } /* 后台进程主线程结束啦

进程已结束，退出代码 0*/ JavaSE高级线程 - 图7

Join方法，加入到另一个线程里，一般t1.join(),t1执行完后t2才会执行

package ThroughHill;

public class PicDown { public static void main(String[] args) { Thread t1= new Thread(){ @Override public void run() { super.run(); //输出下载百分比 for (int i = 0; i <10 ; i++) { System.out.println(“t1：正在下载图片”+i*10+”%”); //每次下载10%暂停1秒 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }

            }
            //t1 完成
            System.out.println("t1:下载完成");
        }
    };
    Thread t2 =new Thread(){
        @Override
        public void run() {
            System.out.println("t2：等图片下载完毕");
            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t2:显示图片");
        }
    };
    t1.start();
    t2.start();
}

} /*

t2：等图片下载完毕 t1：正在下载图片0% t1：正在下载图片10% t1：正在下载图片20% t1：正在下载图片30% t1：正在下载图片40% t1：正在下载图片50% t1：正在下载图片60% t1：正在下载图片70% t1：正在下载图片80% t1：正在下载图片90% t1:下载完成 t2:显示图片

进程已结束，退出代码 0 */

第2章线程安全

2.1 线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。我们通过一个案例，演示线程的安全问题：电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)，需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟。//居然常用的是这个 模拟票： public class Ticket implements Runnable { private int ticket = 100; /*

 * 执行卖票操作
 */
@Override
public void run() {
    //每个窗口卖票的操作 
    //窗口 永远开启 
    while (true) {
        if (ticket > 0) {//有票 可以卖
            //出票操作
            //使用sleep模拟一下出票时间 
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //获取当前线程对象的名字 
            String name = Thread.currentThread().getName();
            System.out.println(name + "正在卖:" + ticket--);
        }
    }
}

} 测试类： public class Demo { public static void main(String[] args) { //创建线程任务对象 Ticket ticket = new Ticket(); //创建三个窗口对象 Thread t1 = new Thread(ticket, “窗口1”); Thread t2 = new Thread(ticket, “窗口2”); Thread t3 = new Thread(ticket, “窗口3”);

    //同时卖票
    t1.start();
    t2.start();
    t3.start();
}

} 结果中有一部分这样现象： JavaSE高级线程 - 图8

发现程序出现了两个问题：

相同的票数,比如5这张票被卖了两回。
不存在的票，比如0票与-1票，是不存在的。

这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

2.2 线程同步

线程同步是为了解决线程安全问题。当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。根据案例简述：窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。那么怎么去使用呢？ 有三种方式完成同步操作：

同步代码块。
同步方法。
锁机制。

2.3 同步代码块

同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式: synchronized(同步锁){ 需要同步操作的代码 }

同步锁: 对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

锁对象可以是任意类型。
多个线程对象要使用同一把锁。

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

使用同步代码块解决代码： public class Ticket implements Runnable{ private int ticket = 100;

Object lock = new Object();
/*
 * 执行卖票操作
 */
@Override
public void run() {
    //每个窗口卖票的操作 
    //窗口 永远开启 
    while(true){
        synchronized (lock) {
            if(ticket>0){//有票 可以卖
                //出票操作
                //使用sleep模拟一下出票时间 
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //获取当前线程对象的名字 
                String name = Thread.currentThread().getName();
                System.out.println(name+"正在卖:"+ticket--);
            }
        }
    }
}

} 当使用了同步代码块后，上述的线程的安全问题，解决了。

2.4 同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式： public synchronized void method(){ 可能会产生线程安全问题的代码 } 同步锁是谁? 对于非static方法,同步锁就是this。//什么东西垃圾对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

使用同步方法代码如下： public class Ticket implements Runnable{ private int ticket = 100; /*

 * 执行卖票操作
 */
@Override
public void run() {
    //每个窗口卖票的操作 
    //窗口 永远开启 
    while(true){
        sellTicket();
    }
}
/*
 * 锁对象 是 谁调用这个方法 就是谁 
 *   隐含 锁对象 就是  this
 *    
 */
public synchronized void sellTicket(){
    if(ticket>0){//有票 可以卖    
        //出票操作
        //使用sleep模拟一下出票时间 
        try {
              Thread.sleep(100);
        } catch (InterruptedException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
        }
        //获取当前线程对象的名字 
        String name = Thread.currentThread().getName();
        System.out.println(name+"正在卖:"+ticket--);
    }
}

}

2.5 Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大 JavaSE高级线程 - 图9

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock():加同步锁。
public void unlock():释放同步锁。

使用如下： public class Ticket implements Runnable{ private int ticket = 100;

Lock lock = new ReentrantLock();
/*
 * 执行卖票操作
 */
@Override
public void run() {
    //每个窗口卖票的操作 
    //窗口 永远开启 
    while(true){
        lock.lock();
        if(ticket>0){//有票 可以卖
            //出票操作 
            //使用sleep模拟一下出票时间 
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //获取当前线程对象的名字 
            String name = Thread.currentThread().getName();
            System.out.println(name+"正在卖:"+ticket--);
        }
        lock.unlock();
    }
}

}

第3章线程状态

3.1 线程状态概述

线程由生到死的完整过程： 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中java.lang.Thread.State这个枚举中给出了六种线程状态：这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析

线程状态	导致状态发生条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread只有线程对象，没有线程特征。
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。调用了t.start()方法：就绪（经典叫法）
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

JavaSE高级线程 - 图10

我们不需要去研究这几种状态的实现原理，我们只需知道在做线程操作中存在这样的状态。那我们怎么去理解这几个状态呢，新建与被终止还是很容易理解的，我们就研究一下线程从Runnable（可运行）状态与非运行状态之间的转换问题。 JavaSE高级线程 - 图11

3.2 睡眠sleep方法

我们看到状态中有一个状态叫做计时等待，可以通过Thread类的方法来进行演示. public static void sleep(long time) 让当前线程进入到睡眠状态，到毫秒后自动醒来继续执行 public class Test{ public static void main(String[] args){ for(int i = 1;i<=5;i++){ Thread.sleep(1000); System.out.println(i)
} } } 这时我们发现主线程执行到sleep方法会休眠1秒后再继续执行。

3.3 等待和唤醒

Object类的方法 public void wait() : 让当前线程进入到等待状态此方法必须锁对象调用. public class Demo1_wait { public static void main(String[] args) throws InterruptedException { // 步骤1 : 子线程开启,进入无限等待状态, 没有被唤醒,无法继续运行. new Thread(() -> { try { System.out.println(“begin wait ….”); synchronized (“”) { “”.wait(); } System.out.println(“over”); } catch (Exception e) { } }).start(); }

public void notify() : 唤醒当前锁对象上等待状态的线程此方法必须锁对象调用. public class Demo2_notify { public static void main(String[] args) throws InterruptedException { // 步骤1 : 子线程开启,进入无限等待状态, 没有被唤醒,无法继续运行. new Thread(() -> { try {

            System.out.println("begin wait ....");
            synchronized ("") {
                "".wait();
            }
            System.out.println("over");
        } catch (Exception e) {
        }
    }).start();
    //步骤2:  加入如下代码后, 3秒后,会执行notify方法, 唤醒wait中线程.
    Thread.sleep(3000);
    new Thread(() -> {
        try {
            synchronized ("") {
                System.out.println("唤醒");
                "".notify();
            }
        } catch (Exception e) {
        }
    }).start();
}

}

3.4 等待唤醒案例（包子铺卖包子）

定义一个集合，包子铺线程完成生产包子，包子添加到集合中；吃货线程完成购买包子，包子从集合中移除。

当包子没有时（包子状态为false），吃货线程等待.

包子铺线程生产包子（即包子状态为true），并通知吃货线程（解除吃货的等待状态） 代码示例： 生成包子类： public class BaoZiPu extends Thread{ private List list ;

public BaoZiPu(String name,ArrayList list){

 super(name);
 this.list = list;

}

@Override public void run() {

 int i = 0; 
 while(true){
     //list作为锁对象
     synchronized (list){
         if(list.size()>0){
             //存元素的线程进入到等待状态
             try {
                 list.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         //如果线程没进入到等待状态 说明集合中没有元素
         //向集合中添加元素
         list.add("包子"+i++);
         System.out.println(list);
         //集合中已经有元素了 唤醒获取元素的线程
         list.notify();
     }
 }

} } 消费包子类： public class ChiHuo extends Thread {

private List list ;

public ChiHuo(String name,ArrayList list){

 super(name);
 this.list = list;

}

@Override public void run() {

 //为了能看到效果 写个死循环
 while(true){
     //由于使用的同一个集合 list作为锁对象
     synchronized (list){
         //如果集合中没有元素，获取元素的线程进入到等待状态
         if(list.size()==0){
             try {
                 list.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         //如果集合中有元素 则获取元素的线程获取元素(删除)
         list.remove(0);
         //打印集合 集合中没有元素了
         System.out.println(list);
         //集合中已经没有元素 则唤醒添加元素的线程 向集合中添加元素
         list.notify();
     }
 }

} } 测试类： public class Demo { public static void main(String[] args) {

 //等待唤醒案例
 List<String> list = new ArrayList<>();
 // 创建线程对象        
  BaoZiPu bzp = new BaoZiPu("包子铺",list);
 ChiHuo ch = new ChiHuo("吃货",list);
 // 开启线程
 bzp.start();
 ch.start();

} }

第4章线程池方式

4.1 线程池的思想

JavaSE高级线程 - 图12

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间，线程也属于宝贵的系统资源。那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？在Java中可以通过线程池来达到这样的效果。今天我们就来详细讲解一下Java的线程池。 JavaSE高级线程 - 图13

一 .简介线程的使用在java中占有极其重要的地位，在jdk1.4极其之前的jdk版本中，关于线程池的使用是极其简陋的。在jdk1.5之后这一情况有了很大的改观。Jdk1.5之后加入了java.util.concurrent包，这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助。

二.线程池 1.线程池的作用：线程池作用就是限制系统中执行线程的数量。根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待任务，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

2.为什么要用线程池: 1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。 2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。 Java里面线程池的顶级接口是Executors，严格意义上讲Executors并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口ExecutorService。

3.比较重要的几个类： ExecutorService 真正的线程池接口。 ScheduledExecutorService 能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。 ThreadPoolExecutor ExecutorService的默认实现。 ScheduledThreadPoolExecutor 继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

newSingleThreadExecutor 创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
newFixedThreadPool 创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
newCachedThreadPool 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程, 那么会回收部分空闲（60秒不执行任务）的线程，当任务数增加时, 此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
newScheduledThreadPool 创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

4.2 线程池概念

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
我们详细的解释一下为什么要使用线程池？在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。

由于线程池中有很多操作都是与优化资源相关的，我们在这里就不多赘述。我们通过一张图来了解线程池的工作原理：

合理利用线程池能够带来三个好处：

降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
4.3 线程池的使用
Java里面线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService。要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。 Executors类中有个创建线程池的方法如下：

public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：

public Future<?> submit(Runnable task):获取线程池中的某一个线程对象，并执行
Future接口：用来记录线程任务执行完毕后产生的结果。

使用线程池中线程对象的步骤：通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。 A：Executors：线程池创建工厂类 public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象 B：ExecutorService：线程池类 Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行 Future接口：用来记录线程任务执行完毕后产生的结果。 C：使用线程池中线程对象的步骤（线程池创建与使用）：创建线程池对象创建Runnable接口实现类对象提交Runnable接口实现类对象关闭线程池

创建线程池对象。
创建Runnable接口子类对象。(task)
提交Runnable接口子类对象。(take task)
关闭线程池(一般不做)。

package com.igeek.thread;

import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future;

/**

线程池测试类 */ public class ThreadPoolDemo { public static void main(String[] args) throws ExecutionException, InterruptedException {

 //获取一个线程池,返回固定线程数量的线程池
 ExecutorService threadPool = Executors.newFixedThreadPool(5);//最新固定的线程
 //创建线程执行目标
 TicketRunnable tr = new TicketRunnable();
 //向线程池提交任务
 threadPool.submit(tr);//可以使用匿名对象方式   threadPool.submit(new TicketRunnable());
 threadPool.submit(tr);
 threadPool.submit(tr);
 threadPool.submit(tr);
 Future<?>  future = threadPool.submit(tr);
 //Runnable没有返回值的run方法，所以返回null
 System.out.println(future.get());//null
 System.out.println("=======================");
 //测试Callable的call()
 //创建MyCallable的执行目标
 MyCallable mc= new MyCallable();
 //向线程池提交任务
 Future<?>  future_c =  threadPool.submit(mc);
 //因为Callable中的call是有返回值的，执行线程任务后会返回具体值
 System.out.println(future_c.get());
 //关闭线程池
 // threadPool.shutdown();

} }

Runnable和Callable的区别

Runnable没有返回值 Callable：中的call方法有返回值，执行线程任务后会返回具体的值。 Runnable实现类代码：

public class MyRunnable implements Runnable { @Override public void run() { System.out.println(“我要一个教练”); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(“教练来了： “ + Thread.currentThread().getName()); System.out.println(“教我游泳,交完后，教练回到了游泳池”); } } 线程池测试类： public class ThreadPoolDemo { public static void main(String[] args) { // 创建线程池对象 ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象 // 创建Runnable实例对象 MyRunnable r = new MyRunnable();

    //自己创建线程对象的方式
    // Thread t = new Thread(r);
    // t.start(); ---> 调用MyRunnable中的run()
    // 从线程池中获取线程对象,然后调用MyRunnable中的run()
    service.submit(r);
    // 再获取个线程对象，调用MyRunnable中的run()
    service.submit(r);
    service.submit(r);
    // 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
    // 将使用完的线程又归还到了线程池中
    // 关闭线程池
    //service.shutdown();
}

} 结果：我要一个教练我要一个教练我要一个教练教练来了：pool-1-thread-3 教完后，教练回到游泳池里了教练来了：pool-1-thread-2 教完后，教练回到游泳池里了教练来了：pool-1-thread-1 教完后，教练回到游泳池里了 Callable测试代码:

Future submit(Callable task) : 获取线程池中的某一个线程对象，并执行.
Future : 表示计算的结果.
V get() : 获取计算完成的结果。

public class ThreadPoolDemo2 { public static void main(String[] args) throws Exception { // 创建线程池对象 ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象

    // 创建Runnable实例对象
    Callable<Double> c = new Callable<Double>() {
        @Override
        public Double call() throws Exception {
            return Math.random();
        }
    };
    // 从线程池中获取线程对象,然后调用Callable中的call()
    Future<Double> f1 = service.submit(c);
    // Futur 调用get() 获取运算结果
    System.out.println(f1.get());
    Future<Double> f2 = service.submit(c);
    System.out.println(f2.get());
    Future<Double> f3 = service.submit(c);
    System.out.println(f3.get());
}

}

结果： 0.8454934271144806 0.8703967714531208 0.44133560739591804

4.4 线程池的练习

需求: 使用线程池方式执行任务,返回1-n的和 分析: 因为需要返回求和结果,所以使用Callable方式的任务 代码: public class Demo04 { public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService pool = Executors.newFixedThreadPool(3);

    SumCallable sc = new SumCallable(100);
    Future<Integer> fu = pool.submit(sc);
    Integer integer = fu.get();
    System.out.println("结果: " + integer);
    SumCallable sc2 = new SumCallable(200);
    Future<Integer> fu2 = pool.submit(sc2);
    Integer integer2 = fu2.get();
    System.out.println("结果: " + integer2);
    pool.shutdown();
}

}

SumCallable.java public class SumCallable implements Callable {//Callable 是一个接口 private int n; //执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。 FutureTask 是 Future 接口的实现类 //自己定义一个返回值李俊 public SumCallable(int n) { this.n = n; }

@Override
public Integer call() throws Exception {
    // 求1-n的和?
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        sum += i;
    }
    return sum;
}

} Callable 和 Future接口的区别（1）Callable规定的方法是call()，而Runnable规定的方法是run(). （2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
（3）call()方法可抛出异常，而run()方法是不能抛出异常的。（4）运行Callable任务可拿到一个Future对象， Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。 Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务

第5章死锁

5.1 什么是死锁

在多线程程序中,使用了多把锁,造成线程之间相互等待.程序不往下走了。

5.2 产生死锁的条件

1.有多把锁 2.有多个线程 3.有同步代码块嵌套

5.3 死锁代码

public class Demo05 { public static void main(String[] args) { MyRunnable mr = new MyRunnable();

    new Thread(mr).start();
    new Thread(mr).start();
}

}

class MyRunnable implements Runnable { Object objA = new Object(); Object objB = new Object();

/*
嵌套1 objA
嵌套1 objB
嵌套2 objB
嵌套1 objA
 */
@Override
public void run() {
    synchronized (objA) {
        System.out.println("嵌套1 objA");
        synchronized (objB) {// t2, objA, 拿不到B锁,等待
            System.out.println("嵌套1 objB");
        }
    }
    synchronized (objB) {
        System.out.println("嵌套2 objB");
        synchronized (objA) {// t1 , objB, 拿不到A锁,等待
            System.out.println("嵌套2 objA");
        }
    }
}

} 注意:我们应该尽量避免死锁 死锁的原因和解决办法 1.多线程并发访问资源，相互持有对方的资源 2.同步代码块嵌套Synchronized 如何解决死锁 1，尽量不要使用Synchronized代码块嵌套 2，不要互持对方资源

注意Sleep（)是不会释放对象锁

第6章可见性

6.1 看程序说结果

public class VolatileThread extends Thread {

// 定义成员变量
private boolean flag = false ;
public boolean isFlag() { 
    return flag;
}
@Override
public void run() {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 将flag的值更改为true
    this.flag = true ;
    System.out.println("flag=" + flag);
}

}

public class VolatileThreadDemo {// 测试类

public static void main(String[] args) {
    // 创建VolatileThread线程对象
    VolatileThread volatileThread = new VolatileThread() ;
    volatileThread.start();
    // main方法
    while(true) {
        if(volatileThread.isFlag()) {
            System.out.println("执行了======");
        }
    }
}

} 结果： JavaSE高级线程 - 图14

我们看到，VolatileThread线程中已经将flag设置为true，但main()方法中始终没有读到，从而没有打印。

6.2 JMM

概述：JMM(Java Memory Model) Java内存模型，是java虚拟机规范中所定义的一种内存模型。 Java内存模型(Java Memory Model)描述了Java程序中各种变量(线程共享变量)的访问规则，以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节。 所有的共享变量都存储于主内存。这里所说的变量指的是实例变量和类变量。不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。 每一个线程还存在自己的工作内存，线程的工作内存，保留了被线程使用的变量的工作副本。线程对变量的所有的操作(读，取)都必须在工作内存中完成，而不能直接读写主内存中的变量，不同线程之间也不能直接访问对方工作内存中的变量，线程间变量的值的传递需要通过主内存完成。 JavaSE高级线程 - 图15

关于JMM的一些同步的约定： 1.线程解锁前，必须把共享变量立刻刷回主存 2.线程加锁前，必须读取主存中的最新值到工作内存中 3.加锁和解锁是同一把锁

6.3 问题分析

JavaSE高级线程 - 图16

VolatileThread线程从主内存读取到数据放入其对应的工作内存
将flag的值更改为true，但是这个时候flag的值还没有写回主内存
此时main方法读取到了flag的值为false
当VolatileThread线程将flag的值写回去后，但是main函数里面的while(true)调用的是系统比较底层的代码，速度快，快到没有时间再去读取主存中的值，所以while(true)读取到的值一直是false。(如果有一个时刻main线程从主内存中读取到了主内存中flag的最新值，那么if语句就可以执行，main线程何时从主内存中读取最新的值，我们无法控制)

引发：多个线程访问共享变量，会出现一个线程修改变量的值后，其他线程看不到变量最新值的情况。总结：并发编程下，多线程修改变量，会出现线程间变量的不可见性。不可见性原因：每个线程都有自己的工作内存，线程都是从主内存拷贝共享变量的副本值。每个线程都是在自己的工作内存中操作共享变量的。

6.4 问题处理

方式一：加锁synchronized

使用synchronized关键字： // main方法 while(true) { synchronized (volatileThread) { if(volatileThread.isFlag()) { System.out.println(“执行了======”); } } } 工作原理： 某一个线程进入synchronized代码块前后，执行过程入如下： a.线程获得锁 b.清空工作内存 c.从主内存拷贝共享变量最新的值到工作内存成为副本 d.执行代码 e.将修改后的副本的值刷新回主内存中 f.线程释放锁

方式二：volatile关键字

使用volatile关键字： private volatile boolean flag ; 工作原理： JavaSE高级线程 - 图17

1.VolatileThread线程从主内存读取到数据放入其对应的工作内存中 2.将flag的值更改为true，但是这个时候flag的值还没有写回主内存 3.此时main方法main方法读取到了flag的值为false 4.当VolatileThread线程将flag的值写回去后，失效其他线程对此变量副本 5.再次对flag进行操作的时候线程会从主内存读取最新的值，放入到工作内存中

总结： volatile保证不同线程对共享变量操作的可见性，也就是说一个线程修改了volatile修饰的变量，当修改写回主内存时，另外一个线程立即看到最新的值。

现象：并发编程下，多线程修改变量，会出现线程间变量的不可见性。解决线程间变量的不可见性的方案有两种常见方式： 1.加锁解决原因：会清空工作内存，读取主内存中最新值到工作内存中来。 2.对共享的变量进行volatile关键字修饰解决原因：一旦一个线程中的变量，添加了volatile修饰符，其它线程可以立即读取到最新值

6.5 volatile与synchronized的区别

1).volatile只能修饰实例变量和类变量，而synchronized可以修饰方法，以及代码块。 2).volatile保证数据的可见性，但是不保证原子性(即：多线程进行写操作，不保证线程安全)；而synchronized是一种排他（互斥）的机制，实现线程安全。 3).从性能上说，volatile更好点，仅仅是对实现线程间变量的可见性上。

JavaSE高级线程 - 图18

第7章原子性

概述：所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行。

7.1 看程序说结果

public class VolatileAtomicThread1 implements Runnable { // 定义一个int类型的遍历 private int count = 0 ;

@Override
public void run() {
    // 对该变量进行++操作，100次
    for(int x = 1 ; x <= 100 ; x++) {
        count++ ;                    
        System.out.println("count =========>>>> " + count);
    }
}

}

public class VolatileAtomicThreadDemo1 {

public static void main(String[] args) {
    // 创建VolatileAtomicThread对象
    VolatileAtomicThread1 volatileAtomicThread = new VolatileAtomicThread1() ;
    // 开启100个线程对count进行++操作
    for(int x = 1 ; x <= 100 ; x++) {
        new Thread(volatileAtomicThread).start();
    }
}

} 执行结果：不保证一定是10000

7.2 问题原理说明

以上问题主要是发生在count++操作上： count++操作包含3个步骤：

从主内存中读取数据到工作内存
对工作内存中的数据进行++操作
将工作内存中的数据写回到主内存

count++操作不是一个原子性操作，也就是说在某一个时刻对某一个操作的执行，有可能被其他的线程打断。 JavaSE高级线程 - 图19

1）假设此时x的值是100，线程A需要对改变量进行自增1的操作，首先它需要从主内存中读取变量x的值。由于CPU的切换关系，此时CPU的执行权被切换到了B线程。A线程就处于就绪状态，B线程处于运行状态。 2）线程B也需要从主内存中读取x变量的值,由于线程A没有对x值做任何修改因此此时B读取到的数据还是100。 3）线程B工作内存中x执行了+1操作，但是未刷新到主内存中。 4）此时CPU的执行权切换到了A线程上，由于此时线程B没有将工作内存中的数据刷新到主内存，因此A线程工作内存中的变量值还是100，没有失效。A线程对工作内存中的数据进行了+1操作。 5）线程B将101写入到主内存。 6）线程A将101写入到主内存。虽然计算了2次，但是只对A进行了1次修改。

7.3 volatile原子性测试

代码测试

// 定义一个int类型的变量 private volatile int count = 0 ; 小结：在多线程环境下，volatile关键字可以保证共享数据的可见性，但是并不能保证对数据操作的原子性（在多线程环境下volatile修饰的变量也是线程不安全的）。在多线程环境下，要保证数据的安全性，我们还需要使用锁机制。

volatile的使用场景

开关控制
利用可见性特点，控制某一段代码执行或者关闭(比如今天课程的第一个案例)。
多个线程操作共享变量，但是是有一个线程对其进行写操作，其他的线程都是读

7.4 问题解决

方式一：使用锁机制synchronized

我们可以给count++操作添加锁，那么count++操作就是临界区的代码，临界区只能有一个线程去执行，所以count++就变成了原子操作。 public class VolatileAtomicThread2 implements Runnable { // 定义一个int类型的变量 private volatile int count = 0 ; private static final Object obj = new Object();

@Override
public void run() {
    // 对该变量进行++操作，100次
    for(int x = 1 ; x <= 100 ; x++) {
        synchronized (obj) {
            count++ ;
            System.out.println("count =========>>>> " + count);
        }
    }
}

}

public class VolatileAtomicThreadDemo2 {

public static void main(String[] args) {
    // 创建VolatileAtomicThread对象
    VolatileAtomicThread2 volatileAtomicThread = new VolatileAtomicThread2() ;
    // 开启100个线程对count进行++操作
    for(int x = 1 ; x <= 100 ; x++) {
        new Thread(volatileAtomicThread).start();
    }
}

}

方式二：原子类

Java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。

AtomicInteger

原子型Integer，可以实现原子更新操作 public AtomicInteger()：初始化一个默认值为0的原子型Integer public AtomicInteger(int initialValue)：初始化一个指定值的原子型Integer

int get(): 获取值 int getAndIncrement(): 以原子方式将当前值加1，注意，这里返回的是自增前的值。 int incrementAndGet(): 以原子方式将当前值加1，注意，这里返回的是自增后的值。 int addAndGet(int data): 以原子方式将输入的数值与实例中的值（AtomicInteger里的 value）相加，并返回结果。 int getAndSet(int value): 以原子方式设置为newValue的值，并返回旧值。

案例改造

使用AtomicInteger对案例进行改造. public class VolatileAtomicThread3 implements Runnable { // 定义一个int类型的变量 private AtomicInteger atomicInteger = new AtomicInteger() ;

@Override
public void run() {
    // 对该变量进行++操作，100次
    for(int x = 1; x <= 100 ; x++) {
        int i = atomicInteger.getAndIncrement();
        System.out.println("count =========>>>> " + i);
    }
}

}

public class VolatileAtomicThreadDemo3 { public static void main(String[] args) { // 创建VolatileAtomicThread对象 VolatileAtomicThread3 volatileAtomicThread = new VolatileAtomicThread3() ;

    // 开启100个线程对count进行++操作
    for(int x = 1 ; x <= 100 ; x++) {
        new Thread(volatileAtomicThread).start();
    }
}

}

7.5 原子类CAS机制实现线程安全

7.5.1 概述

JavaSE高级线程 - 图20

CAS的全称是： Compare And Swap(比较再交换)；是现代CPU广泛支持的一种对内存中的共享数据进行操作的一种特殊指令。 CAS可以将read-modify-check-write转换为原子操作，这个原子操作直接由处理器保证。 CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。

举例：

在内存地址V当中，存储着值为10的变量。

JavaSE高级线程 - 图21

此时线程1想要把变量的值增加1。对线程1来说，旧的预期值A=10，要修改的新值B=11。

JavaSE高级线程 - 图22

在线程1要提交更新之前，另一个线程2抢先一步，把内存地址V中的变量值率先更新成了11。

JavaSE高级线程 - 图23

线程1开始提交更新，首先进行A和地址V的实际值比较（Compare），发现A不等于V的实际值，提交失败。

JavaSE高级线程 - 图24

线程1重新获取内存地址V的当前值，并重新计算想要修改的新值。此时对线程1来说，A=11，B=12。这个重新尝试的过程被称为自旋。

JavaSE高级线程 - 图25

这一次比较幸运，没有其他线程改变地址V的值。线程1进行Compare，发现A和地址V的实际值是相等的。

JavaSE高级线程 - 图26

线程1进行SWAP，把地址V的值替换为B，也就是12。

JavaSE高级线程 - 图27

可以使用AtomicInteger类中的public final boolean compareAndSet(int expect , int update)方法进行校验。

7.5.2 CAS总结

比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作，如果不是就一直循环。 缺点： 1.循环会耗时 2.一次性只能保证一个共享变量的原子性 3.会出现ABA问题（此时建议引入原子引用，使用带版本号的原子操作，例如：AtomicStampedReference中的getStamp()方法）

7.6 CAS与Synchronized：乐观锁与悲观锁

共同点： CAS和Synchronized都可以保证多线程环境下共享数据的安全性。

不同点： Synchronized是从悲观的角度出发（悲观锁） 总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。因此Synchronized我们也将其称之为悲观锁。JDK中的ReentrantLock也是一种悲观锁。性能较差！ CAS是从乐观的角度出发（乐观锁） 总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。CAS这种机制我们也可以将其称之为乐观锁。综合性能较好！

第8章指令重排

8.1 什么是重排序？

重排序就是编译器或者CPU的代码的的结构重排排序，已达到最佳的执行效果。重排大概分为编译器重排，处理器重排。 // 编译器重排 //优化前 int x = 1; int y = 2; int a1 = x 1; int b1 = y 1; int a2 = x 2; int b2 = y 2;

//优化后 int x = 1; int y = 2; int a1 = x 1; int a2 = x 2; int b1 = y 1; int b2 = y 2;

//经过这样的优化，可能对于CPU来说只要读取一次的x和y值。而原来的可能需要反复读取寄存器来交替x和y的值。

// 处理器重排 //初始化： int a = 0; int b = 0; int x = 0; int y = 0;

//处理器A执行 a = 1; //A1 x = b; //A2

//处理器B执行 b = 2; //B1 y = a; //B2

JavaSE高级线程 - 图28 由于处理器有读、写缓存区，写缓存区没有及时刷新到内存，造成其他处理器读到的值不是最新的，使得处理器执行的读写操作与内存上反应出的顺序不一致。上面这个例子，可能造成处理器A读到的b=0，处理器B读到的a=0。A1写a=1先写到处理器A的写缓存区中，此时内存中a=0。如果这时处理器B从内存中读a，读到的将是0。

8.2 代码案例

public class Barrier {

int a = 0;
int b = 0;
int x = 0;
int y = 0;
//创建单个线程的线程池
private static ExecutorService executorService1= Executors.newSingleThreadExecutor();
private static ExecutorService executorService2= Executors.newSingleThreadExecutor();
private static ExecutorService executorService3= Executors.newSingleThreadExecutor();
public static void main(String ... args){
    for (int i=0;i< 1000000;i++){
        //初始化
        Barrier barrier=new Barrier();
        //处理器A执行
        executorService1.submit(()->{
            barrier.a = 1; //A1
            barrier.x = barrier.b; //A2
            print(barrier);
        });
        //处理器B执行
        executorService2.submit(()->{
            barrier.b = 2; //B1
            barrier.y = barrier.a; //B2
            print(barrier);
        });
    }
}
public static void print(Barrier barrier){
    executorService3.submit(()->{
        if(barrier.x==0 && barrier.y==0){

System.out.println(“=======>”+barrier.a+” , “+barrier.b+” , “+barrier.x+” , “+barrier.y); }else { System.out.println(barrier.a+” , “+barrier.b+” , “+barrier.x+” , “+barrier.y); } }); }

} 此时运行结果，可以看到，确实有可能都是0。那么我们有没有办法解决这个问题呢？这时候我们就要提到内存屏障了。

8.3 内存屏障

8.3.1 概述

为了解决上述问题，处理器还是使用提供了个武器——内存屏障指令（Memory Barrier）：

写内存屏障（Store Memory Barrier）：处理器将当前存储缓存的值写回主存，以阻塞的方式。
读内存屏障（Load Memory Barrier）：处理器处理失效队列，以阻塞的方式。

通过加入内存屏障，保证了两个操作之间数据的可见性。 volatile关键字通过“内存屏障”来防止指令被重排序 ， volatile会在读取数据前插入一个读屏障，写数据之后加入一个写屏障，所以，它可以避免CPU重排导致的问题，实现多线程之间数据的可见性。

8.3.2 内存屏障的主要类型

为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。然而，对于编译器来说，发现一个最优布置来最小化插入屏障的总数几乎不可能，为此，Java内存模型采取保守策略。 下面是基于保守策略的JMM内存屏障插入策略： 在每个volatile写操作的前面插入一个StoreStore屏障。在每个volatile写操作的后面插入一个StoreLoad屏障。在每个volatile读操作的后面插入一个LoadLoad屏障。在每个volatile读操作的前面插入一个LoadStore屏障。

内存屏障的主要类型（以下了解即可） 不同硬件实现内存屏障的方式不同，Java内存模型屏蔽了这种底层硬件平台的差异，由JVM来为不同的平台生成相应的机器码。 Java内存屏障主要有Load和Store两类。对Load Barrier来说，在读指令前插入读屏障，可以让高速缓存中的数据失效，重新从主内存加载数据对Store Barrier来说，在写指令之后插入写屏障，能让写入缓存的最新数据写回到主内存对于Load和Store，在实际使用中，又分为以下四种： LoadLoad 屏障 序列：Load1,Loadload,Load2 确保Load1所要读入的数据能够在被Load2和后续的load指令访问前读入。通常能执行预加载指令或/和支持乱序处理的处理器中需要显式声明Loadload屏障，因为在这些处理器中正在等待的加载指令能够绕过正在等待存储的指令。而对于总是能保证处理顺序的处理器上，设置该屏障相当于无操作。 StoreStore 屏障 序列：Store1，StoreStore，Store2 确保Store1的数据在Store2以及后续Store指令操作相关数据之前对其它处理器可见（例如向主存刷新数据）。通常情况下，如果处理器不能保证从写缓冲或/和缓存向其它处理器和主存中按顺序刷新数据，那么它需要使用StoreStore屏障。 LoadStore 屏障 序列： Load1; LoadStore; Store2 确保Load1的数据在Store2和后续Store指令被刷新之前读取。在等待Store指令可以越过loads指令的乱序处理器上需要使用LoadStore屏障。 StoreLoad 屏障 序列: Store1; StoreLoad; Load2 确保Store1的数据在被Load2和后续的Load指令读取之前对其他处理器可见。StoreLoad屏障可以防止一个后续的load指令不正确的使用了Store1的数据，而不是另一个处理器在相同内存位置写入一个新数据。正因为如此，所以在下面所讨论的处理器为了在屏障前读取同样内存位置存过的数据，必须使用一个StoreLoad屏障将存储指令和后续的加载指令分开。Storeload屏障在几乎所有的现代多处理器中都需要使用，但通常它的开销也是最昂贵的。它们昂贵的部分原因是它们必须关闭通常的略过缓存直接从写缓冲区读取数据的机制。这可能通过让一个缓冲区进行充分刷新（flush）,以及其他延迟的方式来实现。

8.3.3 示例

下面是在保守策略下，volatile读插入内存屏障后生成的指令序列示意图： JavaSE高级线程 - 图29

上述volatile写和volatile读的内存屏障插入策略非常保守。在实际执行时，只要不改变volatile写-读的内存语义，编译器可以根据具体情况省略不必要的屏障。下面我们通过具体的示例代码来说明： class VolatileBarrierExample { int a; volatile int v1 = 1; volatile int v2 = 2;

void readAndWrite() {
    int i = v1;           // 第一个volatile读
    int j = v2;           // 第二个volatile读
    a = i + j;            //普通写
    v1 = i + 1;           // 第一个volatile写
    v2 = j * 2;           // 第二个 volatile写
}
…                    //其他方法

} 针对readAndWrite()方法，编译器在生成字节码时可以做如下的优化： JavaSE高级线程 - 图30

8.4 volatile总结

volatile是Java虚拟机提供的轻量级的同步机制 1.保证可见性 2.不保证原子性 3.禁止指令重排 volatile是可以保持可见性，不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生。

第9章并发包

在JDK的并发包里提供了几个非常有用的并发容器和并发工具类。供我们在多线程开发中进行使用。

9.1 ConcurrentHashMap

为什么要使用ConcurrentHashMap：

HashMap线程不安全，会导致数据错乱
使用线程安全的Hashtable效率低下

基于以上两个原因，便有了ConcurrentHashMap的登场机会。

HashMap线程不安全演示。

公有、静态的集合： public class Const { public static HashMap map = new HashMap<>(); } 线程，向map中写入数据： public void run() { for (int i = 0; i < 500000; i++) { Const.map.put(this.getName() + (i + 1), this.getName() + i + 1); } System.out.println(this.getName() + “ 结束！”); } 测试类： public class Demo { public static void main(String[] args) throws InterruptedException { Thread1A a1 = new Thread1A(); Thread1A a2 = new Thread1A(); a1.setName(“线程1-“); a2.setName(“线程2-“);

    a1.start();
    a2.start();
    //休息10秒，确保两个线程执行完毕
    Thread.sleep(1000 * 5);
    //打印集合大小
    System.out.println("Map大小：" + Const.map.size());
}

} 说明：两个线程分别向同一个map中写入50000个键值对，最后map的size应为：100000，但多运行几次会发现有以下几种错误：

假死：

异常：

错误结果：

为了保证线程安全，可以使用Hashtable。注意：线程中加入了计时
公有、静态的集合：
public class Const { public static Hashtable map = new Hashtable<>(); }
线程，向map中写入数据：

public void run() {

  long start = System.currentTimeMillis();
  for (int i = 0; i < 500000; i++) {
      Const.map.put(this.getName() + (i + 1), this.getName() + i + 1);
  }
  long end = System.currentTimeMillis();
  System.out.println(this.getName() + " 结束！用时：" + (end - start) + " 毫秒");

}

测试类：

public class Demo { public static void main(String[] args) throws InterruptedException {

  Thread1A a1 = new Thread1A();
  Thread1A a2 = new Thread1A();
  a1.setName("线程1-");
  a2.setName("线程2-");
  a1.start();
  a2.start();
  //休息10秒，确保两个线程执行完毕
  Thread.sleep(1000 * 5);
  //打印集合大小
  System.out.println("Map大小：" + Const.map.size());

} }

执行结果：

可以看到，Hashtable保证的线程安全，时间是2秒多。

再看ConcurrentHashMap
公有、静态的集合：
public class Const { public static ConcurrentHashMap map = new ConcurrentHashMap<>(); }
线程，向map中写入数据：

public void run() {

  long start = System.currentTimeMillis();
  for (int i = 0; i < 500000; i++) {
      Const.map.put(this.getName() + (i + 1), this.getName() + i + 1);
  }
  long end = System.currentTimeMillis();
  System.out.println(this.getName() + " 结束！用时：" + (end - start) + " 毫秒");

}

测试类：

public class Demo { public static void main(String[] args) throws InterruptedException {

  Thread1A a1 = new Thread1A();
  Thread1A a2 = new Thread1A();
  a1.setName("线程1-");
  a2.setName("线程2-");
  a1.start();
  a2.start();
  //休息10秒，确保两个线程执行完毕
  Thread.sleep(1000 * 5);
  //打印集合大小
  System.out.println("Map大小：" + Const.map.size());

} }

执行结果：
ConcurrentHashMap仍能保证结果正确，而且提高了效率。

HashTable效率低下原因： public synchronized V put(K key, V value) public synchronized V get(Object key) HashTable容器使用synchronized来保证线程安全，但在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法，其他线程也访问HashTable的同步方法时，会进入阻塞状态。如线程1使用put进行元素添加，线程2不但不能使用put方法添加元素，也不能使用get方法来获取元素，所以竞争越激烈效率越低。 JavaSE高级线程 - 图36

ConcurrentHashMap高效的原因：CAS + 局部(synchronized)锁定分段式锁 JavaSE高级线程 - 图37

9.2 CountDownLatch

CountDownLatch允许一个或多个线程等待其他线程完成操作，再执行自己。例如：线程1要执行打印：A和C，线程2要执行打印：B，但线程1在打印A后，要线程2打印B之后才能打印C，所以：线程1在打印A后，必须等待线程2打印完B之后才能继续执行。 CountDownLatch构造方法: public CountDownLatch(int count)// 初始化一个指定计数器的CountDownLatch对象 CountDownLatch重要方法: public void await() throws InterruptedException// 让当前线程等待 public void countDown() // 计数器进行减1

示例 1). 制作线程1：

public class ThreadA extends Thread { private CountDownLatch down ; public ThreadA(CountDownLatch down) { this.down = down; } @Override public void run() { System.out.println(“A”); try { down.await(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(“C”); } } 2). 制作线程2： public class ThreadB extends Thread { private CountDownLatch down ; public ThreadB(CountDownLatch down) { this.down = down; } @Override public void run() { System.out.println(“B”); down.countDown(); } } 3).制作测试类： public class Demo { public static void main(String[] args) { CountDownLatch down = new CountDownLatch(1);//创建1个计数器 new ThreadA(down).start(); new ThreadB(down).start(); } } 4). 执行结果：会保证按：A B C的顺序打印。说明： CountDownLatch中count down是倒数的意思，latch则是门闩的含义。整体含义可以理解为倒数的门栓，似乎有一点“三二一，芝麻开门”的感觉。 CountDownLatch是通过一个计数器来实现的，每当一个线程完成了自己的任务后，可以调用countDown()方法让计数器-1，当计数器到达0时，调用CountDownLatch的await()方法的线程阻塞状态解除，继续执行。

9.3 CyclicBarrier

概述

CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。例如：公司召集5名员工开会，等5名员工都到了，会议开始。我们创建5个员工线程，1个开会线程，几乎同时启动，使用CyclicBarrier保证5名员工线程全部执行后，再执行开会线程。 CyclicBarrier构造方法： public CyclicBarrier(int parties, Runnable barrierAction)// 用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景 CyclicBarrier重要方法： public int await()// 每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞

示例代码： 1). 制作员工线程：

public class PersonThread extends Thread { private CyclicBarrier cbRef; public PersonThread(CyclicBarrier cbRef) { this.cbRef = cbRef; } @Override public void run() { try { Thread.sleep((int) (Math.random() * 1000)); System.out.println(Thread.currentThread().getName() + “ 到了! “); cbRef.await(); } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } } } 2). 制作开会线程： public class MeetingThread extends Thread { @Override public void run() { System.out.println(“好了，人都到了，开始开会……”); } } 3). 制作测试类： public class Demo { public static void main(String[] args) { CyclicBarrier cbRef = new CyclicBarrier(5, new MeetingThread());//等待5个线程执行完毕，再执行MeetingThread PersonThread p1 = new PersonThread(cbRef); PersonThread p2 = new PersonThread(cbRef); PersonThread p3 = new PersonThread(cbRef); PersonThread p4 = new PersonThread(cbRef); PersonThread p5 = new PersonThread(cbRef); p1.start(); p2.start(); p3.start(); p4.start(); p5.start(); } } 4). 执行结果： JavaSE高级线程 - 图38

使用场景

使用场景：CyclicBarrier可以用于多线程计算数据，最后合并计算结果的场景。需求：使用两个线程读取2个文件中的数据，当两个文件中的数据都读取完毕以后，进行数据的汇总操作。

9.4 Semaphore

Semaphore（发信号）的主要作用是控制线程的并发数量。 synchronized可以起到”锁”的作用，但某个时间段内，只能有一个线程允许执行。 Semaphore可以设置同时允许几个线程执行。 Semaphore字面意思是信号量的意思，它的作用是控制访问特定资源的线程数目。 Semaphore构造方法： public Semaphore(int permits) permits 表示许可线程的数量 public Semaphore(int permits, boolean fair) fair 表示公平性，如果这个设为 true 的话，下次执行的线程会是等待最久的线程 Semaphore重要方法： public void acquire() throws InterruptedException 表示获取许可 public void release() release() 表示释放许可

示例一：同时允许1个线程执行

1). 制作一个Service类： public class Service { private Semaphore semaphore = new Semaphore(1);//1表示许可的意思，表示最多允许1个线程执行acquire()和release()之间的内容 public void testMethod() { try { semaphore.acquire(); System.out.println(Thread.currentThread().getName()

                + " 进入 时间=" + System.currentTimeMillis());
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName()
                + "   结束 时间=" + System.currentTimeMillis());
        semaphore.release();
        //acquire()和release()方法之间的代码为"同步代码"
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

} 2). 制作线程类： public class ThreadA extends Thread { private Service service; public ThreadA(Service service) { super(); this.service = service; } @Override public void run() { service.testMethod(); } }

3). 测试类： public class Demo { public static void main(String[] args) { Service service = new Service(); //启动5个线程 for (int i = 1; i <= 5; i++) { ThreadA a = new ThreadA(service); a.setName(“线程 “ + i); a.start();//5个线程会同时执行Service的testMethod方法，而某个时间段只能有1个线程执行 } } } 4). 结果： JavaSE高级线程 - 图39

示例二：同时允许2个线程同时执行 1). 修改Service类，将new Semaphore(1)改为2即可：

public class Service { private Semaphore semaphore = new Semaphore(2);//2表示许可的意思，表示最多允许2个线程执行acquire()和release()之间的内容 public void testMethod() { try { semaphore.acquire(); System.out.println(Thread.currentThread().getName()

                + " 进入 时间=" + System.currentTimeMillis());
        Thread.sleep(5000);
        System.out.println(Thread.currentThread().getName()
                + "   结束 时间=" + System.currentTimeMillis());
        semaphore.release();
        //acquire()和release()方法之间的代码为"同步代码"
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

} 2). 再次执行结果： JavaSE高级线程 - 图40

9.5 Exchanger

概述

Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。这两个线程通过exchange方法交换数据，如果第一个线程先执行exchange()方法，它会一直等待第二个线程也执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。 Exchanger构造方法： public Exchanger() Exchanger重要方法： public V exchange(V x)

示例一：exchange方法的阻塞特性

1).制作线程A，并能够接收一个Exchanger对象： public class ThreadA extends Thread { private Exchanger exchanger; public ThreadA(Exchanger exchanger) { super(); this.exchanger = exchanger; } @Override public void run() { try { System.out.println(“线程A欲传递值’礼物A’给线程B，并等待线程B的值…”); System.out.println(“在线程A中得到线程B的值=” + exchanger.exchange(“礼物A”));

    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

} 2). 制作main()方法： public class Demo { public static void main(String[] args) { Exchanger exchanger = new Exchanger(); ThreadA a = new ThreadA(exchanger); a.start(); } } 3).执行结果： JavaSE高级线程 - 图41

示例二：exchange方法执行交换

1).制作线程A： public class ThreadA extends Thread { private Exchanger exchanger; public ThreadA(Exchanger exchanger) { super(); this.exchanger = exchanger; } @Override public void run() { try { System.out.println(“线程A欲传递值’礼物A’给线程B，并等待线程B的值…”); System.out.println(“在线程A中得到线程B的值=” + exchanger.exchange(“礼物A”)); } catch (InterruptedException e) { e.printStackTrace(); } } } 2).制作线程B： public class ThreadB extends Thread { private Exchanger exchanger; public ThreadB(Exchanger exchanger) { super(); this.exchanger = exchanger; } @Override public void run() { try { System.out.println(“线程B欲传递值’礼物B’给线程A，并等待线程A的值…”); System.out.println(“在线程B中得到线程A的值=” + exchanger.exchange(“礼物B”));

    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

} 3).制作测试类： public class Demo { public static void main(String[] args) throws InterruptedException { Exchanger exchanger = new Exchanger(); ThreadA a = new ThreadA(exchanger); ThreadB b = new ThreadB(exchanger); a.start(); b.start(); } } 4).执行结果： JavaSE高级线程 - 图42

示例三：exchange方法的超时

1).制作线程A： public class ThreadA extends Thread { private Exchanger exchanger; public ThreadA(Exchanger exchanger) { super(); this.exchanger = exchanger; } @Override public void run() { try { System.out.println(“线程A欲传递值’礼物A’给线程B，并等待线程B的值，只等5秒…”); System.out.println(“在线程A中得到线程B的值 =” + exchanger.exchange(“礼物A”,5, TimeUnit.SECONDS)); System.out.println(“线程A结束！”); } catch (InterruptedException e) { e.printStackTrace(); } catch (TimeoutException e) { System.out.println(“5秒钟没等到线程B的值，线程A结束！”); } } } 2).制作测试类： public class Run { public static void main(String[] args) { Exchanger exchanger = new Exchanger(); ThreadA a = new ThreadA(exchanger); a.start(); } } 3).测试结果： JavaSE高级线程 - 图43

使用场景

使用场景：可以做数据校对工作需求：比如我们需要将纸制银行流水通过人工的方式录入成电子银行流水。为了避免错误，采用AB岗两人进行录入，录入到两个文件中，系统需要加载这两个文件，并对两个文件数据进行校对，看看是否录入一致。

JavaSE高级 线程

JavaSE高级 线程

主要内容

教学目标

第1章 多线程

1.1 并发与并行

1.2 线程与进程

1.3 Thread类

三种方式，第三种几乎不用，所以说1,2种

1.4 创建线程方式一__继承方式

1.5 创建线程的方式二__实现方式

1.6 匿名内部类方式

1.7 两种创建线程方式的比较

1.8 练习 线程+集合

守护线程：

第2章 线程安全

2.1 线程安全

2.2 线程同步

2.3 同步代码块

2.4 同步方法

2.5 Lock锁

第3章 线程状态

3.1 线程状态概述

3.2 睡眠sleep方法

3.3 等待和唤醒

3.4 等待唤醒案例（包子铺卖包子）

第4章 线程池方式

4.1 线程池的思想

4.2 线程池概念

4.3 线程池的使用

Runnable和Callable的区别

4.4 线程池的练习

第5章 死锁

5.1 什么是死锁

5.2 产生死锁的条件

5.3 死锁代码

第6章 可见性

6.1 看程序说结果

6.2 JMM

6.3 问题分析

6.4 问题处理

方式一：加锁synchronized

方式二：volatile关键字

6.5 volatile与synchronized的区别

第7章 原子性

7.1 看程序说结果

7.2 问题原理说明

7.3 volatile原子性测试

代码测试

volatile的使用场景

7.4 问题解决

方式一：使用锁机制synchronized

方式二：原子类

AtomicInteger

案例改造

7.5 原子类CAS机制实现线程安全

7.5.1 概述

7.5.2 CAS总结

7.6 CAS与Synchronized：乐观锁与悲观锁

第8章 指令重排

8.1 什么是重排序？

8.2 代码案例

8.3 内存屏障

8.3.1 概述

8.3.2 内存屏障的主要类型

8.3.3 示例

8.4 volatile总结

第9章 并发包

9.1 ConcurrentHashMap

9.2 CountDownLatch

9.3 CyclicBarrier

概述

使用场景

9.4 Semaphore

9.5 Exchanger

概述

使用场景

JavaSE高级线程

JavaSE高级线程

第1章多线程

1.8 练习线程+集合

第2章线程安全

第3章线程状态

第4章线程池方式

第5章死锁

第6章可见性

第7章原子性

第8章指令重排

第9章并发包