java基础-多线程

已于 2022-06-11 16:32:32 修改
阅读量60 收藏
点赞数
分类专栏： java 文章标签： java
于 2022-06-11 14:48:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48865614/article/details/125234631
版权

文章目录

多线程

程序：死的静态的功能的集合
进程：当程序运行起来就会开辟一个进程，多次运行程序会开辟多个进程
线程：一个进程内可以存在多条线程至少有一个线程
并行：多核CPU处理多个任务，多个任务同时进行
并发：单核cpu为例：貌似是一起执行，实际是在不停切换

如何编写多线程程序

继承Thread类

采用继承的方式创建多线程
    1.创建一个类继承Thread类
	2.重写run()方法
	3.启动线程：创建线程对象，使用线程对象调用start()方法来完成启动
Thread.currentThread().setName();设置当前线程名字
Thread.currentThread().getName();获取当前线程名字

public class Test {
    public static void main(String[] args) {
        //创建兔子线程
        RabbitThread rabbitThread = new RabbitThread();
        rabbitThread.setName("小兔子");//设置兔子线程名字
        rabbitThread.start();

        Thread.currentThread().setName("小乌龟");//设置当前线程名字

        while (true){
            System.out.println(Thread.currentThread().getName()+"跑");
        }
    }
}
class RabbitThread extends Thread{
    @Override
    public void run() {
        while (true){
            System.out.println(Thread.currentThread().getName()+"跑");
        }
    }
}

实现Runnable接口

实现的方式创建多线程
1.创建一个类实现Runnable接口
2.重写run()方法
3.创建Runnable对象
4.创建Thread类，将Runnable对象作为参数进行传递
5.调用start()方法启动线程

继承的方式与实现的方式做对比
1.继承的方式简单
2.实现的方式可以更好地实现资源共享

public class Test {
    public static void main(String[] args) {
        //创建Runnable对象
        RabbitRunnable rabbitThread = new RabbitRunnable();
        //创建Thread类，将Runnable对象作为参数进行传递
        Thread thread = new Thread(rabbitThread);
        thread.setName("小兔子");//设置兔子线程名字
        thread.start();//开启线程

        Thread.currentThread().setName("小乌龟");//设置当前线程名字

        while (true){
            System.out.println(Thread.currentThread().getName()+"跑");
        }
    }
}
class RabbitRunnable implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println(Thread.currentThread().getName()+"跑");
        }
    }
}

可以采用匿名内部类的方式实现多线程

//创建了匿名子类对象
Thread t1 = new Thread( ) {
	@Override
	public void run() {
		while (true) {
			System.out.println("乌龟跑");
		}
	}
};
t1.start();
new Thread(new Runnable() {//创建了一个Runnable的匿名子类对象
	@Override
	public void run() {
		while (true) {
			System.out.println("兔子跑");
		}
	}
}).start();

采用构造器的方式实现多线程

public class TestThreadConstructor {
    public static void main(String[] args) {

        /*RabbitThread r1 = new RabbitThread("灰兔子");
        RabbitThread r2 = new RabbitThread("白兔子");
        r1.start();
        r2.start();*/

        TortoiseRunnable tortoiseRunnable = new TortoiseRunnable();
        Thread thread = new Thread(tortoiseRunnable);
        thread.setName("小乌龟");
        thread.start();
        Thread thread1 = new Thread(tortoiseRunnable,"忍者神龟");
        thread1.start();
    }
}
class RabbitThread extends Thread{

    public RabbitThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (true){
            System.out.println(this.getName()+"跑");
        }
    }
}
class TortoiseRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {

            System.out.println(Thread.currentThread().getName()+"跑");
        }
    }
}

常用方法

1.isAlive()：判断当前线程是否处在活跃状态
2.setPriority(优先级)：1<=优先级<=10
	如果没有指定优先级，默认都是5
	优先级特别低也会有执行的机会
	先去执行优先级高的再去执行优先级低的
3.Thread.sleep(数字);：让当前线程睡眠一段时间（让当前线程进入阻塞状态）
	单位是ms
4.join()：强行插队，插队的线程调用join()方法，被插队的线程要进行等待，等插队的线程执行完毕后才能继续执行
join(2000)：强行插队，插队的线程调用join()方法，被插队的线程要进行等待2000ms，等插队的线程执行完毕后或者时间已到，才能继续执行
5.yield();：线程的礼让（特别不明显）
	将线程从运行状态转为就绪状态
6.stop()：结束当前线程
7.setDaemon(true)：守护线程
	哪一个线程调用了该方法就是守护线程
8.volatile：保证线程间的数据的可见性

实现Callable接口

线程池

线程安全

  1. 线程安全问题：当多个线程操作共享数据时，有可能会发生线程安全问题
  2. 解决线程安全问题
  3. 注意： 局部变量不能作为共享资源

同步代码块

语法结构
synchronized(同步监视对象){
]
同步监视对象：
1.必须是引用数据类型
2.当多条线程操作共享数据，同步监视对象，必须是同一个
3.同步代码块意义：保证在同步代码块内只要一条线程在执行，其他线程需要在同步代码块外等待
4.当一条线程进入同步代码块内，那么其他线程不能进入拥有同一个同步监视器对象的同步代码块

同步方法

同步方法的同步监视器是this
当有一条线程进入同步方法，那么其他线程不仅不能进入此方法，也不能进入拥有同一个人同步监视器对象的同步方法

public class Test {
    public static void main(String[] args) {
        WindowRunnable windowRunnable = new WindowRunnable();
        Thread t1 = new Thread(windowRunnable,"窗口一");
        Thread t2 = new Thread(windowRunnable,"窗口二");
        Thread t3 = new Thread(windowRunnable,"窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}
class WindowRunnable implements Runnable{

    int count = 60;

    @Override
    public void run() {

        while (true){
            if (count <= 0){
                break;
            }
            saleTicket();
        }
    }

    private synchronized void saleTicket() {
        if (count<=0){
            return;
        }
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"卖了第"+count+"张票");
        count--;
    }
}

Lock：公平锁和非公平锁

单例模式

一种代码模板
单例模式：包装产生的对象是唯一的，无论产生多少个对象，都是唯一的
单例模式分为两种：
1. 饿汉式：一开始创建类的时候，就把此对象创建出来
2. 懒汉式：等到需要的时候，再次创建出来
懒汉式可能出现线程安全问题

public class Test {
    public static void main(String[] args) {
        HungerSingle i1 = HungerSingle.INSTANCE;
        HungerSingle i2 = HungerSingle.INSTANCE;
        System.out.println(i2==i1);//true

        HungerSingle1 i3 = HungerSingle1.INSTANCE;
        HungerSingle1 i4 = HungerSingle1.INSTANCE;
        System.out.println(i3==i4);//true

        LazySingle i5 = LazySingle.getInstance();
        LazySingle i6 = LazySingle.getInstance();
        System.out.println(i5 == i6);//true
    }
}
class HungerSingle{
    public static final HungerSingle INSTANCE = new HungerSingle();
    private HungerSingle() {
    }
}
enum HungerSingle1{
    INSTANCE
}
class LazySingle{
    private static LazySingle lazySingle;
    private LazySingle(){

    }
    public static synchronized LazySingle getInstance(){
        if (lazySingle == null) {
            synchronized (Test.class){
                if (lazySingle == null) {
                    lazySingle = new LazySingle();
                }
            }
        }
        return lazySingle;
    }
}

等待唤醒机制

线程通信：

  1. wait()：进行等待
  2. wait(时间)：
  3. notify：通知；如果有多个线程等待，则随机通知一个线程
  4. notifyAll()：通知所有等待的线程干活
线程通信使用同步代码块实现
/*
    一个吧台 一个厨师 一个服务员
    吧台最多放10份菜
    厨师已经做了10道菜则进行等待，通知服务员上菜
    服务员上菜，当服务员把所有的菜都上完了，服务员等待，通知厨师做菜

    问题1：厨师和服务员使用两个吧台
    解决：将吧台声明到Test类中

    问题2：厨师还没做菜，服务员已经开始上菜
    解决：保证线程安全，使用同步代码块

    问题3.厨师做的菜已经超出了吧台的能力，服务员端的菜是负数（无）
    解决：当吧台的菜已经<0时，服务员等待；当吧台的菜>0时，厨师等待
    
    wait()释放锁
*/
public class Test {
    public static void main(String[] args) {
        Bar bar = new Bar();
        CookThread cookThread = new CookThread(bar);
        cookThread.setName("厨师");
        WaiterThread waiterThread = new WaiterThread();
        waiterThread.setBar(bar);
        waiterThread.setName("服务员");
        cookThread.start();
        waiterThread.start();
    }
}
class  Bar{
    public static final int MAX_NUM = 10;//只能放10道菜
    int count;//记录吧台上菜的数量
}
class CookThread extends Thread{
    private Bar bar;
    public CookThread(Bar bar) {
        this.bar = bar;
    }
    @Override
    public void run() {
        while (true){
            //同步代码块 ：保证线程安全
            synchronized (bar){//同步监视器使用共享资源
                //厨师在做菜之前对数据进行校验
                if (bar.count >= Bar.MAX_NUM) {//厨师做的菜已经>=吧台能够放菜的最大份数
                    try {
                        bar.wait();//厨师等待：采用同步监视器调用
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                bar.count++;//厨师做了一道菜
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(this.getName()+"做了一道菜，现在有"+bar.count+"份菜");
                bar.notify();//通知服务员端菜
            }
        }
    }
}
class WaiterThread extends Thread{
    private Bar bar;
    public void setBar(Bar bar) {
        this.bar = bar;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (bar) {
                //在端菜之前进行校验
                if (bar.count <= 0) {
                    try {
                        bar.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                bar.count--;//服务员端走了一份菜
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(this.getName() + "端走了一道菜，还有" + bar.count + "份菜");
                bar.notify();//通知厨师做菜
            }
        }
    }
}

了解死锁

/*
    产生死锁的原因：两条线程互相持有对方的锁资源，不放松
    可以让一条线程先跑完再让另一条线程在执行
* */
public class TestDeadLock {
    public static void main(String[] args) {
        Object goods = new Object();
        Object money = new Object();
        GoodsThread goodsThread = new GoodsThread(goods, money);
        CustomerThread customerThread = new CustomerThread(goods, money);
        goodsThread.start();
        try {
            Thread.sleep(1000);// 可以让一条线程先跑完再让另一条线程在执行
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        customerThread.start();
    }
}
class GoodsThread extends Thread{
    Object goods;
    Object money;

    public GoodsThread(Object goods, Object money) {
        this.goods = goods;
        this.money = money;
    }

    @Override
    public void run() {
        synchronized (money) {
            System.out.println("先给钱");
            synchronized (goods){
                System.out.println("再发货");
            }
        }
    }
}
class CustomerThread extends Thread{
    Object goods;
    Object money;

    public CustomerThread(Object goods, Object money) {
        this.goods = goods;
        this.money = money;
    }

    @Override
    public void run() {
        synchronized (goods) {
            System.out.println("先发货");
            synchronized (money){
                System.out.println("再给钱");
            }
        }
    }
}

在这里插入图片描述

线程通信使用同步方法实现
/*
    同步方法也有同步监视器对象：this，想要实现线程安全，this必须是相同的的
    线程通信方法，必须位于同步方法或者同步代码块内
*/
public class Test1 {
    public static void main(String[] args) {
        Bar1 bar1 = new Bar1();
        CookRunnable cookRunnable = new CookRunnable(bar1);
        Thread t0 = new Thread(cookRunnable, "厨师");
        WaiterRunnable waiterRunnable = new WaiterRunnable(bar1);
        Thread t1 = new Thread(waiterRunnable, "服务员1");
        Thread t2 = new Thread(waiterRunnable, "服务员2");
        t0.start();
        t1.start();
        t2.start();

    }
}
class CookRunnable implements Runnable{
    private Bar1 bar1;

    public CookRunnable(Bar1 bar1) {
        this.bar1 = bar1;
    }

    @Override
    public void run() {
        while (true){
            bar1.Put();
        }
    }
}
class WaiterRunnable implements Runnable{

    private Bar1 bar1;

    public WaiterRunnable(Bar1 bar1) {
        this.bar1 = bar1;
    }
    @Override
    public void run() {
        while (true){
            bar1.get();
        }
    }
}
class Bar1{
    public static final int MAX_NUM = 10;//吧台最多放10份菜
    int num;//统计菜数
    //厨师做菜
    public synchronized void Put(){
        if (num >= MAX_NUM) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"做了一道菜，现在有"+num+"道菜");
        //this.notify();
        this.notifyAll();
    }
    //服务员端菜
    public synchronized void get(){
        while (num<=0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"端走了一道菜，还有"+num+"道菜");
        this.notify();
    }
}

线程生命周期

  1. 观点1
    在这里插入图片描述
  2. 观点2
    在这里插入图片描述
I会飞的鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Thread.currentThread().getName() 和 this.getName()的区别
奥妙de~java的博客
11-12 525
Thread.currentThread().getName() 表示当前代码被哪个线程调用 this.getName() 表示当前线程(当前这个这段代码属于哪个线程里边的） 1 线程实体 2 测试类
rabbitmq多线程_Rabbitmq线程模型
weixin_26737625的博客
09-08 1770
rabbitmq多线程This article is based on some basic understanding of Rabbitmq(Queue,Consumer,Producer etc). When communicating with Rabbitmq server, a connection is required. The design of the connection i...
RabbitMq 最全的性能调优笔记
weixin_34062469的博客
09-11 8644
RabbitMq 性能调优笔记 [TOC] 避免雷区 要避免流控机制触发 服务端默认配置是当内存使用达到40%，磁盘空闲空间小于50M，即启动内存报警，磁盘报警；报警后服务端触发流控（flowcontrol）机制。 一般地，当发布端发送消息速度快于订阅端消费消息的速度时，队列中堆积了大量的消息，导致报警，就会触发流控机制。 触发流控机制...
Java基础—多线程
PassionZheng的博客
04-27 362
Java多线程一.线程的相关概念1.程序、进程、线程2.单核CPU和多核CPU的理解3.并行与并发4.单线程 & 多线程5.多线程的好处6.多线程的应用场景二.线程的创建和启动 ★1.java.lang.Thread类2.创建线程的两种方式1）继承Thread类2）实现Runnable接口3.start与run的区别4.两种创建方式的区别：窗口买票案例三.线程的停止方式四.线程的其他知识1...
Java基础---多线程
热门推荐
我是太阳
01-28 2万+
1、程序、进程、线程 2、线程的创建和使用 3、线程的生命周期 4、线程的同步 例题：模拟火车站售票程序，开启三个售票窗口 public class Ticket implements Runnable { private int tick = 100; @Override public void run() { ...
大学课程讲义-Java基础-多线程.pptx
08-14
大学课程讲义_Java基础_多线程.pptx
JAVA-多线程 所有文件
01-09
JAVA-多线程 所有文件
Java基础[06-多线程].ppt
12-09
Java线程具有五中基本状态 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread(); 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。...
Java程序基础-多线程概述.pptx
09-15
java
Java基础之多线程.md
11-10
Java多线程，Java基础，并发
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 323
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 605
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 547
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 413
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
2301_77061352的博客
06-12 840
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。
Invalid keystore format，获取安全码SHA1值出错
yfy1907的博客
06-11 200
Invalid keystore format 错误
【Hydro】SCS-CN方法中径流曲线数的确定（下）
```On Earth, Be Water, By Coding```
06-11 111
在[【Hydro】SCS-CN方法中径流曲线数的确定（上）](https://blog.csdn.net/qq_25262697/article/details/133796329)中已经介绍了SCS-CN在SWAT和HMS中的应用，以下会补充SCS-CN在XPSWMM、InfoWorks ICM中的应用。以及使用软件计算SCS-CN的步骤。
从零手写实现 nginx-20-placeholder 占位符 $
06-12 1144
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat除了内置变量，Nginx 还允许用户自定义变量。自定义变量可以在set指令中定义。在这个例子中，定义了一个自定义变量，其值为，并在响应中返回这个值。Nginx 支持占位符的主要目的是提供更高的灵活性和动态性，使其能够适应各种复杂的应用场景和需求。
eclipse插件开发中，获取一个java工程中的所有import的包名，并打印出来
liudong200618的博客
06-11 210
这段代码将遍历指定Java工程中的所有源代码文件，并打印出每个文件中的所有import语句。确保在开发Eclipse插件时，你的插件项目已经正确配置了对Eclipse JDT的依赖。
Java高级特性 - 多线程基础（3）线程同步
09-01
- *1* *3* [Java高级特性 - 多线程基础（3）线程同步](https://blog.csdn.net/weixin_52034200/article/details/130253687)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值