Java基础加强15-多线程、线程同步、并发/并行

于 2025-10-18 01:00:32 发布
阅读量623 收藏 2
点赞数 23
CC 4.0 BY-SA版权
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Chen_z_b/article/details/153420495

前言：

这个系列记录了我学习面向语言Java的完整过程，可以当作笔记使用。

每篇文章都包含可运行的代码示例和常见错误分析，尤其适合没有编程经验的读者。学习时建议先准备好安装JDK（Java Development Kit）和IDEA（IntelliJ IDEA集成开发环境），随时尝试修改示例代码。

一，多线程

1，三种创建方式：

方式一：

示例：

public class Test {
    //main方法本身是由一条主线程负责推荐执行的。
    public static void main(String[] args) {
        //目标：认识多线程，掌握创建线程的方式一：继承Thread类来实现
        //4，创建线程类的对象，代表线程。
        Thread t1 = new MyThread();//多态写法
        //5，调用线程类的start方法，启动线程。调用run方法执行的。
        t1.start();

        for(int i = 0; i < 5; i++){
            System.out.println("主线程输出："+i);
        }
    }
}
//1，定义一个子类继承Thread类，成为一个线程类
class MyThread extends Thread{
    //2，重写Tread类中的run方法
    @Override
    public void run() {
        //3,在run方法中编写线程要执行的任务代码（线程要干的活儿）
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出："+i);
        }
    }
}

方式二：

示例：

public class ThreadDemo2 {
    public static void main(String[] args) {
        //目标：掌握多线程的创建方式二：实现Runnable接口来创建。
        //3,创建线程任务类的对象代表一个线程任务。
        Runnable r = new MyRunnable();
        //4,把线程任务对象交给一个线程对象来处理
        Thread t1 = new Thread(r);//public Thread(Runnable target)
        //5,启动线程
        t1.start();

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

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

使用匿名内部类化简操作：

public class ThreadDemo2_2 {
    public static void main(String[] args) {
        //目标：掌握多线程的创建方式2：使用Runnable接口的匿名内部类来创建
        //1，通过匿名内部类来创建线程任务类对象
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for(int i = 0; i < 5; i++){
                    System.out.println("子线程输出："+i);
                }
            }
        };
        //2,把线程任务对象交给一个线程对象来处理
        Thread t1 = new Thread(r);//public Thread(Runnable target)
        //3,启动线程
        t1.start();

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

方式三：

示例：

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

public class ThreadDemo3 {
    public static void main(String[] args) {
        //目标：掌握多线程的创建方式三：实现Callable接口
        //优势：可以获取线程执行完毕后的结果
        //3,创建一个Callable接口的实现类对象
        Callable<String> c1 = new MyCallable(100);
        //4,把Callable对象封装成一个真正的线程任务对象FutureTask对象
        /**
         * 未来任务对象的作用：
         * a,本质是一个Runnable线程任务对象，可以交给Thread线程对象处理
         * b,可以获取线程执行完毕后的结果
         */
        FutureTask<String> f1 = new FutureTask<>(c1);//public FutureTask(Callable<V> callable)
        //5，把FutureTask对象交给Thread线程对象处理
        Thread t1 = new Thread(f1);
        //6，启动线程
        t1.start();


        Callable<String> c2 = new MyCallable(50);
        FutureTask<String> f2 = new FutureTask<>(c2);//public FutureTask(Callable<V> callable)
        Thread t2 = new Thread(f2);
        t2.start();

        //获取线程执行完毕后返回的结果
        try {
            //如果主线程发现第一个线程还没有执行完毕，会让出 CPU，
            // 等第一个线程执行完毕后，才会往下执行！
            System.out.println(f1.get());
        }catch (Exception e){
            e.printStackTrace();
        }
        try {
            //如果主线程发现第二个线程还没有执行完毕，会让出 CPU，
            // 等第二个线程执行完毕后，才会往下执行！
            System.out.println(f2.get());
        }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;
    }
}

对比：

2，Thread的常用方法：

二，线程同步

认识：

方式一：同步代码块

示例：

public void drawMoney(double money) {
    // 拿到当前谁来取钱。
    String name = Thread.currentThread().getName();
    // 判断余额是否足够
    synchronized (this) {
        if (this.money >= money) {
            // 余额足够，取钱
            System.out.println(name + "取钱成功，吐出了" + money + "元成功！");
            // 更新余额
            this.money -= money;
            System.out.println(name + "取钱成功，取钱后，余额剩余" + this.money + "元");
        } else {
            // 余额不足
            System.out.println(name + "取钱失败，余额不足");
        }
    }
}

注：

方式二：同步方法

示例：

public synchronized 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 + "取钱失败，余额不足");
    }
}

方式三：lock锁

private final Lock lk = new ReentrantLock(); // 保护锁对象
// 小明和小红都到这里来了取钱
public void drawMoney(double money) {
    // 拿到当前谁来取钱。
    String name = Thread.currentThread().getName();
    lk.lock(); // 上锁
    try {
        // 判断余额是否足够
        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();// 解锁
    }
}

final：确保保护锁对象不被更改。

finally 块：用于确保无论 try 块中的代码是否正常执行（是否发生异常），finally 块中的代码都会被执行。可以用来确保锁一定被释放。

三，线程池

认识：

方式一：

示例：

参数四：

TimeUnit.SECONDS：秒。        TimeUnit.MINUTES：分钟。

TimeUnit.HOURS：小时。        TimeUnit.DAYS：天。

参数七：

注意事项：

 方式二：

示例：

ExecutorService的常用方法：

执行Runnable任务：

执行Callable任务并返回未来任务对象，然后用返回的对象调用get拿线程返回结果：

四，并发/并行

纵横八荒
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值