Java学习day07-Java高级编程-多线程

最新推荐文章于 2024-05-16 20:42:16 发布
最新推荐文章于 2024-05-16 20:42:16 发布
阅读量162 收藏
点赞数
分类专栏： Java学习笔记 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36820823/article/details/120886740
版权

Java多线程

IntelliJ IDEA介绍

Eclipse->IBM IntelliJ IDEA->JetBrains
IDEA安装连接
在这里插入图片描述

IDEA和Eclipse的区别

IDEA中一个project相当于eclipse中的workspace。IDEA中的Module相当于Eclipse中的Module.在IDEA的工程中建立模块，模块中可以建立很多的包，包里面建立类。
在这里插入图片描述
一个项目由多个模块组成，模块之间并发运行。
在这里插入图片描述
IDEA主体字体修改视频教程
模板配置视频教程

基本概念：程序、进程、线程

程序：为了完成指定任务、用某种语言编写的一组指令的集合、
进程：程序的一次执行过程，正在运行的程序
线程：程序可以进一步细化为多个线程，是一个程序内部的一条执行路径。

并行：多个CPU同时执行多个任务
并发：一个CPU分多个时间片执行多个任务

单核CPU：一个计算引擎
多核CPU：一个CPU有多个计算引擎

线程的创建和使用 2种

在这里插入图片描述

第一种创建线程的方式

方法1：继承于Thread类
1.创建一个继承于Thread类的子类
2.重写Thread类的run()， 把创建线程需要做的事情写在run方法中
3.创建Thread类的子类对象
4.通过此类对象调用start()

package com.multithread.java;

/*
@author LiRui
@create 2021-10-26 16:52
*/

class MyThread extends Thread{//1.继承Thread类
    //2.重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread1");
        }
    }
}

class MyThread2 extends Thread{//1.继承Thread类
    //2.重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread2");
        }
    }
}
public class MultiThreadTest {
    public static void main(String[] args) {
        //3.创建子类对象
        MyThread t1 = new MyThread();
        MyThread2 t2 = new MyThread2();
        //4.通过此类对象调用start()
        t1.start();
        t2.start();
    }
}

问题1：不能直接调用run()的方式启动线程
问题2：再启动一个线程, 遍历100以内的偶数, 不可以让已经start()的线程去执行

多线程中常用的方法

1.start()启动当前线程；调用当前线程的run();
2.run(): 通常需要重写Thread类中的方法
3.currentThread()静态方法，返回执行当前代码的线程
4.getName():获取当前线程的名字
5.setName();设置当前线程的名字
6.yield() 释放当前CPU时间片
7.join()在线程a中调用线程b的join，此时线程a就进入阻塞状态，直到线程b‘完全执行以后，线程a才结束阻塞状态。
8.sleep(N)线程阻塞N ms

线程的调度

在这里插入图片描述
在这里插入图片描述

第二种线程创建方法

创建一个类实现Runnable接口，然后重写run()方法，再用该类的对象p去给Thread§构造函数, 调用start()方法

package com.multithread.java;/*
@author LiRui
@create 2021-10-27 10:01
*/

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

public class ThreadTest2 {
    public static void main(String[] args) {
        MThread p = new MThread();
        new Thread(p).start();//匿名对象调用方法,参数传递为多态性
    }
}

两种方式的对比

实现的方式要更好，继承在类的继承方面有局限性比如继承Thread类的类有父类需要继承，但是接口的实现可以完成多继承。对于共享的变量，继承的方式需要设置成静态的。

线程的生命周期

Thread类中定义了枚举类中包含六个类型来表示一个线程的不同状态。
NEW,RUNNABLE,BLOCKED,WATING,TIMED_WAITING,TERMINATED.
分别是，新建，就绪，运行，阻塞，死亡。
在这里插入图片描述
哪些操作会从一种状态到另一种状态
在这里插入图片描述

线程的同步 3种

主要解决线程的安全问题,主要是采用同步锁的方式。

方法1：同步代码块

synchronized(同步监视器){
//需要被同步的代码
}
说明：操作共享数据的代码，即为需要被同步的代码。共享数据：多个线程共享的数据。同步监视器：俗称，锁。任何一个类的对象都可以充当锁。要求：多个线程必须要共用同一把锁。

package com.multithread.java;/*
@author LiRui
@create 2021-10-27 10:01
*/

class MThread implements Runnable{
    private int number=100;
    Object obj =new Object();
    @Override
    public void run() {
        synchronized (obj){
        while (number>0){
            System.out.println(Thread.currentThread().getName()+":"+number);
            number--;
        }
        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) {
        MThread p = new MThread();
        Thread t1= new Thread(p);
        Thread t2= new Thread(p);
        Thread t3= new Thread(p);
        t1.start();
        t2.start();
        t3.start();
    }
}

方法2：同步方法

如果操作数据的代码正好声明在一个方法中，我们不妨将此方法声明为同步的。

package com.multithread.java;/*
@author LiRui
@create 2021-10-27 10:01
*/

class MThread implements Runnable{
    private int number=100;
    @Override
    public void run() {

        while (true){
            show();
        }

    }

    private synchronized void show(){//同步监视器是this
        if (number>0){
            System.out.println(Thread.currentThread().getName()+":"+number);
            number--;
        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) {
        MThread p = new MThread();
        Thread t1= new Thread(p);
        Thread t2= new Thread(p);
        Thread t3= new Thread(p);
        t1.start();
        t2.start();
        t3.start();
    }
}

线程死锁问题

在这里插入图片描述

方法3：锁 JDK5.0新加

在这里插入图片描述

package com.multithread.java;/*
@author LiRui
@create 2021-10-27 10:01
*/

import java.util.concurrent.locks.ReentrantLock;

class MThread implements Runnable{
    private int number=100;
    private ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {

        while (true){
            try {
                lock.lock();
                if (number>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number--;
                }else{
                    break;
                }
            }finally {
                lock.unlock();
            }
        }

    }

}

public class ThreadTest2 {
    public static void main(String[] args) {
        MThread p = new MThread();
        Thread t1= new Thread(p);
        Thread t2= new Thread(p);
        Thread t3= new Thread(p);
        t1.start();
        t2.start();
        t3.start();
        System.out.println("Finished");
    }
}

线程的通信

采用wait()阻塞线程和notify()notifyAll()唤醒线程的方式来达到线程交替执行的目的

package com.multithread.java;/*
@author LiRui
@create 2021-10-27 10:01
*/

class MThread implements Runnable{
    private int number=1;

    @Override
    public void run() {
        synchronized (this){
            while (true){
                notify();
                if(number<101){
                System.out.println(Thread.currentThread().getName()+":"+number);
                number++;
                }else{
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) {
        MThread p = new MThread();
        Thread t1= new Thread(p);
        Thread t2= new Thread(p);
        t1.start();
        t2.start();
    }
}

生产者消费者问题

两个线程都用来执行 同一个共享内存的操作来取出和放入变量。

package com.multithread.java;/*
@author LiRui
@create 2021-10-27 19:55
*/

 class Foot{
    private int foot=0;//食物为0
     public synchronized void produceFoot(){
         if(foot<20){
             foot++;
             System.out.println(Thread.currentThread().getName()+":开始生产第"+foot+"个食物");
             notify();
         }else{
             try {
                 wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

     public synchronized void comsumeFoot(){
         if(foot>0){
             System.out.println(Thread.currentThread().getName()+":开始消费第"+foot+"个食物");
             foot--;
             notify();
         }else{
             try {
                 wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
}

class Comsumer extends Thread{
     private Foot f;

     public Comsumer(Foot f){
         this.f=f;
     }

    @Override
    public void run() {
        while (true){
            f.comsumeFoot();
        }
    }
}
class Producer extends Thread{
    private Foot f;

    public Producer(Foot f){
        this.f=f;
    }

    @Override
    public void run() {
        while (true){
            f.produceFoot();
        }
    }
}
public class PCTest {
    public static void main(String[] args) {
        Foot f = new Foot();
        Producer producer = new Producer(f);
        Comsumer comsumer = new Comsumer(f);
        producer.start();
        comsumer.start();
    }
}

JDK5.0新增的线程创建方式 2种

新增方式1：实现Callable接口

在这里插入图片描述

package com.multithread.java;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
@author LiRui
@create 2021-10-28 9:47
*/

class NumThread implements Callable {
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i < 101; i++) {
            if (i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }
}

public class ThreadTestNew {
    public static void main(String[] args){
        NumThread numThread=new NumThread();
        FutureTask fur=new FutureTask(numThread);
        Thread t1=new Thread(fur);
        t1.start();
        try {
            Object sum = fur.get();
            System.out.println(sum);
        }catch (InterruptedException e){
            e.printStackTrace();
        }catch (ExecutionException e){
            e.printStackTrace();
        }

    }

}

新增方式2：使用线程池

在这里插入图片描述
在这里插入图片描述

package com.multithread.java;/*
@author LiRui
@create 2021-10-28 15:23
*/

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 10; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //提供指定线程数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //设置线程属性
        //ThreadPoolExecutor service=(ThreadPoolExecutor)executorService;
        //service.setCorePoolSize(15);
        //service.setKeepAliveTime();
        //执行指定线程的操作。需要实现Runnable或者Callable接口
        executorService.execute(new NumberThread());//适用于Runnable
        executorService.execute(new NumberThread1());//适用于Runnable
        //executorService.submit();//适用于Callable
        executorService.shutdown();
    }
}

面试题：创建多线程有几种方式 4种

继承Thread类，实现Runnable接口, JDK 5.0 jdk 1.5.0 后：实现Callable接口，使用线程池

吾心即宇宙-THU
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day01-java基础语法.pdf
06-09
Java是一门面向对象编程...Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 [2] 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等 [3] 。
Java多线程
知否技术的博客
04-22 178
进程：一个进程包含多个线程 我们可以把一个程序分成多个代码块，每个代码块交给一个线程去执行。 线程创建： 创建一个Thread类，或者一个Thread子类的对象 创建一个实现Runnable接口的类的对象 线程的状态 • 新建（New） • 可运行（Runnable） • 正在运行（Running） • 阻塞（Blocked） • 终止（Dead） 线程的运行是随机的 ...
学习Java的多线程笔记
pdx77的博客
10-06 81
线程与进程 进程： 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间 线程： 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程 最少有一个线程 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程 同步与异步 同步:排队执行 , 效率低但是安全 异步:同时执行 , 效率高但是数据不安全 并发与并行 并发：指两个或多个事件在同一...
Java进阶DAY31-01-什么是多线程
tang7mj的博客
03-14 377
多线程是现代编程中不可或缺的一部分，特别是在开发需要高性能和高响应性的应用程序时。Java提供的多线程机制强大而灵活，能够帮助开发者有效地管理和控制线程的行为。然而，正确使用多线程也需要对线程同步、死锁等潜在问题有深入的理解。在未来的博客中，我们将继续深入探讨如何在Java中高效地使用多线程，以及如何解决多线程编程中的常见问题。欢迎大家继续关注和学习。
Java多线程编程
chenmi123321的博客
10-19 960
java
最新Java基础系列课程--Day14-多线程编程
znzbs的博客
09-19 7654
多线程(Multithread)是指在同一个程序中同时存在几个执行体，按几条不同的执行路径共同工作的情况
java学习文档（快速学习-非常使用）
05-17
Day1 一、 从面向过程编程到面向对象编程的思维转变 二、 什么是字节码和虚拟机： 三、 环境变量的设置 四、 kate工具的使用 五、 我们的第一个Java...《多线程》 Day12 一．I/O 流（java 如何实现与外界数据的交流）
python多线程DAY05.txt
04-27
多进程/多线程并发 ： 任何任务 3. 基于fork的多进程并发程序 每当有一个客户端连接就创建一个新的进程 4. ftp文件服务程序 *********************************************** 多线程并发 threading 的多...
达内Java培训-CoreJava全程笔记（WORD唐亮版）
07-20
CoreJava DAY01 Java概述 1 CoreJava DAY02 数据类型和控制结构 6 CoreJava DAY03 数组 11 CoreJava DAY04 15 ...CoreJava DAY19-20 多线程 85 CoreJava DAY21-22 IO 95 CoreJava DAY23 网络编程 107
python多线程DAY01.txt
04-27
3.多任务编程 * 并行 和 并发 * 进程 线程 4. 多进程编程 时间片 PCB PID 父子进程 优先级 进程特征 进程状态： 就绪态 运行态 等待态 5. ps -aux ps -ajx pstree top nice 6. os.fork() 7. os.getpid() os....
jdk8新特性----Lambda表达式
w_t_y_y的博客
05-11 440
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
jar包增量更新分析
junlaiyan的专栏
05-16 136
借助jdeps分析出jar包的增量文件
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 519
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 202
java导出excel动态加载多sheet多复杂表头
Android Model引入其他aar包 导致无法打包成aar
最新发布
qq_27400335的博客
05-16 236
Android Model引入其他aar包 导致无法打包成aar
java中实现缓存的几种方式
shenxiaomo1688的博客
05-16 511
Redis 是C语言开发的一个开源高性能键值对的内存数据库，可以用来做数据库、缓存、消息中间件等场景，是一种NoSQL(not-only sql,非关系型数据库)的数据库。下面我们介绍在springboot项目中的使用springboot中有redis的starter我们直接引用即可然后在spring配置文件中加入如下设置，这里用的是properties形式的文件，host是部署redis的服务器ip，port是端口号，password是密码，如果没有设置密码不填即可同样我们编写接口测试。
设计模式-责任链模式
weixin_43880576的博客
05-11 994
责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
brupsuite各版本专业破解安装
weixin_51520483的博客
05-11 198
最新brupsuite专业版安装，全套安装软件+环境，附带安装包教程
Spring Cloud 概述及项目创建
qq_66292058的博客
05-13 720
在介绍什么是微服务之前，我们先来了解一下什么集群和分布式的概念。Spring Cloud是微服务架构的一站式解决方案，它对一系列用来实现微服务或解决微服务带来的问题的组件进行了整合，例如实现负载均衡，服务调用和服务发现，分布式版本配置 ，断路器，分布式消息等功能的组件，并将这些组件按照Spring Cloud的规范进行管理。Spring Cloud并不自己实现这些组件，而是对其进行管理，并提供给用户进行使用。
springmvc 音频流输出_Java高级框架 - SpringMVC学习(02) Day08
05-26
```java @RequestMapping("/audio") @ResponseBody public ResponseEntity[]> getAudio() throws IOException { // 读取音频文件字节数组 InputStream in = getClass().getResourceAsStream("/static/audio/sample...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值