Java JUC基础笔记

Java JUC基础

此笔记适合入门(像进一步进阶的话，请移步尚硅谷34h的JUC）

多线程的创建

继承 Thread 类

import java.lang.Thread;

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程MyThread输出：" + i);
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        
        t.start(); // main线程 t线程
        
        for (int i= 1; i <= 5; i++) {
            System.out.println("主线程main输出: " + i);
        }
    }
}

优缺点：

优点：编码简单
缺点：线程类已经继承 Thread，无法继承其他类，不利于功能的扩展。

注意事项

启动线程必须是调用 start 方法，不是调用 run 方法。
- 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
  - 只有调用start方法才是启动一个新的线程执行。
不要把主线程任务放在启动子线程之前。
- 这样主线程一直是先跑完的，相当于是一个单线程的效果了。

实现 Runnable 接口

方式一

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程输出 ===> " + i);
        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) {
        Runnable target = new MyRunnable();
        
        new Thread(target).start();
        
        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程main输出 ===>" + i);
        }
    }
}

优缺点

任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。

方式二

public class ThreadTest2_2 {
    public staic void main(String[] args) {
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
					System.out.println("子线程1输出: " + i);
                }
            }
        };
        
        // 简化形式2
        new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("子线程3输出： " + i);
            }
        }).start();
        
        new Thread(target).start();
        
        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程main输出: " + i);
        }
    }
}

实现 Callable 接口

public class ThreadTest3 {
    public staic void main(String[] args) throws Exception {
        // 3. 创建一个 Callable 的对象
        Callable <String> call = new MyCallable(100);
        // 4. 把 Callable 的对象封装成一个 FutureTask 对象(任务对象)
        // 未来任务对象的作用
		// 1. 是一个任务对象
		// 2.可以在线程执行完毕之后 用未来任务对象调用 get 方法获取线程执行完毕后
        FutureTask<String> f1 = new FutureTask<>(call);
        
        // 5.把任务对象交给一个 Thread 对象
        new Thread(f1).start();
        
        // 6.取线程执行完毕后返回的结果。
        // 注意：如果执行到这儿，假如上面的线程还没有执行完毕
        // 这里的代码会暂停，等待上面线程执行完毕后才会获取结果
        String rs = f1.get();
        System.out.println(rs);
    }
}

FutureTask的API	说明
public FutureTask<>(Callable call)	把 Callable 对象封装成 FutureTask对象
public V get() throws Exception	获取线程执行 call 方法返回的结果

优缺点

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果。
缺点：编码复杂一点。

Thread 的常用方法

⚠️ Thread类还提供了诸如：yield、interrupt、守护线程、线程优先级等线程的控制方法，在开发中很少使用，这些方法会后续需要用到的时候再讲解。

线程安全

什么是线程安全问题

多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题。

场景：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，如果小明和小红同时来取钱，并且2人各自都在取钱10万元，可能会出现什么问题呢？

线程安全问题出现的原因

存在多个线程同时执行
同时访问一个共享资源
存在修改该用户共享资源

线程同步

同步思想概述

让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

方式一：同步代码块

作用：把访问共享资源的核心代码给上锁，以此保证线程安全。
原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。

同步锁的注意事项

对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug。

public void drawMoney(double money) {
    // 先搞清楚是谁来取钱
    String name = Thread.currentThread().getName();
    // 1. 判断余额是否充足
    // synchronized ("黑马")(不推荐)
    synchronized ("this") {
        if (this.money >= money) {
            System.out.println(name + "来取钱" + money);
            this.money -= money;
            System.out.println(name + "来取钱后， 余额剩余为" + money);
        } else {
            System.out.println(name + "来取钱: 余额不足");
        }
    }
}

// 静态方法
public static void test() {
    synchronized (Account.class) {
        
    }
}

锁对象随便选择一个唯一的对象好不好呢？

不好，会影响其他无关线程的执行。

锁对象的使用规范

建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码（类名.class）对象作为锁对象。

方式二：同步方法

作用：把访问共享资源的核心方法给上锁，以此保证线程安全。
原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

同步方法底层原理

同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
如果方法是实例方法：同步方法默认用this作为的锁对象.
如果方法是静态方法：同步方法默认用类名**.class**作为的锁对象。

方式三：Lock锁

Lock锁是 JDK5 开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。
Lock 是接口，不能直接实例化，可以采用它的实现类 ReentrantLock 来构建 Lock 锁对象。

public void drawMoney(double money) {
    // 先搞清楚是谁来取钱
	String name = Thread.currentThread().getName();
    try {
        lk.lock(); //创建
        // 1.判断余额是否足够
        if (this.money >= money) {
            System.out.println(name + "来取钱" + money + "成功!");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余" + this.money);
        } else {
            System.out.println(name + "来取钱: 余额不足");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock(); // 解题
        }
    }
}

线程通信

多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺。

线程通信的常见模型（生产者与消费者模型）

生产者线程负责生产数据
消费者线程负责消费生产者生产的数据。

注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，再通知生产者生产。

方法名称	说明
void wait()	让当前线程等待并释放所占锁，直到另一个线程调用 notify（）方法或 notifyAll（）方法
void notify()	唤醒正在等待的单个线程
void notifyAll()	唤醒正在等待的所有线程

⚠️上述方法应该使用当前同步锁对象进行调用。

public class Desk {
    private List<String> list = new ArrayList<>();
    public synchronized void put() {
        try {
            String name = Thread.currentThread().getName();
            if (list.size() == 0) {
				list.add(name + "做的肉包子");
                System.out.println(name + "做了一个肉包子");
                Thread.sleep(2000);
                
                this.notifyAll();
                this.wait();
            } else {
                this.notifyAll();
                this.wait();
            } 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public synchronized void put() {
        try {
            String name = Thread.currentThread().getName();
            if (list.size() == 1) {
				System.out.println(name + "吃了: " + list.get(0) + "做的包子");
                list.clear();
                Thread.sleep(1000);
                
                this.notifyAll();
                this.wait();
            } else {
                this.notifyAll();
                this.wait();
            } 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
}

public class Threadtest {
    public static void main(String[] args) {
        
        Desk desk = new Desk();
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师1").start();
        
        Desk desk = new Desk();
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师2").start();
        
        Desk desk = new Desk();
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师3").start();
        
        Desk desk = new Desk();
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "吃货1").get();
        
        Desk desk = new Desk();
        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货2").start();
    }
}

线程池

认识线程池

可以复用线程的技术

不使用线程池的问题

用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，**而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，**这样会严重影响系统的性能。

如何创建线程池？

JDK 5.0 起提供了代表线程池的接口：ExecutorService。

方式一：使用 ExecutorService 的实现类 ThreadPoolExecutor 自创建一个线程池对象。

注意事项

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。

方式二：使用 Executors（线程池的工具类）调用方法返回不同特点的线程池对象。

线程池处理 Runnable 任务

ExecutorService 的常用方法

方法名称	说明
void execute (Runnable command)	执行 Runnable 任务
void shutdown()	执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果
List shutdownNow()	等全部任务执行完毕后，再关闭线程池！
Future submit (Callabl task)	立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

import java.util.concurrent.*;
public class ThreadPoolTest1 {
    public static void main(String[] args) {
        ExecutorService pool = new ThreadPoolExecutor(3, 5, TimeUnit.SECONDS, new ArrayBlockingQueue, Executors.defaultThreadFacotry new ThreadPoolExecutor.AbortPolicy());
        
        Runnable target = new MyRunnable();
        pool.execute(target); // 线性池会自动创建一个新线程，自动处理这个任务，自动执行的!
        pool.execute(target); // 线性池会自动创建一个新线程，自动处理这个任务，自动执行的!
        pool.execute(target); // 线性池会自动创建一个新线程，自动处理这个任务，自动执行的!
        pool.execute(target); // 复用前面的核心线程
        pool.execute(target); // 复用前面的核心编程
        
        // pool.shutdown(); // 等着线程池的任务全部执行完毕后，再关闭线程池
        pool.shutdownNow(); // 立即关闭线程池！ 不管任务是否执行完毕
        
    }
}

策略	详解
ThreadPoolExecutor.AbortPolicy	丢弃任务并抛出 RejectedExecutionException 异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy	丢弃任务，但是不抛出异常这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用任务的 run() 方法从而绕过线程池直接执行

线程池处理 Callable 任务

Executors 工具类实现线程池

public class ThreadPoolTest3 {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(17);
        
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));
        
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

老师: 核心线程数量到底配置多少呢？

计算密集型的任务: 核心线程数量 = CPU 的核数 + 1

IO密集型的任务：核心线程数量 = CPU 核素 * 2

Executors 使用可能存在的陷阱

其它细节知识：并发、并行

进程

正在运行的程序（软件）就是一个独立的进程。
线程是属于进程的，一个进程中可以同时运行很多个线程。
进程中的多个线程其实是并发和并行执行的。

并发的含义

进程中的线程是 由CPU负责调度 执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于 CPU切换 的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行的理解

在同一个时刻上，同时有多个线程在被CPU调度执行。

线程到底是怎么在执行的？

并发和并行同时进行的!

其它细节知识：线程的生命周期

线程的6种状态相互转换

public class MyRunnable2 implements Runable {
    // 整数修改乐观锁：原子类是实现的
    private AtomicInteger count = new AtomicInteger();
    
    @Override
    public void run() {
        for (int i = 0;i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "count =====>" + count.incrementAndGet());
        }
    }
}

public class Test2 {
    public static void main(String[] args) {
        // 目标：扩展悲观锁，乐观锁原理
        // 乐观锁：一开始不上锁，以为是没有问题的，大家一起跑，等要出现线程安全问题的时才开始控制。线程安全，性能较好。
        
        
        // 需求 1变量：100个线程，每个线程对其加 100 次
        Runnable target = new MyRunnable();
        
        for (int i = 1; i <= 100; i++) {
            new Thread(target).start();
        }
        
        
    }
}

// 热观锁
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class BankAccount {
    private double balance;
    private Lock lock = new ReentrantLock();

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public void withdraw(double amount) {
        lock.lock(); // 获取锁
        try {
            if (balance >= amount) {
                balance -= amount;
                System.out.println("Withdrawn: " + amount + ", New balance: " + balance);
            } else {
                System.out.println("Insufficient funds.");
            }
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(100.0);

        Thread t1 = new Thread(() -> account.withdraw(50));
        Thread t2 = new Thread(() -> account.withdraw(70));

        t1.start();
        t2.start();
    }
}

Java JUC基础笔记

Java JUC基础

多线程的创建

继承 Thread 类

优缺点：

注意事项

实现 Runnable 接口

方式一

优缺点

方式二

实现 Callable 接口

优缺点

Thread 的常用方法

线程安全

什么是线程安全问题

线程同步

同步思想概述

方式一：同步代码块

同步锁的注意事项

锁对象随便选择一个唯一的对象好不好呢？

锁对象的使用规范

方式二：同步方法

同步方法底层原理

方式三：Lock锁

线程通信

线程通信的常见模型（生产者与消费者模型）

线程池

认识线程池

不使用线程池的问题

如何创建线程池？

方式一：使用 ExecutorService 的实现类 ThreadPoolExecutor 自创建一个线程池对象。

注意事项

方式二：使用 Executors（线程池的工具类）调用方法返回不同特点的线程池对象。

线程池处理 Runnable 任务

ExecutorService 的常用方法

线程池处理 Callable 任务

Executors 工具类实现线程池

Executors 使用可能存在的陷阱

其它细节知识：并发、并行

进程

并发的含义

并行的理解

线程到底是怎么在执行的？

其它细节知识：线程的生命周期

线程的6种状态相互转换

悦读