Java基础——多线程

1. 线程

是一个程序内部的一条执行流程
程序中如果只有一条执行流程，那这个程序就是单线程的程序

2. 多线程

指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）

2.1. 如何创建多条线程

Java通过java.lang.Thread类的对象来代表线程

2.1.1. 方式一：继承Thread类

// 1. 继承Thread类
public class MyThread extends Thread{// 2. 重写run方法@Overridepublic void run() {System.out.println("子线程");}
}

public static void main(String[] args) {// 3. 创建子线程对象Thread t = new MyThread();// 4. 启动子线程t.start();System.out.println("主线程");
}

优点：编码简单
缺点：已经继承Thread，无法继承其他类，不利于功能的扩展
启动线程必须调用start方法，而不能调用run方法，否则会将线程对象当作一个普通的对象。
不要把主线程任务放在启动子线程之前。

2.1.2. 方式二：实现Runnable接口

// 1. 定义任务类, 实现Runnable接口
public class MyRunnable implements Runnable {// 2. 重写run方法@Overridepublic void run() {System.out.println("Runnable子线程");}
}

public static void main(String[] args) {// 3. 创建一个任务对象Runnable runnable = new MyRunnable();// 4. 把任务对象交给一个线程对象, 启动线程new Thread(runnable).start();System.out.println("主线程");
}

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

2.1.3. 方式三：利用Callable接口、FutureTask类实现

以上两种方式的问题：如果线程执行完毕后有一些数据需要返回，他们重写的run方法均不能直接返回结果。
使用Callable接口，可以返回线程执行完毕后的结果

未来任务对象的作用，是一个任务对象，实现了Runnable接口；可以在线程执行完毕之后，用未来任务对象调用get方法获取执行完的返回结果。

// 1. 实现Callable接口
public class MyCallable implements Callable<String> {// 2. 重写call方法@Overridepublic String call() throws Exception {// 描述线程任务, 返回线程执行后的结果int sum = 0;for(int i = 1; i <= 100; i++){sum += i;}return String.valueOf(sum);}
}

public static void main(String[] args) throws ExecutionException, InterruptedException {// 3. 创建一个Callable对象Callable<String> callable = new MyCallable();// 4. 将Callable对象封装成FutureTask任务对象FutureTask<String> futureTask = new FutureTask<>(callable);// 5. 使用任务对象创建一个线程对象, 并启动new Thread(futureTask).start();// 6. 获取线程执行完毕返回的结果String s = futureTask.get();System.out.println(s);
}

2.2. Thread的常用方法

3. 线程安全

多个线程，同时访问同一共享资源，且存在修改该资源的时候，可能会出现业务安全问题

4. 线程同步

是用于解决线程安全问题的方案
让多个线程实现先后依次访问共享资源，这样就解决了安全问题

4.1. 线程同步的方案

加锁，每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程再加锁进来。

4.2. 加锁的方式

4.2.1. 方式一：同步代码块

作用：把访问共享资源的核心代码块给上锁，以此保证线程安全
写法

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行
注意事项：对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象）
Ctrl + ALT + T选第九个，快速生成同步代码块
建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象；静态方法建议使用字节码（类名.class）对象作为锁对象

4.2.2. 方式二：同步方法

作用：把访问共享资源的核心方法给上锁，以此保证线程安全。

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行

4.2.3. 方式三：Lock锁

可以通过它创建锁对象，进行加锁和解锁
Lock是接口，不能直接实例化，可以采用他的实现类ReentrantLock来创建锁对象。

5. 线程通信

当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，一相互协调，并避免无效的资源争夺
生产者消费者问题

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

public class Test5 {public static void main(String[] args) {// 有三个生产者线程负责生产包子, 每次只能有一个包子放在桌子上// 两个消费者线程负责吃包子, 每次只有一个线程能将包子吃掉// 1. 创建一个桌子对象Desk desk = new Desk();// 2. 创建三个厨师线程new Thread(() ->{while (true) {desk.put(); // 抢桌子}}, "厨师1").start();new Thread(() ->{while (true) {desk.put(); // 抢桌子}}, "厨师2").start();new Thread(() ->{while (true) {desk.put(); // 抢桌子}}, "厨师3").start();// 3. 创建两个吃货线程new Thread(() -> {while (true){desk.get();}},"吃货1").start();new Thread(() -> {while (true){desk.get();}},"吃货2").start();}
}

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 get() {try {if(list.size() == 1){ // 有包子String name = Thread.currentThread().getName();System.out.println(name + "吃了" + list.get(0));list.clear(); // 清空Thread.sleep(1000);// 唤醒别人, 等待自己this.notifyAll();this.wait();} else {// 唤醒别人, 等待自己this.notifyAll();this.wait();}}catch (InterruptedException e) {throw new RuntimeException(e);}}
}

6. 线程池

线程池就是一个可以复用线程的技术
代表线程池的接口，ExecutorService

6.1. 创建线程池对象

6.1.1. 使用ExecutorService的实现类ThreadPoolExecutor创建线程池对象

// 通过ThreadPoolExecutor创建一个线程池对象
/*
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)*/
ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

注意事项：