java基础-多线程

已于 2022-06-11 16:32:32 修改
阅读量83 收藏
点赞数
分类专栏： 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会飞的鱼
关注
专栏目录
Java多线程基础-使用多线程
cgmx551的博客
03-08 2023
线程:程序执行流的最小单元【可以理解为：进程中独立运行的子任务】。 多线程优点:最大限度的利用CPU的空闲时间来处理其他任务。 |-目录 |  创建线程 |  线程运行结果与执行顺序无关 |  线程实例变量与安全问题 |  停止线程 |  线程优先级 |  守护线程 |  线程让步 -创建线程 线程的创建方式:  1.继承Thread类 public class ThreadCreateDemo1 { public static void main(String[] args) { ...
java线程几种类型_Java线程类
cunfen6312的博客
07-30 2850
java线程几种类型 Java线程类 (Java Thread Class) Thread class is the main class on which Java's Multithreading system is based. Thread class, along with its companion interface Runnable will be used to create ...
java Thread两种简单用法总结
cy609329119的专栏
07-10 5273
方法一： 用继承Thread实现实例：package threadtest13; //多线程的写法2，用两种情况变换， //情况1：新建一个对象，两个线程共享一个对象。另外是新建两个对象，两个线程用两个对象 //情况2：int i=0；拿到run（）外面与在run（）里面两种情况。 //上面4种情况可以排列组合试一下 publicclass Thread13 {publicstaticvoid ma
java之Thread类详细分析（全）
码农研究僧的博客
08-06 2180
目录前言1. 属性值2. 常用方法 前言 Thread是程序中的执行线程 jvm并发地运行多个执行线程 1. 属性值 通过查看Thread源码，是继承Runnable接口的实现类 无论使用Runnable还是Thread，都会new Thread，然后执行run方法 通过这里也可以知道创建新执行的线程有两种方法 声明为 Thread 的子类，重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。 声明一个实现 Runnable 接口的类，实现run方法，创建对
Java Thread类主要方法详解
茹煜得氺的博客
09-13 2万+
在java中，谈到线程，必然少不了Thread类。线程是比进程更轻量级的调度执行单位。为什么用线程？通过使用线程，可以把操作系统进程的资源分配和执行调度分开，各个线程既可以共享进程资源（内存地址、文件I/O等），又可以独立调度（线程是CPU调度的基本单位）。 主流操作系统（Windows, Linux）都提供了线程的实现，Java则提供了在不同硬件和操作系统下对线程的统一处理，Thread类则是...
Java多线程（一）- 基础概念
张启明
05-13 995
Java的特点之一就是内置对多线程的支持。每个Java程序都有一个默认的主线程main。如果main方法中又创建了其他线程，那么JVM就要在主线程和其他线程之间轮流切换，保证每个线程都有机会使用CPU资源，main方法即使执行完最后的语句（主线程结束），JVM也不会结束Java应用程序，JVM一直要等到Java应用程序中的所有线程都结束之后，才会结束Java程序。线程的状态和生命周期Java中使用T
Java Thread 实现方式
time_knight的博客
05-09 8575
       关于Thread有一个比较有趣的面试题。当你new 一个Thread的时候，直接调用它的run()方法，run()会执行在哪个线程？ 答案是调用run()的线程，因为只有在调用start()之后，Java才会创建一个新的线程，然后新的线程再调用执行Java代码里面的run()。看如下代码，一个简单的实现：Thread thread = new Thread(){ public...
大学课程讲义-Java基础-多线程.pptx
08-14
Java多线程编程基础 本章节主要讲解了Java多线程编程的基础知识，包括线程的概念模型、线程的创建和启动、临界资源、对象锁、线程的互斥和同步等内容。 一、线程的概念模型 在Java中，线程是程序中单个顺序的流...
java课件-5-多线程
最新发布
01-10
总之，Java多线程编程是一个深度和广度都非常大的主题，涵盖了从基础的线程创建到复杂的并发控制策略，理解并熟练掌握这些知识对于编写高效、可靠的并发Java应用程序具有决定性的影响。通过学习提供的课件和实战练习...
JAVA-多线程 所有文件
01-09
在Java编程语言中，多线程是程序设计中的一个重要概念，尤其在开发高效能和响应迅速的应用时。这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨...
Java程序基础-多线程概述.pptx
09-15
Java程序基础中的多线程是Java编程中一个重要的概念，特别是在构建高效并发应用程序时不可或缺。在Java中，多线程允许程序同时执行多个任务，从而提高计算机系统的利用率和响应速度。 1. **线程与进程**： - **...
Object有哪些公用方法
08-23 597
首先，object 是所有类的父类，所有类默认继承 object 类。 1. clone 方法，是 object 类的 protect 方法。实现了对象的浅拷贝。有两个需要注意，第一点是如果不显式去重写 clone 方法。其他类无法直接调用该类实例的 clone 方法。第二点是，如果不实现 ...
java中thread的start()和run()的区别
wangyangkobe的专栏
08-26 2万+
<br />java中thread的start()和run()的区别：<br />1.start（）方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码：<br />通过调用Thread类的start()方法来启动一个线程，<br />这时此线程是处于就绪状态，<br />并没有运行。<br />然后通过此Thread类调用方法run()来完成其运行操作的，<br />这里方法run()称为线程体，<br />它包含了要执行的这个线程的内容，<br />Run方
Java中的Thread类
qq_774952435的博客
03-21 1万+
线程
Java 并发：Thread 类深度解析
Rico's Blogs
01-11 1万+
摘要： 　　Java 中 Thread类 的各种操作与线程的生命周期密不可分，了解线程的生命周期有助于对Thread类中的各方法的理解。一般来说，线程从最初的创建到最终的消亡，要经历创建、就绪、运行、阻塞 和 消亡 五个状态。在线程的生命周期中，上下文切换通过存储和恢复CPU状态使得其能够从中断点恢复执行。结合 线程生命周期，本文最后详细介绍了 Thread 各常用 API。特别地，在介绍会导致...
java 线程上下文类加载器 Thread ContextClassloader
xukangkang1hao的博客
08-01 2501
  https://blog.csdn.net/yangcheng33/article/details/52631940 上面这篇文章是用jdbc和tomcat说明上下文类加载器的作用。 下面的示例和jdbc加载实现类的原理类似： Father模块结构如下：   Son模块结构如下： 因为Son类要继承Father类，所以Son模块依赖Father模块，Son模块的pom.x...
JAVA线程之Thread类详解
热门推荐
MC的博客
05-30 9万+
ss
Java Thread类源码详解
有信仰的蜗牛
08-23 9529
概述 Java所有多线程的实现，均通过封装Thread类实现，所以深入Thread类，对深入理解java多线程很有必要 构造函数： Thread的构造函数，采用缺省的方式实现： //传入Runnable接口实现 Thread(Runnable target) //传入Runnable接口实现,传入线程名 Thread(Runnable target, String name...
RabbitMq 最全的性能调优笔记
weixin_34062469的博客
09-11 8825
RabbitMq 性能调优笔记 [TOC] 避免雷区 要避免流控机制触发 服务端默认配置是当内存使用达到40%，磁盘空闲空间小于50M，即启动内存报警，磁盘报警；报警后服务端触发流控（flowcontrol）机制。 一般地，当发布端发送消息速度快于订阅端消费消息的速度时，队列中堆积了大量的消息，导致报警，就会触发流控机制。 触发流控机制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值