Java SE多线程

最新推荐文章于 2024-09-04 20:23:24 发布
最新推荐文章于 2024-09-04 20:23:24 发布
阅读量538 收藏
点赞数
分类专栏： 学习JAVA从入门到放弃 文章标签： 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42496149/article/details/125605437
版权

目录

1️⃣多线程的创建

🗝️继承Thread类

🗝️实现Runnable接口

🗝️JDK 5.0新增：实现Callable接口

2️⃣Thread的常用方法

 3️⃣线程安全（小案例）

 4️⃣线程同步

🗝️方式一：同步代码块

 🗝️方式二：同步方法

🗝️方式三：Lock锁

 5️⃣线程通信

6️⃣线程池

🗝️线程池概述

🗝️线程池实现的API 参数说明

🗝️线程池处理Runnable任务

🗝️线程池处理Callable任务

🗝️Executors工具类实现线程池

 7️⃣定时器

1️⃣多线程的创建

🗝️继承Thread类

 

/**
  目标：多线程的创建方式之一 继承Thread类
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //3new一个线程对象
        Thread t = new MyThread();
        //4启动线程对象
        t.start();

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

/**
  1定义一个线程类继承Thread
 */
class MyThread extends Thread{
    /**
      2重写run方法
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行了 " + i);
        }
    }
}

 优点：编码简单

 缺点：线程类已经继承Thread，无法继承其他类，不利于扩展

注意🔔🔔🔔🔔🔔🔔🔔🔔🔔🔔🔔🔔🔔🔔🔔🔔

        不可以直接调用RUN方法 否则会直接当成单线程执行

        主线程任务放在子线程任务之后

🗝️实现Runnable接口

 

public class ThreadDemo2 {
    public static void main(String[] args) {
        //3创建一个任务对象
        Runnable target = new MyRunnable();
        //4把任务对象交给Thread处理
        Thread t = new Thread(target);
        //5启动线程
        t.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);
        }
    }
}

 优点：线程任务类只是实现接口，可以继续继承类和实现其他接口，拓展性强

 缺点：编程多一层对象包装，如果线程执行结果是不可以直接返回的

🗝️JDK 5.0新增：实现Callable接口

 

/**
  目标：学会线程的创建方式三，实现Callable接口，结合FutureTask完成
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        //3创建任务对象
        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);
        t1.start();

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

        try {
            String rs1 =  f1.get();
            System.out.println("第一个结果 " + rs1);

        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            String rs2 =  f2.get();
            System.out.println("第er个结果 " + rs2);

        } 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 = 0; i <= n; i++) {
            sum += i;
        }
        return "子线程的结果是" + sum;
    }
}

优点：可以返回线程执行的结果

2️⃣Thread的常用方法

⚫Thread的常用方法：获取线程名称getName()、设置名称setName()、获取当前线程对象             currentThread()

 

public class MyThread extends Thread{
    public MyThread() {
    }

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

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出 " + i );
        }
    }
}
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 t2 = new MyThread("2号");
        //t2.setName("2号");
        t2.start();
        System.out.println(t2.getName());

        //哪个线程执行它，他就得到哪个线程对象（当前线程对象）
        Thread m= Thread.currentThread();
        System.out.println(m.getName());
        m.setName("哇哈哈");

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

 3️⃣线程安全（小案例）

为什么会出现线程安全？

       ①存在多线程并发

       ②同时访问共享资源

       ③存在修改共享资源

小案例：小敏和小红是夫妻，他们有一个共同账户，余额10万元，模拟两人同时取钱

账户信息：⬇️⬇️⬇️⬇️⬇️⬇️

public class Account {
    private String ID;
    private double money;

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

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public void drawMoney(double money) {
        //1先获取谁来取钱
        String name = Thread.currentThread().getName();
        //2判断余额是否充足
        if (this.money >= money){
            //3取钱
            System.out.println(name + "来取钱，吐出" + money);
            //4更新
            this.money -= money;
            System.out.println(name + "取钱后剩余" + this.money);

        }else {
            //5余额不足
            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("ICBU-123",100000);

        //2创建两个线程对象
        new DrawThread(acc,"小敏").start();
        new DrawThread(acc,"小红").start();
    }
}

结果⬇️⬇️⬇️⬇️⬇️⬇️⬇️（出现安全问题）

 4️⃣线程同步

线程同步核心思想：把共享资源加上锁，每次只能一个线程进入访问完毕后再解锁其他线程再进来

🗝️方式一：同步代码块

 

    //同步代码块
//    public void drawMoney(double money) {
             //this == acc
//        synchronized (this) {    //代表当前对象
//            //1先获取谁来取钱
//            String name = Thread.currentThread().getName();
//            //2判断余额是否充足
//            if (this.money >= money){
//                //3取钱
//                System.out.println(name + "来取钱，吐出" + money);
//                //4更新
//                this.money -= money;
//                System.out.println(name + "取钱后剩余" + this.money);
//
//            }else {
//                //5余额不足
//                System.out.println(name + "来取钱，余额不足");
//            }
//        }
//
//    }

 🗝️方式二：同步方法

 

    //同步方法
//    public synchronized void drawMoney(double money) {
//
//            //1先获取谁来取钱
//            String name = Thread.currentThread().getName();
//            //2判断余额是否充足
//            if (this.money >= money){
//                //3取钱
//                System.out.println(name + "来取钱，吐出" + money);
//                //4更新
//                this.money -= money;
//                System.out.println(name + "取钱后剩余" + this.money);
//
//            }else {
//                //5余额不足
//                System.out.println(name + "来取钱，余额不足");
//            }
//
//
//    }

🗝️方式三：Lock锁

 

 //LOCK锁
    public  void drawMoney(double money) {

        //1先获取谁来取钱
        String name = Thread.currentThread().getName();
        //2判断余额是否充足
        //小敏 小红
        lock.lock();  //上锁
        try {
            if (this.money >= money){
                //3取钱
                System.out.println(name + "来取钱，吐出" + money);
                //4更新
                this.money -= money;
                System.out.println(name + "取钱后剩余" + this.money);

            }else {
                //5余额不足
                System.out.println(name + "来取钱，余额不足");
            }
        } finally {
            lock.unlock();//解锁
        }


    }

 5️⃣线程通信

什么是线程通信、如何实现❓

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

线程通信实际应用场景

⚫生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据

⚫要求：生产者生产完数据后唤醒消费者，然后等待自己，消费者消费完以后唤醒生产者，然后等待自己

 同上Account账户内容添加

public synchronized void drawMoney(double money) {
        try {
            String name = Thread.currentThread().getName();
            if (this.money >= money){
                //钱够 可以取
                this.money -= money;
                System.out.println(name + "来取钱" + money + "成功!余额是" + this.money);
                //没钱了
                this.notifyAll();  //唤醒所有人
                this.wait(); //锁对象 让当前线程进入等待

            }else {
                //钱不够，不可以取
                //唤醒别人 等待自己
                this.notifyAll();  //唤醒所有人
                this.wait(); //锁对象 让当前线程进入等待


            }
        } catch (Exception e) {
            e.printStackTrace();
        }

6️⃣线程池

🗝️线程池概述

 什么是线程池？

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

 

 

🗝️线程池实现的API 参数说明

 

🗝️线程池处理Runnable任务

 

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出了 " + i);

        }
        try {
            System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了，进入休眠");
            Thread.sleep(10000000);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        //1创建线程池对象
        /**
         public ThreadPoolExecutor(int corePoolSize,
                                   int maximumPoolSize,
                                   long keepAliveTime,
                                   TimeUnit unit,
                                   BlockingQueue<Runnable> workQueue,
                                   ThreadFactory threadFactory,
                                   RejectedExecutionHandler handler)
         */
        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);
        //不创建了  拒绝策略触发  因为最多5个线程
        pool.execute(target);


    }
}

 

 

🗝️线程池处理Callable任务

 

/**
 *  1定义一个任务类 实现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 = 0; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "执行1-"+ n+ "结果是" + sum;
    }
}

 

public class ThreadPoolDemo2 {
    public static void main(String[] args) throws Exception {
        //1创建线程池对象
        /**
         public ThreadPoolExecutor(int corePoolSize,
                                   int maximumPoolSize,
                                   long keepAliveTime,
                                   TimeUnit unit,
                                   BlockingQueue<Runnable> workQueue,
                                   ThreadFactory threadFactory,
                                   RejectedExecutionHandler handler)
         */
        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(200));
       Future<String> f3 = pool.submit(new MyCallable(300));
       Future<String> f4 = pool.submit(new MyCallable(400));
       Future<String> f5 = pool.submit(new MyCallable(500));

//       String rs = f1.get();
//       System.out.println(rs);
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
        System.out.println(f5.get());


    }
}

🗝️Executors工具类实现线程池

/**
  目标：使用Executors的工具方法直接得到一个线程池对象
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        //1创建固定线数据的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);

        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());//已经没有多余的线程了


    }
}

 7️⃣定时器

 

 

 

 

/**
 * 目标  Timer定时器的使用和了解
 */
public class TimerDemo1 {
    public static void main(String[] args) {
        //1创建Timer定时器
        Timer timer = new Timer();  //定时器本身就是一个单线程
        //2调用方法，处理定时器任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行一次~~~~");
            }
        },3000,2000);
    }
}

 缺点：Timer是单线程，若因为某个异常使其死掉，会影响后续的执行

public class TimerDemo2 {
    public static void main(String[] args) {
        //1创建ScheduleExceutorService线程池，做定时器
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);

       //2开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：AA");
                try {
                    Thread.sleep(100000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：BB");
                System.out.println(10 / 0);
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：CC");
            }
        },0,2, TimeUnit.SECONDS);
    }
}

 优点：基于线程池，某个任务执行挂掉不会影响后续执行

 

ヾppoiso,
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程（详细了解java多线程机制）
来了点个赞再走...
04-30 3780
每天进步一点点一、程序、进程、线程1.1 什么是程序1.2 什么是进程1.3 什么是线程1.4 进程和线程的区别二、创建线程的三种方式2.1 继承Thread类重写run()方法具体实现获取线程ID和名称修改线程名称2.2 实现Runnable接口实现run()方法具体实现使用匿名内部类2.3 实现Callable接口Callable和Thread、Runnable比较具体实现三、线程的状态3.1 基本四状态3.2 等待状态3.3 阻塞状态四、线程常用的方法4.1 线程休眠（sleep）4.2 线程放弃
Java SE文档（全）
02-09
12. **多线程**：Java内置了多线程支持，可以通过实现Runnable接口或继承Thread类创建线程，以及使用synchronized关键字和Lock接口实现线程同步。 以上只是Java SE文档中的一部分内容，实际文档会更详细地涵盖异常...
Java并发包：ExecutorService和ThreadPoolExecutor
charming的专栏
07-12 1万+
文章译自：http://tutorials.jenkov.com/java-util-concurrent/index.html 抽空翻译了一下这个教程的文章，后面会陆续放出，如有不妥，请批评指正。 转自请注明出处。 ExecutorServiceJava.util.concurrent.ExecutorService接口代表一种异步执行机制，它能够在后台执行任务。因此ExecutorSer
线程池（Java版）
weixin_52572813的博客
07-16 223
程序中如果需要使用线程，将一个执行任务传给线程池，线程池就会使用一个空闲状态的线程来执行这个任务。1)) 工作队列未满时，线程池将该任务放入工作队列中等待，当线程池中出现空闲队列时， 将该任务从工作队列中调出，交给该空闲线程执行；3. STOP：停止状态。线程池调用shutdownnow()方法，进入停止状态，此时线程池不会接受新任务，也不会处理工作队列中的任务，而且会中断工作队列中的任务。1. 向线程池提交一个新的线程任务，线程池会分配一个空闲线程来执行这个任务。
ExecutorService线程池详解
qiaziliping的博客
04-10 689
对线程池 “池”的理解 可以理解为工厂，如果工厂生产斧头，小王从工厂借了一把，当小王用完了，还给工厂，之后小李也可以借去用 复用已有资源 控制资源总量 你一个任务过来了，我发现池子里有没事干并且还活着的线程，来，拿去用，我也不用费事给你创建一条线程了，要知道线程的创建和销毁可都是麻烦事 你一个任务过来了，我发现池子的线程都在忙，并且现在池子的线程已经太多了，在不限制下去就要内存溢出了...
线程池使用
wuzj1314的博客
02-14 105
线程池使用
ExecutorService详细介绍（ThreadPoolExecutor）
城市星尘的博客
04-23 1311
ExecutorService详细介绍 ExecutorService的主要实现类为ThreadPoolExecutor，ThreadPoolExecutor的参数如下： public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
Java SE多线程(线程安全与sychornized)
qq_47201748的博客
04-09 1696
若初次接触移至多线程请先移至JavaSE 多线程初次接触 线程安全与sychornized理解1.作为了解的知识1.1 常见的线程调度模型有哪些？1.2 和线程调度有关的方法2.关于多线程并发环境下，数据的安全问题（重点）。2.1为什么这个是重点2.2什么时候会出现线程安全问题2.3如何解决线程安全问题?2.4异步编程模型与同步编程模型3.Java中三大变量4.如果使用局部变量：5.sychornized（尽我可能写的详细）5.1sychornized理解概念开发中应该怎么解决线程安全问题？（老师讲解） 1
Java多线程Callable接口
01-20
在Java SE5中引入的Callable是一种具有类型参数的泛型，它的类型参数表示的是从方法call()中返回的值，并且必须使用ExecutorService.submit()方法调用它。 import java.util.ArrayList; import java.util....
java会话管理、多线程.docx
04-21
【Java会话管理与多线程详解】 Java会话管理主要涉及的是在Web应用程序中如何维护用户的状态信息。在Web应用中，用户打开一个页面，然后进行一系列操作，这些操作可能跨越多个HTTP请求。为了保持用户的上下文信息，...
java SE最经典的桌面小程序(N多demo)适合初学者
03-22
本压缩包包含了一百个经典的Java SE桌面小程序，这些DEMO涵盖了Java的基础语法、面向对象编程、图形用户界面（GUI）设计、输入/输出处理、多线程、网络编程等多个核心知识点。 1. **基础语法**：Java是一门强类型、...
Java多线程-线程池ThreadPoolExecutor构造方法和规则
热门推荐
喵了个呜的博客
05-03 12万+
为什么用线程池博客地址 http://blog.csdn.net/qq_25806863原文地址 http://blog.csdn.net/qq_25806863/article/details/71126867有时候，系统需要处理非常多的执行时间很短的请求，如果每一个请求都开启一个新线程的话，系统就要不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会比线程真正执行的时间还长。而且当线程数
【学习笔记】卫星通信NTN 3GPP标准化进展分析（六）- 参考标准
u011376987的博客
09-01 1142
本文总结了NTN标准化进程以及后续的研究计划，是学习NTN协议的入门。本文来自3GPP Joern Krause, 3GPP MCC。
iomuxc、pinctrl子系统、gpio子系统（学习总结）
最新发布
weixin_61385844的博客
09-04 851
IOMUXC是SOC设计中实现引脚复用的关键组件，它通过动态切换引脚功能，提高了IO资源的利用率，满足了不同外设和功能的IO需求。在配置和使用IOMUXC时，需要参考芯片使用手册和设备树文档，确保引脚功能的正确设置。
Datawhale X 李宏毅苹果书AI夏令营 学习笔记
m0_61049596的博客
08-31 1312
今天，我继续学习了深度学习中的优化算法，并且着重理解了如何利用。等高级优化器来提高模型训练的效率和效果。2024年8月30日。
学习项目1
m0_62803606的博客
09-03 1601
这篇文章主要记录你最近入手的无线串口模块的配置情况，这是个很好的习惯，尤其是在你以后需要重复操作或排查问题时，会非常有帮助。- **DL_20无线串口模块**：这是一个常见的无线串口通信模块，通常基于nRF24L01+等无线通信芯片，支持点对点或多点通信，适合短距离的无线数据传输。是的，如果你按照步骤成功配置了两个模块并将它们连接到单机和电脑，当你在上位机软件（如SSCOM）上能稳定地接收到从单片机发送的数据（例如每秒输出的T值），就说明两个无线模块之间的通信已经配置成功。
Web3开发与安全：6个月高效学习路径
weixin_47075747的博客
08-30 1898
这份计划应该能帮助你系统地学习智能合约开发和安全审计技能，同时克服英语的障碍。
算法的学习笔记—把数字翻译成字符串
业精于勤，荒于嬉
08-31 960
通过动态规划的方法，我们可以高效地计算出一个数字字符串有多少种不同的翻译方法。这个问题不仅考察了我们对动态规划的理解，还让我们熟悉了如何处理字符串中的边界情况和状态转移。希望通过这个例子的讲解，能够帮助你更好地理解动态规划的应用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybit欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论
Java SE多线程详解：线程实现与同步
本资源是一份关于Java SE多线程的详细教程，由讲师秦疆提供，版权归属于西安西部开源教育科技有限公司。该系列文档是基于B站视频项目的学习总结，旨在帮助个人深入理解多线程概念和实践。 1. 线程简介： 多线程是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值