JUC 全套（1）-CFANZ编程社区

进程与线程

进程

程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的
当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等）

线程

一个进程之内可以分为一到多个线程。
一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行

并行与并发

并发（concurrent）是同一时间应对（dealing with）多件事情的能力
并行（parallel）是同一时间动手做（doing）多件事情的能力

1：每个 核（core） 都可以调度一个运行线程，核越多，处理越快

2：操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小
约为 15 毫秒）分给不同的程序线程使用

3：多核 cpu 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的

4： IO 操作不占用 cpu，阻塞IO ，没能充分利用线程

线程创建

Thread
Thread + Runnable
Thread + FutureTask(同步阻塞等待返回)

进程查看

Windows

tasklist | findstr xxx 查看进程
taskkill /F /PID xxx 杀死进程

栈与栈帧

每个线程启动后，虚拟机就会为其分配一块栈内存。不同的线程对应不同的栈内存。

每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存

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

一个栈帧对应一个方法

线程上下文切换

发生的场景

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

java 工作线程被挂起的时候，需要要由操作系统保存当前线程的状态，Java 中对应的概念
就是程序计数器（Program Counter Register），它的作用是记住下一条 
jvm 指令的执行地址，是线程私有的

状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
Context Switch 频繁发生会影响性能

线程常见方法

sleep

 - 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
 - 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 
   方法会抛出 InterruptedException
 - 睡眠结束后的线程未必会立刻得到执行
 - 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield

 - 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，
   然后调度执行其它线程
 - 具体的实现依赖于操作系统的任务调度器

interrupt

打断阻塞状态下的线程，t1.isInterrupted() 标志位为false

打断正常运行的线程，isInterrupted() 打断标记标志位为true，可以通过此标记
判断是否进行停止

线程安全

static int counter = 0;
static void increment() 
// 临界区
{ 
 counter++; }
static void decrement() 
// 临界区
{ 
 counter--; }

线程安全出现前提

多个线程对共享变量进行写操作

临界区

一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

解决方案

synchronized

获得锁的线程，享有对临界区的执行权，其他线程获取锁时，发生阻塞

获得锁的线程被挂起之后，其他线程依旧阻塞，只能等待锁被释放

使用对象锁保证临界区代码的原子性

锁对象

锁住当前对象
class Test{
 public synchronized void test() {
 
 }
}
等价于
class Test{
 public void test() {
 synchronized(this) {
 
 }
 }
}

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

修饰符可以一定程度保证线程安全

final 修饰表示最终
private 修饰私有

常见线程安全类

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

多个线程调用它们同一个实例的某个方法时，是线程安全的

转账线程安全小测试

@Slf4j
public class ExerciseTransfer {
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                a.transfer(b, randomAmount());
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                b.transfer(a, randomAmount());
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();// 查看转账2000次后的总金额
        log.debug("total:{}", (a.getMoney() + b.getMoney()));
    }

    // Random 为线程安全
    static Random random = new Random();

    // 随机 1~100
    public static int randomAmount() {
        return random.nextInt(100) + 1;
    }
}

class Account {
    private int money;

    public Account(int money) {
        this.money = money;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

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

a.transfer(b, randomAmount()); 为临界区，此临界区有两个对象参与，
如果要同时保证两对象，使用 .class