JAVAEE细细看 进阶 15 - 多线程

最新推荐文章于 2024-09-21 10:38:43 发布
最新推荐文章于 2024-09-21 10:38:43 发布
阅读量260 收藏
点赞数 1
分类专栏： 多线程 Thread 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZMW_IOS/article/details/103771014
版权

多线程

一. 进程

是正在运行的程序

  1. 是系统进行资源分配和调用的独立单位；
  2. 每个进程都有它自己的内存空间和系统资源
二. 线程

是进程中的耽搁顺序控制流，是一条执行路径
1.一个进程如果只有一条执行路径，则成为单线程程序
2.多线程，一个进程如果有多条执行路径，则成为多线程程序

多线程的实现方式

  • 方式1
  1. 定义一个类，继承于Thread类
  2. 在这个类中重写run()方法
  3. 创建类对象
  4. 启动线程

两个小问题

  1. 为什么要重写run()方法？
    因为run() 方法是为了封装被线程执行的代码
  2. run()和strart()的区别
    前者封装线程执行代码，直接调用，相当于普通方法的调用；后者启动线程，然后由JVM调用此线程的run()方法

设置和获取线程名称

  • setName()
  • getName()
  • currentThread().getName() 获取当前线程的名称
	 /*
        设置线程名称
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

        my1.setName("飞机");
        my2.setName("高铁");
        */

        /*
        带参数的设置线程名称
        MyThread my1 = new MyThread("飞机");
        MyThread my2 = new MyThread("高铁");
        */

//      my1.start();
//	my2.start();

        // 获取当前线程的名称  System.out.println(Thread.currentThread().getName());  // main
三. 线程调度

线程优先级高，仅仅表示它获取CPU时间片相对多一些，并不表示它一定最先执行，是概率事件。

线程的调度模型

  1. 分时调度模型：所有线程轮有使用CPU的使用权，平均分配每个线程占用CPU的时间片。
  2. 抢占式调度模型：优先让优先级高的线程使用CPU，如果优先级相同，那么会随机选择一个。优先级高的获取的CPU时间片相对多一些。
    Java使用的是抢占式的调度模型

Thread类设置和获取线程优先级的方法

  • getPriority() int
  • setPriority(int newPriority)
    Thread.MAX_PRIORITY 最大10
    Thread.MIN_PRIORITY 最小1
    Thread.NORM_PRIORITY 默认值5
    优先级高不一定在最前面，只是获取CPU时间片相对多一些
ThreadPriority tp1 = new ThreadPriority();
ThreadPriority tp2 = new ThreadPriority();
ThreadPriority tp3 = new ThreadPriority();

tp1.setName("高铁");
tp2.setName("飞机");
tp3.setName("汽车");

// 获取优先级
System.out.println(tp1.getPriority());  // 5
System.out.println(tp2.getPriority());  // 5
System.out.println(tp3.getPriority());  // 5
System.out.println("--------");

// 查看优先级的区间
System.out.println(Thread.MAX_PRIORITY);  // 10
System.out.println(Thread.MIN_PRIORITY);  // 1
System.out.println(Thread.NORM_PRIORITY); // 5

// 设置优先级
tp1.setPriority(10);
tp2.setPriority(1);
tp3.setPriority(6);

// 运行
tp1.start();
tp2.start();
tp3.start();
四. 线程控制
  • sleep(long) 暂停
  • join() 这个线程结束，才能向下执行
  • setDaemon(boolean) 当运行的程序只剩下守护线程时，Java虚拟机也将退出，比如垃圾回收机制就是守护线程；
    a. 当java虚拟机中没有非守护线程在运行的时候，java虚拟机会关闭。
    b. 当所有常规线程运行完毕以后，守护线程不管运行到哪里，虚拟机都会退出运行。
    c. 所以你的守护线程最好不要写一些会影响程序的业务逻辑。否则无法预料程序到底 会出现什么问题
五. 线程的生命周期

在这里插入图片描述

方式二
实现Runnable

  1. 定义一个了类，实现Runnable接口
  2. 在类中重写run() 方法
  3. 创建类对象
  4. 创建Thread类对象，把类对象作为构造方法的参数
  5. 启动线程
    两种方式小结：
    方案：
  6. 继承Thread类
  7. 实现Runnable接口

相比于继承Thread类，实现Runnable接口的好处

  1. 避免了Java单继承的局限性
  2. 避免多个相同的程序代码去处理同一个资源，把线程和程序的代码，数据有效分离，较好的体现了面向对象的设计思想

案例

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

public class SellTicket implements Runnable {

    private int tickets = 100;

    @Override
    public void run() {
        int k = 110;

        while (k >= 0) {
            if (tickets >= 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 卖了票，目前剩票" + tickets--);
            } else {
                System.out.println("票已经卖光了");
            }
            k --;
        }
    }
}

测试类
// 创建卖票对象
SellTicket sellTicket = new SellTicket();

// 创建线程
Thread th1 = new Thread(sellTicket,"窗口1");
Thread th2 = new Thread(sellTicket,"窗口2");
Thread th3 = new Thread(sellTicket,"窗口3");

// 时间到，开始售票
th1.start();
th2.start();
th3.start();

但是测试出来会出现bug

六. 同步代码块

synchronized(任意对象){}
改进上面代码如下

public class SellTicket implements Runnable {

    private int tickets = 100;
    private int runTimes = 110;
    private Object obj = new Object();

    @Override
    public void run() {

        while (runTimes >= 0) {
            synchronized (obj) {
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 卖了票，目前剩票" + tickets--);
                } else {
                    System.out.println("票已经卖光了");
                }
                runTimes--;
            }
        }
    }
}

同步代码块的优缺点

优点：解决了多线程的数据安全问题。
缺点：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

七. 同步方法

把synchronized 加到方法上
格式：

  • 修饰符 synchronized 返回值类型 方法名(){}
    同步方法的锁对象是： this
八. 同步静态方法

格式

  • 修饰符 static synchronized 返回值类型 方法名(){}
    同步静态方法的锁对象是：类名.class
private static int tickets = 100;
private Object obj = new Object();

@Override
public void run() {
    while (true) {

        // 同步方法锁
        sellTickets();
        
        // 同步静态方法锁
        sellTickets_class();
    }
}

// 同步方法锁，锁对象是 this
private synchronized void sellTickets() {
    if (tickets > 0) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
        tickets--;
    }
}

// 同步今天方法锁的锁对象是 SellTicket.class
private static synchronized void sellTickets_class() {
    if (tickets > 0) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
        tickets--;
    }
}
九. 线程安全的类

在这里插入图片描述

/*
 以下是线程安全的替代类，如果不考虑同步，还是使用StringBuilder 、ArrayList 、HashMap
  */

StringBuilder sbu = new StringBuilder();
StringBuffer sbf = new StringBuffer();

ArrayList<String> arr = new ArrayList<>();
Vector<String> ve = new Vector<>();

HashMap<String, String> map = new HashMap<>();
Hashtable<String, String> table = new Hashtable<>();

/*
 但是数组和map的依然被替代了，替代的是Collections
 */

List<String> strings = Collections.synchronizedList(arr);
Set<Object> objects = Collections.synchronizedSet(new HashSet<>());
Map<String, String> map1 = Collections.synchronizedMap(map);

JDK5之后提供了新的锁对象 Lock

十. Lock

它是一个接口，所有要用他的实现类ReentrantLock的实例

  • lock() 加锁
  • unlock() 释放锁
private int tickets = 100;
private Lock lock = new ReentrantLock();

@Override
public void run() {
    while (true) {
        try {
            lock.lock();
            if (tickets > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                tickets--;
            }
        } finally {
            lock.unlock();
        }
    }
}
十一. 线程等待

为了体现java生产者和消费者，在生产和消费过程中的等待和唤醒，在Object类中有等待和唤醒的方法

  • wait() 导致当前线程等待，直到另一个线程调用该对象的notify() 或者notifyAll()
  • notify() 唤醒单个线程
  • notifyAll() 唤醒正在等待监视器中的的所有线程

特殊的错误 IllegalMonitorStateException
在线程中调用wait方法的时候 要用synchronized锁住对象，确保代码段不会被多个线程调用

案例
送奶工人送牛奶到奶箱中，程序员从奶箱中拿牛奶，要求：工人送一瓶，程序员取一瓶，用多线程实现；

生产者消费者案例中包含的类：
    1:奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
    2:生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作
    3:消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作
    4:测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下
        A:创建奶箱对象，这是共享数据区域
        B:创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        C:创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
        D:创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        E:启动线程

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

        // 创建盒子对象
        Box box = new Box();

        // 创建生产者和消费者，因为他们都对盒子做操作，所以盒子作为参数
        Producter producter = new Producter(box);
        Consumer consumer = new Consumer(box);

        // 创建两个线程，开始存牛奶和取牛奶
        Thread t1 = new Thread(producter);
        Thread t2 = new Thread(consumer);

        // 开始
        t1.start();
        t2.start();
    }
}

public class Box {

    private int milk; // 记录第几瓶奶

    private boolean state = false; // 记录箱子中是否有奶

    // 盒子具有放入牛奶的功能
    public synchronized void put(int i){

        // 如果有奶，就等待
        if (state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 如果没奶，就放入
        this.milk = i+1;
        System.out.println("生产者放入第" + this.milk + "瓶奶");

        // 通知，其他线程，已经有奶了，可以拿了
        state = true;
        notifyAll();

    }

    // 盒子具有被拿出牛奶的功能
    public synchronized void get() {

        // 如果没有奶了，就等待
        if (!state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 如果有奶，就取走
        System.out.println("消费者拿走第" + milk + "瓶奶");

        // 通知其他线程，可以放奶了
        state = false;
        notifyAll();
    }
}

public class Producter implements Runnable{

    private Box box;

    public Producter(Box box) {
        this.box = box;
    }

    @Override
    public void run() {
        // 放入牛奶
        for (int i = 0; i < 5; i++) {
            box.put(i);
        }
    }
}

public class Consumer implements Runnable{

    private Box box;

    public Consumer(Box box) {
      this.box = box;
    }

    // 消费者 取走牛奶
    @Override
    public void run() {
        // 因为不知道什么时候放奶，所以一直取
        while (true) {
            box.get();
        }
    }
}
十二. 总结

在这里插入图片描述

ZMW_iOS
关注
专栏目录
JavaEE进阶知识学习----多线程JUC知识学习
疾风知劲草，智者必怀仁
05-04 469
多线程基础知识 1.概述程序，进程和线程 程序：是为了完成某一特定的功能或任务，用某种语言编写的一段静态代码。 进程：是程序的一次执行过程，它自身有产生，存在和消亡的生命周期。 线程：是进程的小单元，是一个程序内部的一条执行路径。 多线程的创建和使用 创建方法一 继承Thread类，重写Run()方法 使用说明： 定义子类继承Thread类。 子类中重写Thre...
对JavaEE基础多线程基础的理解
KeJason的博客
04-12 629
掌握Executors可以创建的三种线程池的特点及使用范围. 1.1集成Thread类,重写父类run()方法 1.2实现runnable接口 1.3使用ExecutorService、Callable、Future实现有返回结果的多线程(JDK1.5以后) 多线程同步机制 在需要同步的方法的方法签名中加入synchronized的关键字. 使用synchronized块对需要进行同步代码
JAVAEE多线程
风一般的男子·小亮仔
04-04 436
线程: 原理:多线程执行时候,在栈内存中,其实每一个执行线程都有一片所属的栈内存的空间,进行方法的 压栈,和弹栈. 原理图; Thread类: 构造方法: public Thread():分配一个新的线程对象。 public Thread(String name):分配一个指定名字的新的线程对象。 ...
JavaEE开发之Spring中的多线程编程以及任务定时器详解
weixin_30651273的博客
04-05 194
上篇博客我们详细的聊了Spring中的事件的发送和监听，也就是常说的广播或者通知一类的东西，详情请移步于《JavaEE开发之Spring中的事件发送与监听以及使用@Profile进行环境切换》。本篇博客我们就聊一下Spring中的并发编程，看一下Spring中的多线程编程和任务的定时执行。下方我们就来聊一下这两方面的内容。 一、Spring中的多线程 本部分就来看一下Spring框架封装...
JAVAEE细细看 进阶 17 - 新特性：Lambda、接口的组成、方法引用
ZMW_IOS的博客
01-02 305
新特性：Lambda、接口的组成、方法引用 一 Lambda 案例 启动一个线程，在控制台输出一句话：多线程程序启动了 // 方法一 需要建一个类实现Runnable接口 Lambda lambda = new Lambda(); // 线程 Thread thread = new Thread(lambda); thread.start(); // 方法 二 改进 // 匿名内部类的方式实现...
程序员进阶必看！Java进阶书籍推荐
69小石头的博客
08-13 7339
第一部分：Java语言篇 1.《Java编程规范》 适合对象：初级、中级 介绍：这本书的作者是被誉为Java之父的James Gosling，入门者推荐阅读，对基础的讲解很不错。 2.《Java编程思想》 适合对象：初级、中级 介绍：豆瓣给出了9.1的评分，全球程序员广泛赞誉。有人说这本书不适合初学者，不过小编认为作者并没有对读者已有的知识经验有过多要求，只是要求读者需要知道基本的程序语言...
javaee-api-8.0-javadoc.jar
10-12
javaee-api-8.0-javadoc.jar，这是javaee1.8api的jar包，解压后可用javadoc2chm制作成chm帮助文档。
笔记16-JAVAEE之多线程进阶
12-17
Java 多线程进阶 - 锁策略与读写锁 在 Java 多线程编程中，锁策略和读写锁是两个非常重要的概念。本文将对 Java 多线程进阶中的锁策略和读写锁进行详细介绍。 锁策略 在多线程编程中，锁策略是一个非常重要的概念...
java在线源码-JavaEE-Unit02:JavaEE在线课程使用的源码->单元2-多线程
06-01
java在线源码JavaEE在线...JavaEE在线课程->单元2-多线程中使用的源代码。 这些类代表了 Java 中多线程的使用，如 Dimik Computing 举办的在线课程中所演示的。 随意分叉并自己尝试。 @author Mushfekur Ra​​hman ()
JavaEE课程设计-----基于SpringBoot、Maybatis实现网上书城.zip
12-29
【标题】"JavaEE课程设计-----基于SpringBoot、Mybatis实现网上书城"是一个实践项目，旨在教授学生如何使用Java企业级开发技术构建一个在线图书销售平台。该项目选择了SpringBoot和Mybatis作为主要的技术栈，这两大...
JavaEE源代码 struts2-core-2.0.11
07-09
JavaEE源代码 struts2-core-2.0.11JavaEE源代码 struts2-core-2.0.11JavaEE源代码 struts2-core-2.0.11JavaEE源代码 struts2-core-2.0.11JavaEE源代码 struts2-core-2.0.11JavaEE源代码 struts2-core-2.0.11JavaEE源...
JavaWeb 服务启动时，在后台启动加载一个线程
QQbet的专栏
10-22 845
JavaWeb 服务启动时，在后台启动加载一个线程。 目前，我所掌握的一共有两种方法，第一种是监听（Listener），第二种是配置随项目启动而启动的Servlet。 下面对这两种方法做一简单的介绍，（Mark一下，防止以后急用又忘记了）： 监听（Listener） 首先，我们创建一个监听的类，继承ServletContextListener，如下： [java] vie
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 267
Arthas sysenv（查看JVM的环境变量）
Java企业面试题3
m0_74972727的博客
09-15 909
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 187
faiss版本 faiss-v1.7.4。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 946
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
面试突击-多线程和IO专题(至尊典藏版)
人生若只初相见@的博客
09-18 1631
金九银十多线程和IO大厂面试专题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值