文章目录

一、多线程概述

  线程（Thread）是一个程序内部的一条执行路径。我们之前启动程序执行后，main 方法的执行其实就是一条单独的执行路径。程序中如果只有一条执行路径，那么这个程序就是单线程的程序。Java 是通过 java.lang.Thread 类来代表线程的，Thread 类提供了实现多线程的方式 。

二、多线程的创建

1.1 方式一：继承 Thread 类

步骤：

① 定义一个子类 MyThread 继承线程类 java.lang.Thread，重写 run() 方法
② 创建 MyThread 类的对象
③ 调用线程对象的 start() 方法启动线程（启动后还是执行 run 方法）

优缺点：

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

举例：

// 1、定义一个线程类继承Thread类
public class MyThread extends Thread{
     // 2、重写run方法，里面是定义线程以后要干啥
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        // 3、new一个新线程对象
        Thread t = new MyThread();
        // 4、调用start方法启动线程（执行的还是run方法）
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}

输出：
在这里插入图片描述

注意：

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

1.2 方式二：实现 Runnable 接口

步骤：

① 定义一个线程任务类 MyRunnable 实现 Runnable 接口，重写 run() 方法
② 创建 MyRunnable 任务对象
③ 把 MyRunnable 任务对象交给 Thread 处理
④ 调用线程对象的 start() 方法启动线程

构造器：

在这里插入图片描述
注：其中第一种方法，是通过子类的有参构造，来调用 Thread 类的有参构造，以此来指定线程名称（举例看Thread常用方法）

public class MyThread extends Thread{
    public MyThread(String name) {
        // 为当前线程对象设置名称，送给父类的有参数构造器初始化名称
        super(name);
    }
    @Override
    public void run() {
        ....
    }
}

优缺点：

① 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
② 缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

举例：

// 1、定义一个线程任务类 实现Runnable接口
class MyRunnable  implements Runnable {
     // 2、重写run方法，定义线程的执行任务的
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        // 3、创建一个任务对象
        Runnable target = new MyRunnable();
        // 4、把任务对象交给Thread处理
        Thread t = new Thread(target);
        // Thread t = new Thread(target, "1号");
        // 5、启动线程
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);
            // System.out.println(Thread.currentThread().getName()+"主线程执行输出：" + i); // 获取线程的名字
        }
    }
}

输出：

在这里插入图片描述
注：主线程默认 “main”，子线程默认名字 “Thread-index”，index 从 0 开始。

匿名内部类实现方案

步骤：

① 创建 Runnable 的匿名内部类对象
② 交给 Thread 处理
③ 调用线程对象的 start() 启动线程

举例：

public class ThreadDemo2Other {
    public static void main(String[] args) {
        // 创建匿名内部类对象，并交给 Thread 处理
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程1执行输出：" + i);
                }
            }
        };
        Thread t = new Thread(target);
        t.start();

        // 化简形式
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程2执行输出：" + i);
                }
            }
        }).start();

        // Lambda 化简
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("子线程3执行输出：" + i);
            }
        }).start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}

1.3 方式三：JDK 5.0新增: 实现 Callable 接口

前两种方式存在的问题：他们重写的 run 方法均不能直接返回结果，不适合需要返回线程执行结果的业务场景。

问题解决：JDK 5.0 提供了 Callable 和 FutureTask 来实现，这种方式的优点是，可以得到线程执行的结果。

步骤：

① 得到任务对象：定义类实现 Callable 接口，重写 call 方法，封装要做的事情；用 FutureTask 把 Callable 对象封装成线程任务对象。
② 把线程任务对象交给 Thread 处理。
③ 调用 Thread 的 start 方法启动线程，执行任务
④ 线程执行完毕后，通过 FutureTask 的 get 方法去获取任务执行的结果。

常用API：

在这里插入图片描述

优缺点：

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

举例：

// 1、定义一个任务类 实现 Callable 接口  应该申明线程任务执行完毕后的结果的数据类型
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

     // 2、重写call方法（任务方法）
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
            System.out.println(Thread.currentThread().getName());
        }
        return "子线程执行的结果是：" + sum;
    }
}

public class ThreadDemo3 {
    public static void main(String[] args) {
        // 3、创建 Callable 任务对象
        Callable<String> call = new MyCallable(100);
        // 4、把 Callable 任务对象 交给 FutureTask 对象
        // FutureTask 对象的作用 1： 是 Runnable 的对象（实现了 Runnable 接口），可以交给 Thread 了
        // FutureTask 对象的作用 2： 可以在线程执行完毕之后通过调用其 get 方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        // 5、交给线程处理
        Thread t1 = new Thread(f1);
        // 6、启动线程
        t1.start();

        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            // 如果 f1 任务没有执行完毕，这里的代码会等待，直到线程1 跑完才提取结果。
            String rs1 = f1.get();
            System.out.println("第一个结果：" + rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            // 如果 f2 任务没有执行完毕，这里的代码会等待，直到线程2 跑完才提取结果。
            String rs2 = f2.get();
            System.out.println("第二个结果：" + rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出：

在这里插入图片描述

1.4 三种方式对比

在这里插入图片描述

二、Thread的常用方法

在这里插入图片描述

举例1：

public class MyThread extends Thread{
    public MyThread() {
    }
    public MyThread(String name) {
        // 为当前线程对象设置名称，送给父类的有参数构造器初始化名称
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "输出：" + i);
        }
    }
}

public class ThreadDemo01 {
    // main方法是由主线程负责调度的
    public static void main(String[] args) {
        Thread t1 = new MyThread("1号");
        // t1.setName("2号");
        t1.start();

        Thread t2 = new MyThread("2号");
        t2.start();

        // 哪个线程执行它，它就得到哪个线程对象（当前线程对象）
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出：" + i);
        }
    }
}

在这里插入图片描述

举例2：

public class ThreadDemo02 {
    public static void main(String[] args) throws Exception {
        Thread t1 = new MyThread("1号");
        t1.start();
        t1.join();

        Thread t2 = new MyThread("2号");
        t2.start();
        t2.join();

        Thread t3 = new MyThread("3号");
        t3.start();
        t3.join();
    }
}

在这里插入图片描述

三、线程安全与同步

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

3.1 线程安全

线程安全问题模拟案例：

需求：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元。如果小明和小红同时来取钱，而且2人都要取钱10万元，可能出现什么问题呢？

/**
 * 账户类
 */
public class Account {
    private String cardId;
    private double money; // 账户的余额
    public Account(){
    }
    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    // 小明 小红：取钱
    public void drawMoney(double money) {
        // 0、先获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        // 1、判断账户是否够钱
        if(this.money >= money){
            // 2、取钱
            System.out.println(name + "来取钱成功，吐出：" + money);
            // 3、更新余额
            this.money -= money;
            System.out.println(name + "取钱后剩余：" + this.money);
        }else {
            // 4、余额不足
            System.out.println(name +"来取钱，余额不足！");
        }
    }
    ...
}

/**
 * 取钱的线程类
 */
public class DrawThread extends Thread {
    // 接收处理的账户对象
    private Account acc;
    public DrawThread(Account acc,String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run() {
        // 小明 小红：取钱
        acc.drawMoney(100000);
    }
}

/**
 * 需求：模拟取钱案例。
 */
public class ThreadDemo {
    public static void main(String[] args) {
        // 1、定义线程类，创建一个共享的账户对象
        Account acc = new Account("ICBC-111", 100000);

        // 2、创建2个线程对象，代表小明和小红同时进来了。
        new DrawThread(acc, "小明").start();
        new DrawThread(acc, "小红").start();
    }
}

输出：
在这里插入图片描述

分析问题：
取钱案例出现问题的原因？多个线程同时执行，发现账户都是够钱的
如何才能保证线程安全呢？让多个线程实现先后依次访问共享资源，这样就解决了安全问题

3.2 线程同步

同步思想概述：加锁，即让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

3.2.1 方式一：同步代码块

作用：把出现线程安全问题的核心代码给上锁。
原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。

在这里插入图片描述
案例修改：

// 小明 小红：取钱
public void drawMoney(double money) {
	// 1、拿到是谁来取钱
	String name = Thread.currentThread().getName();
	// 同步代码块
	synchronized (this) {
	    // 2、判断余额是否足够
	    if(this.money >= money){
	        // 钱够了
	        System.out.println(name+"来取钱，吐出：" + money);
	        // 更新余额
	        this.money -= money;
	        System.out.println(name+"取钱后，余额剩余：" + this.money);
	    }else{
	        // 3、余额不足
	        System.out.println(name+"来取钱，余额不足！");
	    }
	}
}

synchronized (共享锁对象) 共享锁对于线程来说是唯一对象即可。

如：synchronized ("acc") 对于共享同一个账户的小明小红是同一个对象，但是如果有两个共享账户，那 "acc" 这个对象也是对于两个共享账户下的不同线程而言，也是同一个对象。因此 synchronized ("acc") 不同共享账户下的线程也会使用同一把锁，即锁住了千家万户。

标准的写法 synchronized (this)，这样以来，线程对于同一个共享账户都有一把锁。

锁对象要求：规范上：建议使用共享资源作为锁对象。

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

举例静态方法：

public static void drawMoney(){
	synchronized (Account.class){
		...
	}
}

3.2.2 方式二：同步方法

作用：把出现线程安全问题的核心方法给上锁。
原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

在这里插入图片描述

底层原理：同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

如果方法是实例方法：同步方法默认用 this 作为的锁对象。
如果方法是静态方法：同步方法默认用 类名.class 作为的锁对象。

案例修改：

// 小明 小红：取钱
public synchronized void drawMoney(double money) {
	// 1、拿到是谁来取钱
	String name = Thread.currentThread().getName();
	// 2、判断余额是否足够
	// 小明  小红
	if(this.money >= money){
	    // 钱够了
	    System.out.println(name+"来取钱，吐出：" + money);
	    // 更新余额
	    this.money -= money;
	    System.out.println(name+"取钱后，余额剩余：" + this.money);
	}else{
	    // 3、余额不足
	    System.out.println(name+"来取钱，余额不足！");
	}
}

输出：
在这里插入图片描述

两种方式对比：同步代码块锁的范围更小，同步方法锁的范围更大。

3.2.3 方式三：Lock锁

为了更清晰的表达如何加锁和释放锁，JDK5 以后提供了一个新的锁对象 Lock，更加灵活、方便。
Lock 实现提供比使用 synchronized 方法和语句可以获得更广泛的锁定操作。
Lock 是接口不能直接实例化，这里采用它的实现类 ReentrantLock 来构建 Lock 锁对象。

在这里插入图片描述
案例修改：

// 方法里面定义Lock锁的实现类对象的成员变量
private final Lock lock = new ReentrantLock();
// 小明 小红：取钱
public void drawMoney(double money) {
	// 1、拿到是谁来取钱
	String name = Thread.currentThread().getName();
	// 2、判断余额是否足够
	// 小明  小红
	lock.lock(); // 上锁
	try {
	    if(this.money >= money){
	        // 钱够了
	        System.out.println(name+"来取钱，吐出：" + money);
	        // 更新余额
	        this.money -= money;
	        System.out.println(name+"取钱后，余额剩余：" + this.money);
	    }else{
	        // 3、余额不足
	        System.out.println(name+"来取钱，余额不足！");
	    }
	} finally {
	    lock.unlock(); // 解锁
	}
}

四、线程通信

线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。

常见形式：通过共享一个数据的方式实现。根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

实际应用场景：生产者与消费者模型，生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。
要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。

参考：经典同步问题：https://blog.csdn.net/weixin_43819566/article/details/128824443

Object类的等待和唤醒方法：

在这里插入图片描述

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

五、线程池 ★

5.1 线程池概述

线程池就是一个可以复用线程的技术。

不使用线程池存在的问题：如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

工作原理：
在这里插入图片描述

5.2 线程池实现的API

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

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

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

在这里插入图片描述

参数说明：

参数一：指定线程池的线程数量（核心线程）： corePoolSize，不能小于0
参数二：指定线程池可支持的最大线程数： maximumPoolSize， 最大数量 >= 核心线程数量
参数三：指定临时线程的最大存活时间： keepAliveTime，不能小于0
参数四：指定存活时间的单位(秒、分、时、天)： unit，时间单位
参数五：指定任务队列： workQueue，不能为null
参数六：指定用哪个线程工厂创建线程： threadFactory，不能为null
参数七：策略，指定线程忙，任务满的时候，新任务来了怎么办： handler，不能为null

ExecutorService 的常用方法：
在这里插入图片描述
新任务拒绝策略：

在这里插入图片描述

5.2.1 线程池处理Runnable任务

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 输出了：HelloWorld");
        try {
            System.out.println(Thread.currentThread().getName() + " 线程进入休眠");
            Thread.sleep(3000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        // 1. 创建线程池对象：3个核心线程、2个临时线程（5-3）、任务队列容量为 5，表示还可以缓存 5个任务
        // 当核心线程全被占用，任务队列也满，再有任务需要处理时，才会创建临时线程 
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 6, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
                
        // 2. 给任务线程池处理
        Runnable target = new MyRunnable();       
        pool.execute(target); // 线程池自动创建一个新线程，自动处理这个任务
        pool.execute(target); // 线程池自动创建一个新线程，自动处理这个任务
        pool.execute(target); // 线程池自动创建一个新线程，自动处理这个任务

        pool.execute(target); // 进入任务队列
        pool.execute(target); // 进入任务队列
        pool.execute(target); // 进入任务队列
        pool.execute(target); // 进入任务队列
        pool.execute(target); // 进入任务队列
        
        pool.execute(target); // 创建临时线程
        pool.execute(target); // 创建临时线程

        // pool.execute(target); // 拒绝创建

        // (了解)关闭线程池
        // pool.shutdownNow(); // 立即关闭，即使任务没有完成，会丢失任务
        // pool.shutdown(); // 会等待全部任务执行完之后再关闭
    }
}

注：当核心线程全被占用，任务队列也满，再有任务需要处理时，才会创建临时线程。

5.2.2 线程池处理 Callable 任务

public class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    /**
       2、重写call方法（任务方法）
     */
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return Thread.currentThread().getName()
                + "执行 1-" + n + "的和，结果是：" + sum;
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) throws Exception {
        // 1. 创建线程池对象：3个核心线程、2个临时线程（5-3）、任务队列容量为 5 
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 6, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        // 2. 给任务线程池处理
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(100));
        Future<String> f3 = pool.submit(new MyCallable(100));
        Future<String> f4 = pool.submit(new MyCallable(100));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

注：Future 是 FutureTask 的 父接口

5.2.3 面试题

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

5.3 Executors工具类实现线程池

得到线程池对象的常用方法：

在这里插入图片描述
注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。

可能存在的陷阱：大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

在这里插入图片描述
注：OOM 指内存溢出。

在这里插入图片描述

文章参考：Java入门基础视频教程，java零基础自学就选黑马程序员Java入门教程（含Java项目和Java真题）

# java # jvm # 开发语言
Logo
CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

嵌入式作业（七）：基于Ardunio的STM32串口通信

嵌入式作业（七）0作业要求1Ardunio 完成STM32的串口通信（1）安装Ardunio IDE（2）stm32串口通信2关于 stduino IDE0作业要求安装 Ardunio IDE 和相关软件支持库，在Ardunio 完成STM32板子的串口通信程序：（1）持续向串口输出“Hello world！”；（2）当接收到“stop!”时，停止输出。网上有一个国人版的MCU集成开发平台， st

avatar CSDN学习社区

JDBC详解

JDBC文章目录JDBC什么是JDBC?JDBC驱动程序:Java使用JDBC访问数据库的步骤:设置classpath:Oracle连接字符串的书写格式:简单的例子:常用数据库的驱动程序及JDBC URL:Oracle数据库:SQL Server数据库MySQL数据库Access数据库PreparedStatement接口:JNDI-数据源（Data Source）与连接池（Connection

avatar CSDN学习社区

“模式识别与机器学习”学习笔记no2.再谈感知机

接**上篇：上篇主要进行了PLA，Pocket算法的理论过程分析和在给定数据集上利用pocket算法对数据集进行分类学习，得到错分数量最少的分类面。上篇中pocket算法的过程已经进行了编程和测试，框架已经建立了起来，这一篇主要上篇中没有提到或涉及不深的几个问题。1.数据集的构造。上篇是直接使用了题目给的向量，这次来根据正态分布来产生数据集。np.random.normal函数可以根据均值和方差生

avatar CSDN学习社区