? 在计算机发明之前，人们处理大量的计算是通过人工处理的，耗费人力，成本很大而且错误较多。为了处理大量的数学计算问题，人们发明了计算机。
? 最初的计算机只能接受一些特定的指令，用户输入一个指令，计算机就做出一个操作。当用户在思考或者输入时，计算机就在等待。显然这样效率低下，在很多时候，计算机都处在等待状态。
? 既然传统计算机那么慢，那么能不能把一系列需要操作的指令写下来，形成一个清单，一次性交给计算机，计算机通过不断得读取指令进行相应的操作。
? 就这样，批处理操作系统诞生了。用户将多个需要执行的程序写在磁带上，然后交由计算机去读取并逐个执行这些程序，并将输出结果写在另一个磁带上。
? 虽然批处理操作系统的诞生提高了任务处理的便捷性（省略了用户输入的时间），但是仍然存在一个很大的问题：
? 假如有两个任务A和B,需要读取大量的数据输入（I/O操作），而其实CPU只能处在等待状态，等任务A读取完数据再能继续进行，这样就白白浪费了CPU资源。于是人们就想，能否在任务A读取数据的过程中，让任务B去执行，当任务A读取完数据之后，暂停任务B，让任务A继续执行？
? 这时候又出现了几个问题：内存中始终都只有一个程序在运行，而想要解决上述问题，必然要在内存中装入多个程序，如何处理呢？多个程序使用的数据如何辨别？当一个程序暂停后，随后怎么恢复到它之前执行的状态呢？
? 这时候，人们就发明了进程，用一个进程对应一个程序，每个进程都对应一定的内存地址和内存空间，并且只能自己使用自己的内存空间，多个进程之间的内存互不共享，且进程之间彼此不打扰。
? 进程同时也保存了程序每时每刻的运行状态，为进程切换提供了如可能。
? 当进程暂停时，它会保存当前进程的状态（进程标识，进程使用的资源等），在下一次切换回来时根据之前保存的2状态进行恢复，接着继续执行。
? 并发是能够让操作系统从宏观上看起来同一时间段执行多个任务。 换句话说，进程让操作体统的并发成为了可能，至此出现多任务操作系统。
? 虽然并发从宏观上看是有多个任务在执行，但是实际上对于单核CPU来说，任意具体时刻都只有一个任务在占用CPU资源，操作系统一般通过CPU时间片轮转来实现并发。
? 总的来说，并发就是在一段时间内多个进程轮流使用同一个 CPU，多个进程形成并发。
? 在同一时刻多个进程使用各自的 CPU，多个进程形成并行。并行需要多个 CPU 支持。
? 出现了进程之后，操作系统的性能(CPU利用率)得到了大大的提升。虽然进程的出现解决了操作系统的并发问题，但是人们不满足，逐渐对实时性有了要求。因为一个进程在一个时间段内只能做一个事情，如果一个进程有多个子任务时，只能逐个得执行这些子任务，很影响效率。
? 举一个例子：对于监控系统这个进程来说，不仅要与服务器端进行通信获取图像数据并将图像信息显示在画面上，还要处理与用户的交互操作。如果在一个时刻该系统正在与服务器通信获取图像数据，而用户在监控系统上点击了一个按钮，那么系统只能等获取完图像后才能与用户进行交互操作。如果获取图像需要10s，用户就得等待10s。显然这样的系统，无法满足人们的需求。
? 为了让子任务可以分开执行，即上个例子说的，在与服务器通信获取图形数据的同时相应用户，为了处理这种情况，人们发明了线程，一个线程执行一个子任务，这样一个进程就包含了多个线程，每个线程负责一个单独的子任务。在用户点击按钮的时候，可以暂停获取图像数据的线程，让出CPU资源，让UI线程获取CPU资源，响应用户的操作，响应完后再切换回来，获取图像数据的线程重新获取CPU资源。让用户感觉系统在同时做很多事，满足用户对实时性的要求。线程的出现是为了解决实时性的问题
? 总的来说，线程是进程的细分，通常，在实时性操作系统中，进程会被划分为多个可以独立运行的子任务，这些子任务被称为线程，多个线程配合完成一个进程的任务。
注意
? 一个进程包含多个线程，但是这些线程共享进程占有的内存地址空间和资源。进程是操作系统进行资源分配的基本单位（进程之间互不干扰），而线程是操作系统进行CPU调度的基本单位（线程间互相切换）。
? 假设 P 进程抢占 CPU 后开始执行，此时如果 P 进行正在进行获取网络资源的操作时，用户进行UI 操作，此时 P 进程不会响应 UI 操作。可以把 P 进程可以分为 Ta、Tb 两个线程。Ta 用于获取网络资源，Tb 用于响应 UI 操作。此时如果 Ta 正在执行获取网络资源时、用户进行 UI 操作，为了做到实时性，Ta 线程暂时挂起，Tb 抢占 CPU 资源，执行 UI 操作，UI 操作执行完成后让出CPU，Ta 抢占 CPU 资源继续执行请求网络资源。
总结
? 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
? 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
? 在 Java 中实现线程的方式有 2 种，一种是继承 Thread，一种是实现 Runnable 接口。
? 如果一个进程没有任何线程，我们成为单线程应用程序；如果一个进程有多个线程存在，我们成为多线程应用程序。进程执行时一定会有一个主线程(main 线程)存在，主线程有能力创建其他线程。多个线程抢占 CPU，导致程序的运行轨迹不确定。多线程的运行结果也不确定。
? 线程开启我们需要用到了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() :返回对当前正在执行的线程对象的引用。? 继承 Thread 实现多线程，必须重写 run 方法，启动的时候调用的也是调用线程对象的start()方法来启动该线程，如果直接调用run()方法的话，相当于普通类的执行，此时相当于只有主线程在执行。
package day16_thread.classing.thread;
/**
* @author Xiao_Lin
* @date 2020/12/20 11:40
*/
public class MyThread extends Thread{
@Override
public void run() {
for (int i =1;i<501;i++){
System.out.println("A Thread"+i);
}
}
}
package day16_thread.classing.thread;
/**
* @author Xiao_Lin
* @date 2020/12/20 11:41
*/
public class TestThread {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
for (int i=1;i<501;i++){
System.out.println("MainThread"+i);
}
}
}
? 从结果我们可以看出，每一次抢占CPU资源的线程是不同的，多个线程轮流使用 CPU，谁先抢占到谁使用 CPU 并执行线程。所以执行结果不确定。
? 编码简单
? 线程类已经继承了Thread类了就无法再继承其他类了，功能不能通过其他类继承拓展，功能没有那么强大。
? 采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。
? 步骤如下：
package day16_thread.classing.thread;
/**
* @author Xiao_Lin
* @date 2020/12/20 13:49
*/
public class MyRun implements Runnable {
@Override
public void run() {
for (int i =1;i<501;i++){
System.out.println("A Thread"+i);
}
}
}
package day16_thread.classing.thread;
/**
* @author Xiao_Lin
* @date 2020/12/20 13:49
*/
public class TestMyRun {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread());
thread.start();
for (int i=1;i<501;i++){
System.out.println("MainThread"+i);
}
}
}
? 实现多线程还有另一种方式，那就是实现Callable接口，前面的两种方式都没办法拿到线程执行返回的结果，因为run()方法都是void修饰的。但是这种方式是可以拿到线程执行返回的结果。
步骤
package day16_thread.classing.thread;
/**
* @author Xiao_Lin
* @date 2020/12/20 13:49
*/
// 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型
class MyCallable implements Callable<String>{
// 2.重写线程任务类的call方法！
@Override
public String call() throws Exception {
// 需求：计算1-10的和返回
int sum = 0 ;
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+" => " + i);
sum+=i;
}
return Thread.currentThread().getName()+"执行的结果是："+sum;
}
}
public class ThreadDemo {
public static void main(String[] args) {
// 3.创建一个Callable的线程任务对象
Callable call = new MyCallable();
// 4.把Callable任务对象包装成一个未来任务对象
// -- public FutureTask(Callable<V> callable)
// 未来任务对象是啥，有啥用？
// -- 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！
// -- 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。
FutureTask<String> task = new FutureTask<>(call);
// 5.把未来任务对象包装成线程对象
Thread t = new Thread(task);
// 6.启动线程对象
t.start();
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+" => " + i);
}
// 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果
try {
String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）
System.out.println(rs);
} catch (Exception e) {
e.printStackTrace();
}
}
}
需求：模拟售票窗口买票的过程，共有五张票
package day16_thread.classing.thicks;
/**
* @author Xiao_Lin
* @date 2020/12/20 13:53
*/
public class MyThread extends Thread{
private static int count = 5;
public MyThread() {
}
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i=0;i<5;i++){
if (count>0){
count--;
System.out.println(super.getName()+"卖了一张票。还剩下"+count+"张票");
}
}
}
}
package day16_thread.classing.thicks;
/**
* @author Xiao_Lin
* @date 2020/12/20 13:55
*/
public class TestThread {
public static void main(String[] args) {
MyThread t1 = new MyThread("窗口A");
MyThread t2 = new MyThread("窗口B");
MyThread t3 = new MyThread("窗口C");
MyThread t4 = new MyThread("窗口D");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
package day16_thread.classing.thicks;
/**
* @author Xiao_Lin
* @date 2020/12/20 14:15
*/
public class MyRun implements Runnable {
private int count = 5;
@Override
public void run() {
for (int i=0;i<5;i++){
if (count>0){
count--;
System.out.println(Thread.currentThread().getName()+"卖了一张票。还剩下"+count+"张票");
}
}
}
}
package day16_thread.classing.thicks;
/**
* @author Xiao_Lin
* @date 2020/12/20 14:17
*/
public class TestRun {
public static void main(String[] args) {
MyRun myRun = new MyRun();
Thread t1 = new Thread(myRun,"窗口A");
Thread t2 = new Thread(myRun,"窗口B");
Thread t3 = new Thread(myRun,"窗口C");
Thread t4 = new Thread(myRun,"窗口D");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
实现Runnable接口比继承Thread类所具有的优势：
? 多线程访问共享资源的同时，存在一个十分严重的问题，那就是会导致共享资源数据错乱。
? 假设我们拿一种执行情况来分析
? 我们可以设置线程的优先级调用，优先级越高 ，被 CPU 调动的可能性越大，但不一定是优先级越高就一定先执行。，有可能设置了最高的优先级但是确实最后调用。
//系统的默认三种优先级
System.out.println(Thread.MAX_PRIORITY);//数字是10
System.out.println(Thread.MIN_PRIORITY);//数字是1
System.out.println(Thread.NORM_PRIORITY);//数字是5
package day16_thread.classing.PriorityTest;
/**
* @author Xiao_Lin
* @date 2020/12/20 19:30
*/
public class TestPriority {
public static void main(String[] args) {
PriorityThrea p1 = new PriorityThrea("线程1");
PriorityThrea p2 = new PriorityThrea("线程2");
p1.setPriority(PriorityThrea.MAX_PRIORITY);
p2.setPriority(PriorityThrea.MIN_PRIORITY);
p1.start();
p2.start();
}
}
? 强制执行（join方法）会导致其他线程阻塞，当线程执行完以后，其他线程阻塞原因消除，进入就绪状态
package day16_thread.classing.join;
/**
* @author Xiao_Lin
* @date 2020/12/20 15:45
*/
public class TestMyJoinThread {
public static void main(String[] args) {
MyJoinThread myJoinThread = new MyJoinThread();
myJoinThread.start();
for (int i =0;i<5;i++){
System.out.println("main -> " + i);
if (i==2){
try {
myJoinThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
? 线程调用（sleep方法）方法，传入一个毫秒值，会导致当前线程进入阻塞状态，阻塞时间到了以后线程进入就绪状态，sleep方法会抛出一个编译时异常InterruptedException
package day16_thread.classing.sleep;
/**
* @author Xiao_Lin
* @date 2020/12/20 19:47
*/
public class SleepThread extends Thread{
public SleepThread() {
}
public SleepThread(String name) {
super(name);
}
@Override
public void run() {
System.out.println("线程A开始执行");
try {
sleep(2000);
System.out.println("休眠结束");
} catch (InterruptedException e) {
System.out.println("外界有程序中断线程 A");
}
System.out.println("线程A即将结束");
}
}
package day16_thread.classing.sleep;
/**
* @author Xiao_Lin
* @date 2020/12/20 19:50
*/
public class TestSleepThread {
public static void main(String[] args) {
SleepThread s = new SleepThread();
s.start();
}
}
package day16_thread.classing.sleep;
/**
* @author Xiao_Lin
* @date 2020/12/20 19:47
*/
public class SleepThread extends Thread{
public SleepThread() {
}
public SleepThread(String name) {
super(name);
}
@Override
public void run() {
System.out.println("线程A开始执行");
try {
sleep(20000);
System.out.println("休眠结束");
} catch (InterruptedException e) {
System.out.println("外界有程序中断线程 A");
}
System.out.println("线程A即将结束");
}
}
package day16_thread.classing.sleep;
/**
* @author Xiao_Lin
* @date 2020/12/20 19:50
*/
public class TestSleepThread {
public static void main(String[] args) {
SleepThread s = new SleepThread();
s.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//线程中断
s.interrupt();
System.out.println("主线程结束");
}
}
线程休眠导致当前线程进入阻塞状态，休眠时间结束后，线程进入就绪状态，抢占CPU，抢到后继续运行
线程休眠过程中可以被中断，所以存在一个编译时异常：InterruptedException，外界程序中断该线程时，休眠时间提前结束，进入就绪状态，等待CPU调度执行。
package day16_thread.classing.yield;
/**
* @author Xiao_Lin
* @date 2020/12/20 20:00
*/
public class YieldThread extends Thread{
public YieldThread() {
}
public YieldThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(super.getName() + "=>" + i);
}
}
}
package day16_thread.classing.yield;
/**
* @author Xiao_Lin
* @date 2020/12/20 20:01
*/
public class TestThreadYield {
public static void main(String[] args) {
System.out.println("主线程开始执行");
YieldThread y1 = new YieldThread();
y1.start();
for (int i = 0;i<1000;i++){
System.out.println(Thread.currentThread().getName()+"->"+i);
if (i%2 == 0){
Thread.yield();
}
}
}
}
? 当前线程礼让后，线程进入就绪状态。
? stop表示强制停止一个线程，停止一个线程的风险较大，不建议使用，通过interrupt发送中断信号中断线程，线程就会在在那个时间点结束
? interrupt中止正在运行的线程，该线程不会立即结束，而是继续执行，在适当的时机选择结合异常处理机制结束，异常处理机制可以保证线程继续执行，通过异常处理机制让一个线程正常结束。
? 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在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方法而死亡。 |
? 用new关键字建立一个线程后，该对象就处于新生状态，处于新生状态的多线程有自己的内存空间，通过调用start()方法进行就绪状态。
? 处于就绪状态的线程具备了运行的条件，但是还没有分配到CPU，处于线程就绪队列，等待系统为其分配CPU，当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动作称为"CPU调度"，等待状态还有一个名字也叫作就绪状态。
? 在运行状态的线程执行自己的run方法中的代码，直到因为等待某资源而阻塞或者完成任务而死亡，如果在给定的时间内没有执行结束，就会被系统换下来回到等待执行的状态。
? 处于运行状态的线程在某种情况下，比如说执行了sleep（睡眠）方法，或者是等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入阻塞状态
? 在阻塞状态的的线程不会马上进入就绪队列，只有当引起阻塞状态的原因消除时，如睡眠时间已到或者等待的I/O设备空闲下来，线程便进入了就绪状态，重新进入到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续执行。冻结状态、静止状态都是阻塞状态
? 死亡状态是线程生命周期中最后的一个状态。
? 引起线程死亡的原因有三种：
在多线程环境下，什么时候会出现数据错乱的问题？
? 多个线程并发访问共享资源，并对共享资源进行破坏性操作（增删改）的时候，一定会出现数据错乱的问题
如何解决
? 在多线程环境下，如果对共享资源进行破坏性操作的时候，需要同步操作。
? 如果希望一系列操作(在代码中可以认为是很多句语句)，要么都执行，要么都不执行，我们把这种操作叫做原子性操作，原则性操作可以认为是业务上不可分割的单元。
? Java实现原子性操作的过程叫做同步操作，常见的有两种方式实现同步：
? 把原子性操作放到一个代码块中，就是同步代码块，使用关键字synchronized
synchronized (mutex) {//mutex 称为同步锁，也叫互斥锁。
// 原子性操作
}
? 改造之前的火车卖票的代码
package day16_thread.classing.thicks;
/**
* @author Xiao_Lin
* @date 2020/12/20 14:15
*/
public class MyRun implements Runnable {
private int count = 500;
@Override
public void run() {
for (int i=0;i<1000;i++){
synchronized (this){
if (count>20){
count--;
System.out.println(Thread.currentThread().getName()+"卖了一张票。还剩下"+count+"张票");
}
}
}
}
}
package day16_thread.classing.thicks;
/**
* @author Xiao_Lin
* @date 2020/12/20 14:17
*/
public class TestRun {
public static void main(String[] args) {
MyRun myRun = new MyRun();
Thread t1 = new Thread(myRun,"窗口A");
Thread t2 = new Thread(myRun,"窗口B");
Thread t3 = new Thread(myRun,"窗口C");
Thread t4 = new Thread(myRun,"窗口D");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
? 原则上，锁对象建议使用共享资源，但是遵循以下两个点：
this作为锁对象，此时this正好是共享资源。类名.calss字节码作为锁对象。? synchronized(obj){}中的 obj 称为同步监视器，同步代码块中的同步监视器可以是任何对象，但是推荐使用共享资源作为同步监视器，且同步监视器不能是基本数据类型，同时也不推荐使用包装类型（会有自动拆箱和装箱）
Runnable接口会比较方便。? 当原子性操作代码很长且需要重复调用的时候，可以考虑将同步代码块中的代码抽取出来变成同步方法。
修饰符 synchronized 返回值类型 方法名称(){
//原子性操作
}
? 同步方法中无需指定同步监视器，因为同步方法的监视器就是this，也就是对象本身。
? java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大。
? 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();//解锁操作
}
}
}
? 多个线程由于处在同一个进程，所以互相通信是比较容易的。
? 线程通信的核心方法：
public void wait(): 让当前线程进入到等待状态 此方法必须锁对象调用。public void notify() : 唤醒当前锁对象上等待状态的某个线程 此方法必须锁对象调用。public void notifyAll() : 唤醒当前锁对象上等待状态的全部线程 此方法必须锁对象调用。? 线程通信的经典模型：生产者与消费者问题。
? 模拟一个案例：小明和小红有一个共同账户(共享资源)，他们有3个爸爸（亲爸，岳父，干爹）给他们存钱。小明和小红去取钱，如果有钱就取出，然后等待自己，唤醒他们3个爸爸们来存钱他们的爸爸们来存钱，如果发现有钱就不存，没钱就存钱，然后等待自己，唤醒孩子们来取钱。做整存整取：10000元。
package com;
// 账户对象
public class Account {
private String cardId ;
private double money ; // 余额。
public Account() {
}
public Account(String cardId, double money) {
this.cardId = cardId;
this.money = money;
}
// 亲爸，干爹，岳父
public synchronized void saveMoney(double money) {
try{
// 1.知道是谁来存钱
String name = Thread.currentThread().getName();
// 2.判断余额是否足够
if(this.money > 0){
// 5.等待自己，唤醒别人！
this.notifyAll();
this.wait();
}else{
// 3.钱没有，存钱
this.money += money;
System.out.println(name+"来存钱，存入了"+money+"剩余："+this.money);
// 4.等待自己，唤醒别人！
this.notifyAll();
this.wait();
}
}catch (Exception e){
e.printStackTrace();
}
}
// 小明 小红
public synchronized void drawMoney(double money) {
try{
// 1.知道是谁来取钱
String name = Thread.currentThread().getName();
// 2.判断余额是否足够
if(this.money > 0){
// 3.账户有钱，有钱可以取
this.money -= money;
System.out.println(name+"来取钱"+money+"取钱后剩余："+this.money);
// 4.没钱，先唤醒别人，等待自己，。
this.notifyAll();
this.wait();
}else{
// 5.余额不足，没钱，先唤醒别人，等待自己，。
this.notifyAll();
this.wait();
}
}catch (Exception e){
e.printStackTrace();
}
}
public String getCardId() {
return cardId;
}
public void setCardId(String cardId) {
this.cardId = cardId;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
}
package com;
/**
取钱的线程类
*/
public class DrawThread extends Thread {
private Account acc ; // 定义了一个账户类型的成员变量接收取款的账户对象！
public DrawThread(Account acc , String name){
super(name); // 为当前线程对象取名字
this.acc = acc ;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(4000);
acc.drawMoney(10000);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
package com;
/**
存钱的线程类
*/
public class SaveThread extends Thread {
private Account acc ; // 定义了一个账户类型的成员变量接收取款的账户对象！
public SaveThread(Account acc , String name){
super(name); // 为当前线程对象取名字
this.acc = acc ;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(4000);
acc.saveMoney(10000);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
package com;
/**
目标：线程通信（了解原理，代码几乎不用）
线程通信：多个线程因为在同一个进程中，所以互相通信比较容易的。
线程通信的经典模型：生产者与消费者问题。
生产者负责生成商品，消费者负责消费商品。
生产不能过剩，消费不能没有。
模拟一个案例：
小明和小红有一个共同账户：共享资源
他们有3个爸爸（亲爸，岳父，干爹）给他们存钱。
模型：小明和小红去取钱，如果有钱就取出，然后等待自己，唤醒他们3个爸爸们来存钱
他们的爸爸们来存钱，如果发现有钱就不存，没钱就存钱，然后等待自己，唤醒孩子们来取钱。
做整存整取：10000元。
分析：
生产者线程：亲爸，岳父，干爹
消费者线程：小明，小红
共享资源：账户对象。
注意：线程通信一定是多个线程在操作同一个资源才需要进行通信。
线程通信必须先保证线程安全，否则毫无意义，代码也会报错！
线程通信的核心方法：
public void wait(): 让当前线程进入到等待状态 此方法必须锁对象调用.
public void notify() : 唤醒当前锁对象上等待状态的某个线程 此方法必须锁对象调用
public void notifyAll() : 唤醒当前锁对象上等待状态的全部线程 此方法必须锁对象调用
小结：
是一种等待唤醒机制。
必须是在同一个共享资源才需要通信，而且必须保证线程安全。
*/
public class ThreadCommunication {
public static void main(String[] args) {
// 1.创建一个账户对象。
Account acc = new Account("ICBC-1313113",0);
// 2.创建2个取钱线程。
new DrawThread(acc , "小明").start();
new DrawThread(acc , "小红").start();
// 3.创建3个存钱线程。
new SaveThread(acc , "亲爹").start();
new SaveThread(acc , "干爹").start();
new SaveThread(acc , "岳父").start();
}
}
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("执行了======");
}
}
}
}
? 在介绍多线程并发修改变量不可见现象的原因之前，我们先看看另一种Java内存模型（和Java并发编程有关的模型）：JMM。
? JMM（Java Memory Model）：Java内存模型是Java虚拟机规范中定义的一种内存模型，Java内存模型是标准化的，他屏蔽了底层不同计算机的硬件的不同
? Java内存模型描述了Java程序中各种变量（线程共享变量）的访问规则以及在JVM中将变量存储到内存和从内存中读取变量的底层细节。
? JMM有以下规定：
本地内存和主内存之间的关系：
while(true)调用的是系统底层的代码，速度快，快到没有时间再去读取主内存中的值，所以此时while(true)读取到的值一直是flag = false。while(true){
synchronized(t){
if(t.isFlag()){
System.out.print("主线程进入循环")
}
}
}
? 第一个线程进入synchronized代码块前后，执行过程如下：
? 我们还可以对共享变量用volatile关键字修饰，volatile关键字的作用是在多线程并发下修改共享变量实现可见性。，一旦一线程修改了volatile修饰的变量，另一个线程可以立即读取到最新值。
volatile只能修饰实例变量和类变量，而synchronized可以修饰方法以及代码块volatile保证数据的可见性，但是不保证原子性（多线程进行写操作，不保证线程安全），而synchronized是一种排他互斥的机制，可以保证线程安全。? 所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行。
public class VolatileAtomicThread implements Runnable {
// 定义一个int类型的遍历
private int count = 0 ;
@Override
public void run() {
// 对该变量进行++操作，100次
for(int x = 0 ; x < 100 ; x++) {
count++ ;
System.out.println("count =========>>>> " + count);
}
}
}
public class VolatileAtomicThreadDemo {
public static void main(String[] args) {
// 创建VolatileAtomicThread对象
VolatileAtomicThread volatileAtomicThread = new VolatileAtomicThread() ;
// 开启100个线程对count进行++操作
for(int x = 0 ; x < 100 ; x++) {
new Thread(volatileAtomicThread).start();
}
}
}
? 执行结果：不保证一定是10000
以上问题主要是发生在count++操作上，count++操作包含3个步骤：
? count++操作不是一个原子性操作，也就是说在某一个时刻对某一个操作的执行，有可能被其他的线程打断。
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次修改。
// 定义一个int类型的变量
private volatile int count = 0 ;
? 小结：在多线程环境下，volatile关键字可以保证共享数据的可见性，但是并不能保证对数据操作的原子性（在多线程环境下volatile修饰的变量也是线程不安全的）。
? 在多线程环境下，要保证数据的安全性，我们还需要使用锁机制。
? 我们可以给count++操作添加锁，那么count++操作就是临界区的代码，临界区只能有一个线程去执行，所以count++就变成了原子操作。
? 缺点：性能差。
public class VolatileAtomicThread implements Runnable {
// 定义一个int类型的变量
private volatile int count = 0 ;
private static final Object obj = new Object();
@Override
public void run() {
// 对该变量进行++操作，100次
for(int x = 0 ; x < 100 ; x++) {
synchronized (obj) {
count++ ;
System.out.println("count =========>>>> " + count);
}
}
}
}
? Java从JDK5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。我们可以使用原子类来保证原子性操作，从而保证线程安全。
? 我们以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的值，并返回旧值。 |
public class VolatileAtomicThread implements Runnable {
// 定义一个int类型的变量,默认值是0，我们也可以指定长度
private AtomicInteger atomicInteger = new AtomicInteger() ;
@Override
public void run() {
// 对该变量进行++操作，100次
for(int x = 0 ; x < 100 ; x++) {
int i = atomicInteger.getAndIncrement();
System.out.println("count =========>>>> " + i);
}
}
}
? CAS的全成是： Compare And Swap(比较再交换); 是现代CPU广泛支持的一种对内存中的共享数据进行操作的一种特殊指令。CAS可以将read-modify-check-write转换为原子操作，这个原子操作直接由处理器保证。
? CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。
? CAS和Synchronized都可以保证多线程环境下共享数据的安全性。那么他们两者有什么区别？
? Synchronized是从悲观的角度出发，是一个典型的悲观锁。
? 总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。
? 共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。因此Synchronized我们也将其称之为悲观锁。jdk中的ReentrantLock也是一种悲观锁。性能较差！
? CAS是从乐观的角度出发，总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。
? CAS这种机制我们也可以将其称之为乐观锁。综合性能较好！很多数据库都会使用到乐观锁机制。
? 在实际开发中如果不需要考虑线程安全问题，大家不需要做线程安全，因为如果做了反而性能不好！但是开发中有很多业务是需要考虑线程安全问题的，此时就必须考虑了。否则业务出现问题。
? Java为很多业务场景提供了性能优异，且线程安全的并发包，程序员可以选择使用！
? Map集合中的经典集合：HashMap它是线程不安全的，性能好。如果在要求线程安全的业务情况下就不能用这个集合做Map集合，否则业务会崩溃。
? 为了保证线程安全，可以使用Hashtable。Hashtable是线程安全的Map集合，但是性能较差！(已经被淘汰了，虽然安全，但是性能差)
? 为什么说HashTable的性能差呢？我们看看源码可以得知，HashTable的每一个方法都用synchronized修饰了，实在是过于悲观。
? ConcurrentHashMap不止线程安全，而且效率高，性能好，最新最好用的线程安全的Map集。
public class Const {
public static HashMap<String,String> map = new HashMap<>();
}
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());
}
}
? 我们执行后可以发现出来的错误是有以下三种：
public class Const {
public static Hashtable<String,String> map = new Hashtable<>();
}
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());
}
}
public class Const {
public static ConcurrentHashMap<String,String> map = new ConcurrentHashMap<>();
}
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的源码我们可以发现他的每一个方法都用synchronized修饰了，实在是过于悲观。
public synchronized V put(K key, V value)
public synchronized V get(Object key)
? 在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法，其他线程也访问HashTable的同步方法时，会进入阻塞状态。如线程1使用put进行元素添加，线程2不但不能使用put方法添加元素，也不能使用get方法来获取元素，所以竞争越激烈效率越低。
? ConcurrentHashMap上锁机制：CAS + 局部(synchronized)锁定(分段式锁)
? CountDownLatch允许一个或多个线程等待其他线程完成操作，再执行自己。
需求
? 线程1要执行打印：A和C，线程2要执行打印：B，但线程1在打印A后，要线程2打印B之后才能打印C，所以：线程1在打印A后，必须等待线程2打印完B之后才能继续执行。
CountDownLatch构造器以及方法
public CountDownLatch(int count)// 初始化唤醒需要的down几步。count相当于一个计数器
| 方法 | 详解 |
|---|---|
| public void await() throws InterruptedException | 让当前线程等待，必须down完初始化的数字才可以被唤醒，否则进入无限等待 |
| public void countDown() | 计数器进行减1 （down 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");
}
}
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();
}
}
public class Demo {
public static void main(String[] args) {
CountDownLatch down = new CountDownLatch(1);//创建1个计数器
new ThreadA(down).start();
new ThreadB(down).start();
}
}
? CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。这里的屏障相当于需要达到的要求。
? CyclicBarrier构造方法：
public CyclicBarrier(int parties, Runnable barrierAction)// 用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景
? CyclicBarrier重要方法：
public int await()// 每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞
制作员工线程
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();
}
}
}
制作开会线程
public class MeetingThread extends Thread {
@Override
public void run() {
System.out.println("好了，人都到了，开始开会......");
}
}
制作测试类
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();
}
}
? CyclicBarrier可以用于多线程计算数据，最后合并计算结果的场景。例如：使用两个线程读取2个文件中的数据，当两个文件中的数据都读取完毕以后，进行数据的汇总操作。
? Semaphore（发信号）的主要作用是控制线程的并发数量。他的机制和synchronized一样都是上锁，但是，但某个时间段内，synchronized只能有一个线程允许执行。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() 表示释放许可
? 我们测试一下只允许一个线程的案例。
制作一个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();
}
}
}
制作线程类
public class ThreadA extends Thread {
private Service service;
public ThreadA(Service service) {
super();
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}
测试类
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个线程执行
}
}
}
我们测试一下只允许两个线程的案例。
修改Service类
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();
}
}
}
? Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。
? 这两个线程通过exchange方法交换数据，如果第一个线程先执行exchange()方法，它会一直等待第二个线程也执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。
? Exchanger构造方法：
public Exchanger();
Exchanger重要方法：
public V exchange(V x)
- 制作线程A，并能够接收一个Exchanger对象：
public class ThreadA extends Thread {
private Exchanger<String> exchanger;
public ThreadA(Exchanger<String> 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();
}
}
}
- 制作main()方法
public class Demo {
public static void main(String[] args) {
Exchanger<String> exchanger = new Exchanger<String>();
ThreadA a = new ThreadA(exchanger);
a.start();
}
}
- 制作线程A
public class ThreadA extends Thread {
private Exchanger<String> exchanger;
public ThreadA(Exchanger<String> 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();
}
}
}
- 制作线程B
public class ThreadB extends Thread {
private Exchanger<String> exchanger;
public ThreadB(Exchanger<String> 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();
}
}
}
- 制作测试类
public class Demo {
public static void main(String[] args) throws InterruptedException {
Exchanger<String> exchanger = new Exchanger<String>();
ThreadA a = new ThreadA(exchanger);
ThreadB b = new ThreadB(exchanger);
a.start();
b.start();
}
}
? exchange方法我们可以设置不一直等待，可以设置一个超时时间。
- 制作线程A
public class ThreadA extends Thread {
private Exchanger<String> exchanger;
public ThreadA(Exchanger<String> 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结束！");
}
}
}
- 制作测试类
public class Run {
public static void main(String[] args) {
Exchanger<String> exchanger = new Exchanger<String>();
ThreadA a = new ThreadA(exchanger);
a.start();
}
}
? 我们可以做可以做数据校对工作，比如我们需要将纸制银行流水通过人工的方式录入成电子银行流水。为了避免错误，采用AB岗两人进行录入，录入到两个文件中，系统需要加载这两个文件，并对两个文件数据进行校对，看看是否录入一致。
? 我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：
? 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间，线程也属于宝贵的系统资源。
? 于是Java提供了一种思想：线程池，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务。
? 线程池其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
? 合理利用线程池能够带来三个好处：
? Java中线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而是一个执行线程的工具。真正的线程池接java.util.concurrent.ExecutorService。
? 要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。
? Executors类中有个创建线程池的方法有：
public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)
public Future<?> submit(Runnable task):获取线程池中的某一个线程对象，并执行
Future接口：用来记录线程任务执行完毕后产生的结果。
使用线程池中线程对象的步骤：
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();
}
}
<T> Future<T> submit(Callable<T> 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());
}
}
? 多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
? 举个例子：客户（占用资金，等待经销商的货品资源） 经销商（占用货品资源，等待客户的资金）
? 当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失
? 死锁是多个线程满足上述四个条件才会形成，死锁需要尽量避免，且死锁一般存在资源的嵌套请求！
package test;
/**
* @author Xiao_Lin
* @date 2020/12/30 19:10
*/
public class DeadlockDemo {
// 1.至少需要两个资源，每个资源只需要1份。
public static Object resources1 = new Object();
public static Object resources2 = new Object();;
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
// 线程1：占用资源1 ，请求资源2
synchronized (resources1){
System.out.println("线程1抢占资源1,等待资源2");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (resources2){
System.out.println("线程1成功抢占资源2");
}
};
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (resources2){
System.out.println("线程2抢占资源2，等待资源1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (resources1){
System.out.println("线程2成功抢占资源1");
}
}
}
}).start();
}
}
原文：https://www.cnblogs.com/XiaoLin-Java/p/14735926.html