Java-多线程

最新推荐文章于 2025-12-21 21:47:42 发布

原创最新推荐文章于 2025-12-21 21:47:42 发布 · 1k 阅读

30 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

1.线程的三种创建方式

1.1线程创建方式一：继承Thread类

2.线程创建方式二：实现Runnable接口

3.线程创建方式三：实现Callable接口

6.5 创建线程池方式二：Executors工具类实现线程池（了解）

7.并发、并行

8.线程的生命周期

1.线程的三种创建方式

1.1线程创建方式一：继承Thread类

package com.itheima.d1_thread_create;

public class ThreadDemo1 {
    // 注意：main方法本身就是由一条主线程负责执行的。
    public static void main(String[] args) {
        // 目标：掌握线程的创建方式一：继承Thread类。
        // 3、创建线程对象代表具体的线程
        Thread t = new MyThread();
        // 4、启动线程 : 会自动执行线程的run方法
        // 如果直接调用run,CPU不会注册新线程执行，此时相当于还是单线程
        t.start();

        for (int i = 0; i < 4 ; i++) {
            System.out.println("main线程输出：" + i);
        }
    }
}

// 1、定义一个类继承Thread类，成为线程类
class MyThread extends Thread{
    // 2、重写run方法 ，声明线程要干的事情
    @Override
    public void run() {
        for (int i = 0; i < 4 ; i++) {
            System.out.println("子线程输出：" + i);
        }
    }
}

2.线程创建方式二：实现Runnable接口

package com.itheima.d1_thread_create;

public class ThreadDemo2 {
    public static void main(String[] args) {
        // 目标：掌握多线程的创建方式二：实现Runnable接口的方式。
        // 3、创建任务类的一个对象
        Runnable target = new MyRunnable();
        // 4、把任务对象交给线程对象
        // public Thread(Runnable task, String name)
        // String name为子线程赋予了一个名字
        Thread t = new Thread(target, "1号");
        // 5、启动线程
        t.start();


        for (int i = 0; i < 4 ; i++) {
            System.out.println("main线程输出：" + i);
        }
    }
}

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

匿名内部类写法

package com.itheima.d1_thread_create;

public class ThreadDemo2_2 {
    public static void main(String[] args) {
        // 目标：掌握多线程的创建方式二：实现Runnable接口的方式。
        // 1、创建任务类的一个对象
        //使用匿名内部类直接隐式地实现Runable接口，不需要显示使用implements关键字
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 4 ; 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 < 4 ; i++) {
                    System.out.println("子线程2输出：" + i);
                }
            }
        }).start();

        new Thread(() -> {
                for (int i = 0; i < 4 ; i++) {
                    System.out.println("子线程3输出：" + i);
                }
        }).start();
    }
}

3.线程创建方式三：实现Callable接口

package com.itheima.d1_thread_create;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ThreadDemo3 {
    public static void main(String[] args) {
        // 目标：掌握多线程的创建方式三：可以返回线程执行完毕后的结果。
        // 3、创建Callbable对象
        Callable<String> call = new MyCallable(100);
        // 4、把Callable对象，封装成FutureTask对象
        //  未来任务对象有两个作用：
        //    它是一个Runnable对象
        //    它可以获取线程执行后的结果。
        //Runnable task = new FutureTask<>(call);//多态
        FutureTask<String> task = new FutureTask<>(call);
        // 5、把未来任务对象交给线程对象
        Thread t =  new Thread(task);
        // 6、启动线程
        t.start();

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

        try {
            // 如果第一个线程没有执行完毕，会在这里等待第一个线程执行完毕后，再取结果
            String rs1 = task.get();
            System.out.println(rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            String rs1 = task2.get();
            System.out.println(rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 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;
        }
        return "子线程求和1-" + n + "的结果是：" + sum;
    }
}

三种线程创建方式的对比：

继承 Thread 类：简单直接，但存在单继承的局限性。
实现 Runnable 接口：灵活且能共享资源，不过没有返回值。
实现 Callable 接口：能获取返回值，但使用起来相对复杂。

在实际开发中，优先考虑使用实现接口的方式，尤其是 Callable 接口，这样可以获得更好的扩展性和功能支持。

2.线程的API

2.1 线程API

package com.itheima.d2_thread_api;

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread("1号线程");
        // t1.setName("1号线程");
        t1.start();
        System.out.println(t1.getName()); //Thread-0

        Thread t2 = new MyThread("2号线程");
        //也可以用有参构造器设置名字，如上
        //t2.setName("2号线程");
        t2.start();
        System.out.println(t2.getName()); //Thread-0

        // 这个代码是哪个线程在执行，就会得到哪个线程对象。
        Thread m = Thread.currentThread();
        m.setName("最牛的");
        System.out.println(m.getName()); // main

        for (int i = 0; i < 4; i++) {
            System.out.println(m.getName() + "线程输出：" + i);
        }
    }
}

// 1、定义一个类继承Thread类，成为线程类
class MyThread extends Thread {
    public MyThread(String name){
        //用super(name)把name送给父类Thread的public Thread(String name)
        super(name);
    }
    // 2、重写run方法 ，声明线程要干的事情
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            // 当前线程对象的名字
            System.out.println(Thread.currentThread().getName() + " => 线程输出：" + i);
        }
    }
}

2.2 线程休眠

package com.itheima.d2_thread_api;

public class ThreadDemo2 {
    public static void main(String[] args) throws Exception {
        // 目标：掌握线程休眠，线程join.
        for (int i = 1; i <= 5 ; i++) {
            System.out.println("输出：" + i);
            // 作用：让当前线程执行的慢一点
            // 项目经理让我写上这行代码，用户交钱了，我就注释了！
            Thread.sleep(1000); // 休眠1s后再执行
        }
    }
}

2.3 join线程

package com.itheima.d2_thread_api;

public class ThreadDemo3 {
    public static void main(String[] args) throws Exception {
        // 目标：join线程
        Thread t = new MyThread2();
        t.start();

        for (int i = 0; i < 4; i++) {
            System.out.println("main线程输出：" + i);
            if(i == 2){
                t.join(); // 让t插队先执行完毕！
            }
        }
    }
}

// 1、定义一个类继承Thread类，成为线程类
class MyThread2 extends Thread {
    // 2、重写run方法 ，声明线程要干的事情
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            System.out.println("子线程输出：" + i);
        }
    }
}

3.线程安全

3.1 什么是线程安全？

3.2 取钱案例

package com.itheima.d3_thread_safe;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Account {
    private String cardId;
    private double money; // 余额

    // 小明 小红拿同一个账户对象acc取钱。
    public void drawMoney(double money) {
        //用当前线程对象来取当前的用户名
        String name = Thread.currentThread().getName();
        if(this.money >= money){
            System.out.println(name + "取钱成功，吐出：" + money);
            // 更新余额
            this.money -= money;

            System.out.println(name + "取钱成功后，账户余额剩余：" +  this.money);
        }else {
            System.out.println(name + "来取钱：余额不足！");
        }
    }
}

4.线程同步

加锁之后，当锁对象会随机让一个线程进入去进行取钱操作，当一个线程进入之后，另一个线程就必须在外面等待，当第一个线程结束之后，才可以进入。

4.1 同步代码块

如果是静态方法就用类名.class作为锁，如：

public static void test(){
    synchronized(Account.calss){
    
    }
}

而实例方法中就用this作为锁，就如上面的取钱案例，前提是代码必须高度的面向对象。

如何理解synchronized(this)?

在这个例子中，this指的就是调用drawMoney方法的Account对象实例，也就是acc。当小明和小红这两个线程同时调用同一个acc对象的drawMoney方法时，会发生以下情况：

线程需要先获取acc对象的锁。
只有拿到锁的线程才能执行同步代码块中的内容。
执行完成后释放锁，另一个线程才可以获取锁并执行。

锁的对象：必须是多个线程共享的对象。在这个例子中，acc是小明和小红线程共享的，所以可以用this。

// 写法1：同步代码块
public void drawMoney(double money) {
    synchronized (this) {
        // 临界区代码
    }
}

// 写法2：同步方法（隐式使用this）
public synchronized void drawMoney(double money) {
    // 临界区代码
}

如果使用synchronized ("LOCK")或者任何字符串字面量作为锁对象是一个严重的错误。

全局锁问题

假设有两个完全无关的类：

// 银行账户类
public class BankAccount {
    public void withdraw() {
        synchronized ("LOCK") {
            // 取钱操作
        }
    }
}

// 用户信息类
public class UserProfile {
    public void updateName() {
        synchronized ("LOCK") {
            // 更新用户名
        }
    }
}

不同类的方法意外共用同一把锁

虽然BankAccount和UserProfile是两个完全不同的类，但它们的同步块使用了相同的字符串锁"LOCK"。这意味着：

当一个线程在执行bankAccount.withdraw()时
另一个完全无关的线程在执行userProfile.updateName()时会被阻塞
即使这两个操作根本不涉及共享资源

所有使用相同字符串的地方都会冲突

Java 中所有相同内容的字符串字面量实际上是同一个对象。例如：

synchronized ("HELLO") { ... } // 锁1
synchronized ("HELLO") { ... } // 锁2，与锁1相同！

上面这两个同步块使用的是同一把锁，即使它们在不同的类或方法中。

一定要避免使用字符串常量或包装类作为锁，控制好锁的范围。

4.2 同步方法

是同步代码块好还是同步方法好一点？

范围上：同步代码块锁的范围更小，同步方法锁的范围更大
可读性：同步方法更好

4.3 Lock锁

package com.itheima.d6_thread_synchronized_lock;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Data
@NoArgsConstructor
public class Account {
    private String cardId;
    private  double money; // 余额
    //得到一个锁对象，保证当前账户只有一个唯一的锁
    private final Lock lk = new ReentrantLock();

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    // 小明 小红拿同一个账户对象acc取钱。、
    public void drawMoney(double money) {
        String name = Thread.currentThread().getName();
        try {
            lk.lock(); // 加锁
            if(this.money >= money){
                System.out.println(name + "取钱成功，吐出：" + money);
                // 更新余额
                this.money -= money;

                System.out.println(name + "取钱成功后，账户余额剩余：" +  this.money);
            }else {
                System.out.println(name + "来取钱：余额不足！");
            }
        } finally {
            lk.unlock(); // 解锁
        }

    }
}

为什么Account对象类中需要重新写构造器？

因为如果Account类使用了Lombok的@AllArgsConstructor注解，这会生成一个包含所有字段的构造器，包括Lock lk。因此当你尝试使用new Account("ICBC-110", 100000)创建对象时，编译器会报错，因为这个构造器实际上需要三个参数：cardId、money和lk。

错误原因：

@AllArgsConstructor生成的构造器签名为：

public Account(String cardId, double money, Lock lk) { ... }

而我们在调用时只提供了两个参数，缺少Lock类型的参数，导致不匹配。

解决方案

1.使用无参构造器并通过setter设置属性

Account acc = new Account();
acc.setCardId("ICBC-110");
acc.setMoney(100000);

2.显式提供需要的参数

手动传入Lock实例（不推荐，因为会破坏锁的唯一性）：

Account acc = new Account("ICBC-110", 100000, new ReentrantLock());

3. 使用@RequiredArgsConstructor代替@AllArgsConstructor

@RequiredArgsConstructor工作机制

final 字段

如果已初始化（如lk）：不会出现在构造器参数中
如果未初始化：必须通过构造器初始化，因此会出现在参数列表中

@NonNull 字段

如果已初始化：不会出现在构造器参数中
如果未初始化（如cardId和money）：必须通过构造器传入非空值，因此会出现在参数列表中

这里的lk是已经被 new ReentrantLock() 初始的lk字段，不会出现在构造器参数中。

4.手动编写需要的构造器

显示定义只包含cardId和money的构造器，覆盖Lombok生成的构造器：

@Data
@NoArgsConstructor
@AllArgsConstructor // 生成的构造器会被手动构造器覆盖
public class Account {
    private String cardId;
    private double money;
    private final Lock lk = new ReentrantLock();

    // 手动构造器，只初始化需要的字段
    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }
    // ... 其他代码不变
}

推荐方案：
使用@RequiredArgsConstructor或手动编写构造器，既能保证锁的唯一性，又能提供简洁的对象创建方式。