java并发编程 JUC-基础篇快速入门

1.进程与线程的概念

（1）进程

程序有指令与数据组成，指令要运行，数据要读写，就必须指令加载到CPU。数据加载到内容，指令运行需要用到磁盘。

当一个程序被运行时，从磁盘加载这个程序的代码至内存，这时开启了一个进程。

（2）线程

一个进程之内可以分为一个或多个线程。

一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给CPU执行。

Java中的最小调度单位是线程，最小资源分配单位是进程。

2.并发与并行的概念

并发：同一时间应对多件事情的能力。

并行：同一时间动手做多件事情的能力。

3.异步与同步的概念

异步：不需要等待结果返回，就能继续运行

同步：需要等待结果返回，才能继续运行

同步在多线程中是让多个线程步调一致

4.多线程提高效率的结论

（1）单核CPU下，多线程不能实际提高程序运行效率，只是为了能够在不同任务之间切换，不同

线程轮流使用CPU，不至于一个线程总是占用一个CPU，别的线程没法干活。

（2）多核CPU下，可以并行运行多个线程，能否提高效率要分情况：

一些任务可以通过设计，将任务拆分，并行执行，可以提高运行效率。

不是所有任务都需要拆分，任务的目的不同。

（3）IO操作不占用CPU，只是我们一般拷贝文件使用的是 阻塞IO，相当于线程虽然不用CPU，但是需要等待IO结束，没能充分利用线程，才有了 非阻塞IO 和 异步IO 优化

5.创建线程

5.1 Thread的方式

        Thread thread = new Thread(){@Overridepublic void run(){System.out.println("Hello JUC");}};thread.start();

5.2 Runnable的方式

        Runnable runnable = new Runnable(){@Overridepublic void run(){System.out.println("Hello JUC Runnable");}};Thread thread = new Thread(runnable);thread.start();

5.3 Lambda的方式

5.3.1 Thread的Lambda写法

        Thread thread = new Thread(()->{ System.out.println("Hello JUC Lambda");});thread.start();

5.3.2 Runnable的Lambda写法

        Runnable runnable = ()->{System.out.println("Hello JUC Lambda");};Thread thread = new Thread(runnable);thread.start();

5.4 FutureTaks 配合 Thread

FutureTasks 能够接收Callable类型的参数，用于·处理有返回结果的情况

    @Testvoid testFutureTask() throws ExecutionException, InterruptedException {FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {@Overridepublic Integer call() throws Exception {System.out.println("Running ...");Thread.sleep(3000);return 100;}});Thread thread = new Thread(task);thread.start();System.out.println(task.get());}

6.线程运行

线程运行现象：线程运行交替执行。谁先谁后，不由我们所控制。

查询线程的方式：

（1）windows：

可以通过任务管理器查看进程和线程数

tasklilst 查看进程

taskkill 杀死进程

（2）linux:

ps -fe 查看所有进程

ps -fT -p <PID> 这将显示PID进程及其所有线程的详细信息。

kill 杀死进程

top 按大写H切换是否显示线程

top -H -p <PID> 查看某个进程（PID）

（3）Java:

jps 命令查看所有Java进程

jstack <PID> 查看某个Java进程(PID)的所有线程状态

jconsole 来查看某个Java进程中线程的运行情况

7.线程运行的原理

7.1栈帧

JVM是由堆、栈、方法区所组成的，其中栈内存存放就是线程，每个线程启动后，虚拟机就会分配一块栈内存。

每个栈有多个栈帧，对应着每次方法调用时所占用的内存。

每个线程只有一个活动栈帧，对应着当前正在执行的那个方法。

7.2上下文切换(Thread Context Switch)

可能因为

线程的cpu时间用完
垃圾回收
有更高优先级的线程需要运行
线程自己调用了sleep、yield、wait、join、park、synchronized、lock等方法

当Thread Context Switch发送时，需要操作系统保存当前线程的状态，并恢复另一个线程的状态，Java中对应的概念就是程序计数器，它的作用记录下一条jvm指令的执行地址，是线程私有的。

状态包括程序计数器，虚拟机中每个栈帧的信息，如局部变量，操作数栈，返回地址等

Thread Context Switch频繁发生会影响性能

8.线程中的常见方法

方法	描述
start()	启动新线程并执行该线程的`run()`方法。线程开始执行时，它的`run()`方法会被调用。
run()	当线程启动时，`run()`方法会被调用。这个方法应该包含线程的执行代码。
join()	等待调用`join()`方法的线程终止。例如，`thread.join()`会使当前线程等待`thread`线程终止。
sleep(long millis)	使当前线程暂停执行指定的毫秒数。线程不会失去任何监视器的所有权。
interrupt()	中断线程。如果线程在调用`Object`类的`wait()`、`wait(long)`、`wait(long, int)`、`join()`、`join(long, int)`或者`sleep(long, int)`方法时被阻塞，那么它的中断状态将被清除，并且它将接收到`InterruptedException`。
isAlive()	测试线程是否处于活动状态。如果线程已经启动且尚未终止，则线程处于活动状态。
setName(String name)	改变线程的名称，可以通过`getName()`方法获取线程的名称。
getPriority()	返回线程的优先级。线程的优先级可以设置为`MIN_PRIORITY`（1）、`NORM_PRIORITY`（5）或`MAX_PRIORITY`（10）。
setPriority(int newPriority)	变线程的优先级。线程优先级只是建议给调度器，实际调度可能会忽略它。
yield()	暂停当前正在执行的线程对象，并执行其他线程。
getState()	返回线程的状态。线程的状态可以是`NEW`、`RUNNABLE`、`BLOCKED`、`WAITING`、`TIMED_WAITING`或`TERMINATED`。
isInterrupted()	测试线程是否已经中断。不同于`interrupted()`方法，这个方法不会改变线程的中断状态。

8.1 run 与 start 的区别

`（1）run()` 方法：

run() 方法是线程的执行主体，它包含了线程要执行的任务。
当线程被启动时，run() 方法会被自动调用。
run() 方法可以直接调用，就像调用普通方法一样，它在当前线程中执行，而不是在新线程中执行。
如果直接调用 run() 方法，程序不会创建新的线程，而是在当前线程中顺序执行 run() 方法中的代码。

`（2）start()` 方法：

start() 方法用于启动一个新线程，并执行该线程的 run() 方法。
当 start() 方法被调用时，Java 虚拟机会创建一个新的线程，并执行 run() 方法中的代码。
start() 方法只能被调用一次，多次调用会抛出 IllegalThreadStateException。
调用 start() 方法后，线程可能会立即开始执行，也可能因为线程调度器的安排而在稍后执行。

8.2 Sleep和yield的区别

（3）Sleep

调用sleep让当前线程从Running进入Timed Waiting（阻塞）状态
其他线程可以通过interrupt方法打断正在睡眠的线程，这时sleep方法会抛出InterruptedException
睡眠解释后的线程未必会立即执行
建议使用Timeunit的sleep代替Thread的sleep，有更好的可读性

（4）yield

调用yield 会使当前线程从Running进入Runnable就绪状态，然后调度执行其他线程
具体的实现依赖操作系统的任务调度器
在Java中，Thread.yield()也是一个静态方法，它使当前线程从运行状态转到可运行状态，但不会释放所占有的任何资源。
通常，yield的使用并不频繁，因为它对线程调度提供的信息有限，且线程调度器可能会忽略这个提示。

8.3 线程优先级

线程优先级会提示调度器优先调度线程
如果CPU比较忙，那么优先级高的线程会获得更多的时间片；如果CPU比较空闲，优先级几乎没有什么作用。

8.4 Sleep实现

在没有利用CPU实现计算时，不要让while(true)空转浪费CPU，这时可以使用yield或sleep使CPU的使用权让给其他的程序

8.5 join实现

等待thread线程运行结束或终止。

如果join(long n)带参数的话，就是等待线程运行结束的最多等待n毫秒

8.6 打断阻塞

阻塞

打断sleep的线程，清空打断状态

示例：

  @Testvoid test() throws ExecutionException, InterruptedException {Thread t1 = new Thread(()->{try{TimeUnit.SECONDS.sleep(12);}catch (Exception e){e.printStackTrace();}},"t1");t1.start();TimeUnit.SECONDS.sleep(2);t1.interrupt();System.out.println(t1.isInterrupted());}

注意： 使用 isInterrupted()来判断是否打断成功，对于打断sleep的结果为false则表示打断成功，同理wait和join都是false标记为打断成功。

8.7 打断正常

打断正常的则isInterrupted()为true则表示打断成功

示例：

    @Testvoid test() throws  InterruptedException {Thread t1 = new Thread(()->{try{while (true){boolean interrupted = Thread.currentThread().isInterrupted();if (interrupted){log.info("打斷...");break;}}}catch (Exception e){e.printStackTrace();}},"t1");t1.start();TimeUnit.SECONDS.sleep(3);log.info("interrupt");t1.interrupt();}

9.两阶段终止

问题：在一个线程T1中如何优雅的终止线程T2呢？

错误的思路：

使用stop方法终止线程，这种如果此时线程锁住了公共享资源，将其杀死后就再也没有机会释放资源，导致其他线程永远无法获取锁。
使用System.exit(int)方法停止线程，目的是仅停止一个线程，但是会让整个程序都停止

正确的思路：

    @Testvoid test() throws  InterruptedException {Thread t1 = new Thread(()->{while (true){Thread current = Thread.currentThread();if(current.isInterrupted()){log.info("打断....");break;}try {Thread.sleep(800);log.info("正在记录中.....");}catch (InterruptedException e){e.printStackTrace();//重置设置打断标识，因为sleep过程中进行interrupt是标识false,那么需要正常的interrupt使其标识为truecurrent.interrupt();}}});t1.start();TimeUnit.SECONDS.sleep(3);t1.interrupt();}

10.打断park线程

打断线程后不会影响标记

11.不推荐的方法

这些方法过时，容易破坏同步代码块，造成线程死锁

方法名	说明
stop()	停止线程运行
suspend()	挂起（暂停）线程运行
resume()	恢复线程运行

12.主线程与守护线程

默认情况下，Java进程需要等待线程运行都结束，才会结束。有一种特殊的线程是守护线程，只要其他的线程运行结束了，即使守护线程的代码还没有执行结束，也会强制结束。

示例：设置t1线程为守护线程：

t1.setDaemon(true);

运用：

垃圾回收器线程就是一种守护线程
接收shutdown命令后，不会等待Acceptor和Poller守护线程处理完当前请求

13.线程的五种状态

五种状态：初始状态、可运行状态、运行状态、终止状态、阻塞状态

初始状态：仅在语言层面创建了线程对象，还未与操作系统线程关联
可运行状态；也称（就绪状态），指线程已经被创建（与操作系统线程未关联），可以由CPU调度执行
运行状态：指获取CPU时间片运行中的状态
阻塞状态：如果调用了阻塞API，这时线程实际不会用到CPU，会导致线程上下文切换，进入阻塞状态
终止状态：表示线程已经执行完毕，生命周期已经结束，不会转换为其他状态

14.共享资源的线程安全（synchronized）

竞态条件：发生在至少两个线程竞争同一资源时，而最终的结果取决于这些线程的执行顺序。在大多数情况下，竞态条件的出现是由于程序设计上的缺陷，例如没有适当的同步机制来控制对共享资源的访问。

为了避免临界的竞态的条件发生，可以使用以下的手段实现：

阻塞式的解决方案：Synchronized，Lock
非阻塞式的解决方案：原子变量

使用阻塞式的解决方案：Synchronized（对象锁），采用互斥的方式让同一时刻至多只有一个线程能持有 对象锁，其他线程再想获取这个 对象锁 就会被阻塞住。这样可以保证线程可以安全的执行临界区内的代码，不用担心线程的上下文切换

互斥是保证临界区的竞态条件发生，同一时刻只有一个线程执行临界区代码
同步是由于线程执行的先后，顺序不同，需要一个线程等待其他线程运行到某个点

示例代码：

    int counter = 0;Object lock = new Object();@Testvoid test() throws  InterruptedException {Thread t1 = new Thread(()->{for (int i = 0;i<=50000;i++){synchronized(lock){counter++;}}});Thread t2 = new Thread(()->{for (int i = 0;i<=50000;i++){synchronized(lock){counter--;}}});t1.setName("t1");t2.setName("t2");t1.start();t2.start();t1.join();t2.join();log.info("Counter:{}",counter);}

synchronized用对象锁保证了临界区内代码的原子性，临界区的代码对外不可分割，不会被线程切换所打断

思考：

如果synchronized(obj)放在for循环外面，如何理解？ --原子性

如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎么运行？--锁对象

如果 t1 synchronized(obj）而 t2没有加会怎么样？--锁对象

14.1 通过面向对象的方式实现：

创建实体：

public class Room {private int counter = 0;public void increment(){synchronized (this){counter++;}}public void decrement(){synchronized (this){counter--;}}public int getCounter(){synchronized (this){return counter;}}
}

实现代码：

    Room room = new Room();@Testvoid test() throws  InterruptedException {Thread t1 = new Thread(()->{room.increment();});Thread t2 = new Thread(()->{room.decrement();});t1.setName("t1");t2.setName("t2");t1.start();t2.start();t1.join();t2.join();log.info("Counter:{}",room.getCounter());}

14.2 synchronized加在方法上

（1）

public class Test {public synchronized void test(){}}

相当于：

public class Test {public  void test(){synchronized(this){}}}

（2）static方法

public class Test {public synchronized static void test(){}}

相当于：

public class Test {public  static void test(){synchronized(Test.class){}}}

15.变量线程安全分析

15.1 成员变量和静态变量是否线程安全？

（1）如果没有共享，则线程安全

（2）如果共享，根据他们的状态是否能够改变，分为两种情况：

如果只有读操作，则线程安全
如果有读写操作，则这段代码是临界区，需要考虑线程安全

15.2 局部变量是否线程安全？

（1）局部变量是线程安全的

（2）但是局部变量引用的对象则未必

如果该对象没有逃离方法的作用访问，它是线程安全的
如果该对象逃离方法的作用范围，则需要考虑线程安全

16.常用的线程安全类

String
Integer
StringBuffer
Random
Vector
Hashtable
java.utils.concurrent包下的类

这里的线程安全是多线程调用它们同一个实例的某个方法时，线程是安全的。可以理解为

它们的每个方法是原子
但是它们的多个方法的组合不是原子的（不是线程安全的）

不可改变线程安全

String、Integer等都是不可变类，因为其内部的状态不可改变，因此它们的方法都是线程安全的

虽然String有replace、substring等方法可以改变值、但是根据源码可知都是创新一个新的对象，没有改变原有的对象的值，所以线程安全

17.买票问题习题

（1）线程安全问题示例

package org.example;import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Vector;// 主类，用于执行售票模拟
public class ExerciseSell {// 执行售票模拟的入口点public static void main(String[] args) throws InterruptedException {// 创建一个 TicketWindow 实例，初始票数为1000TicketWindow ticket = new TicketWindow(1000);// 创建一个线程列表，用于存放即将创建的线程List<Thread> threadList = new ArrayList<>();// 创建一个Integer类型的列表，用于存放每个线程卖出的票数List<Integer> amountList = new Vector<>();// 创建80000个线程，每个线程将模拟卖出一定数量的票for(int i = 0; i < 80000; i++) {Thread thread = new Thread(() -> {// 每个线程卖出的票数是随机生成的int amount = ticket.sell(randomAmount());try {// 模拟售票操作后的延迟Thread.sleep(10);} catch (InterruptedException e) {// 如果线程在睡眠中被中断，抛出运行时异常throw new RuntimeException(e);}// 将卖出的票数添加到amountList中amountList.add(amount);});// 将新创建的线程添加到线程列表中threadList.add(thread);// 启动线程thread.start();}// 等待所有线程完成for (Thread thread : threadList) {thread.join();}// 打印剩余票数System.out.println("余票：" + ticket.getAmount());// 计算所有线程卖出的票数总和并打印System.out.println("卖出的票数：" + amountList.stream().mapToInt(i -> i).sum());}// 生成随机售票数的方法static Random random = new Random();public static int randomAmount() {// 返回1到5之间的随机整数，包括1和5return random.nextInt(5) + 1;}
}// 表示售票窗口的类
class TicketWindow {// 私有属性，表示售票窗口的票数private int amount;// 构造函数，初始化票数为传入的参数public TicketWindow(int amount) {this.amount = amount;}// 获取当前票数的方法public int getAmount() {return amount;}// 售票方法，尝试从窗口卖出指定数量的票public int sell(int amount) {if (this.amount >= amount) {// 如果票数足够，减少票数并返回卖出的票数this.amount -= amount;return amount;} else {// 如果票数不足，返回0return 0;}}
}

（2）解决线程安全问题方法

这段代码存在线程安全问题。具体来说，TicketWindow 类的 amount 成员变量在被多个线程访问和修改时，没有使用任何同步机制，这可能导致多个线程同时修改 amount，从而引发数据不一致的问题。

所以要给amount 进行共享资源读写的时进行加锁操作（这段代码，只需要对sell方法加上synchronized即可加锁）

 public synchronized int sell(int amount){if(this.amount >= amount){this.amount -= amount;return amount;}else {return 0;}}

18. 转账习题

（1）线程安全问题示例

package org.example;import java.util.Random;public class ExerciseTransfer {public static void main(String[] args) throws InterruptedException {Amount a = new Amount(1000);Amount b = new Amount(1000);Thread t1 = new Thread(()->{for(int i = 0;i < 100;i++){a.transfer(b,randomAmount());}});Thread t2 = new Thread(()->{for(int i = 0;i < 100;i++){b.transfer(a,randomAmount());}});t1.start();t2.start();t1.join();t2.join();System.out.println("总金额："+a.getMoney() + b.getMoney());}static Random random = new Random();public static int randomAmount(){return random.nextInt(100) + 1;}}class Amount{private int money;public int getMoney() {return money;}public void setMoney(int money) {this.money = money;}public Amount(int money) {this.money = money;}public void transfer(Amount amount,int transferMoney){if(this.money >= transferMoney){this.setMoney(this.getMoney() - transferMoney);amount.setMoney(amount.getMoney() + transferMoney);}}
}

（2）解决线程安全问题方法（两个共享变量）

    public void transfer(Amount amount,int transferMoney){synchronized(Amount.class){if(this.money >= transferMoney){this.setMoney(this.getMoney() - transferMoney);amount.setMoney(amount.getMoney() + transferMoney);}}}

因为如果

public synchronized  void transfer(Amount amount,int transferMoney){if(this.money >= transferMoney){this.setMoney(this.getMoney() - transferMoney);amount.setMoney(amount.getMoney() + transferMoney);}}

相当于保护this.money，但是不保护amount的money

    public void transfer(Amount amount,int transferMoney){synchronized(this){if(this.money >= transferMoney){this.setMoney(this.getMoney() - transferMoney);amount.setMoney(amount.getMoney() + transferMoney);}}}