4.5、多线程上（持续更新中......）

最新推荐文章于 2024-11-10 08:43:33 发布
最新推荐文章于 2024-11-10 08:43:33 发布
阅读量83 收藏
点赞数
分类专栏： java 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45862336/article/details/115729050
版权
本文详细介绍了Java中的线程与进程概念，包括线程调度的分时和抢占式策略。接着讨论了同步与异步、并发与并行的区别。通过实例展示了通过继承Thread类和实现Runnable接口创建线程的方法，并讲解了Thread类常用方法。此外，还探讨了线程的休眠、阻塞、中断、守护线程以及线程安全问题，如同步代码块、同步方法和显式锁Lock的使用，以解决线程安全问题。
摘要由CSDN通过智能技术生成

4.5、多线程上

1）线程与进程

进程：
	是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。
线程：
	是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行。一个进程最少有一个线程。
	线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。

线程调度：
	1.分时调度
		所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
	2.抢占式调度
		2.1、优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
		2.2、CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

2）同步与异步&并发与并行

同步：排队执行，效率低但是安全。
异步：同时执行，效率高但是数据不安全。

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

3）继承Thread

简单案列：

public class Demo {
    public static void main(String[] args) {
        // 开启一个任务
        MyThread m = new MyThread();
        m.start();
        // thread主线程
        for (int i = 0; i < 10; i++) {
            System.out.println("defdef" + i);
        }
    }
}

class MyThread extends Thread {
    /**
     * run方法就是线程要执行的任务方法
     */
    @Override
    public void run() {
        /**
         * 这里的代码，就是一条新的执行路径。
         * 这个执行路径的触发方式，不是调用run方法，而是通过Thread对象的start()来启动任务。
         */
        for (int i = 0; i < 10; i++) {
            System.out.println("abcabcabc" + i);
        }
    }
}

匿名内部类案列：

public class Demo {
    public static void main(String[] args) {
        // 只打算调用一次Start()
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("abcabcabc" + i);
                }
            }
        }.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("defdef" + i);
        }
    }
}

两条线程执行的时序图：

在这里插入图片描述

4）实现Runnable

public class RunDemo {
    /**
     * 实现Runnable 与Thread相比有如下优势：
     * 1.  通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程同时执行相同任务的情况。
     * 2.  可以避免单继承所带来的局限性。
     * 3.  任务与线程本身是分离的，提高了程序的健壮性。
     * 4.  后续学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程。
     *
     * @param args
     */
    public static void main(String[] args) {
        // 实现Runnable
        // 1.   创建一个任务对象
        MyRunnable r = new MyRunnable();
        //2.    创建一个线程，并为其分配一个任务
        Thread t = new Thread(r);
        //3.    执行这个线程
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("defdef" + i);
        }
    }
}

/**
 * 用于给线程进行执行的任务
 */
class MyRunnable implements Runnable {

    @Override
    public void run() {
        // 线程的任务
        for (int i = 0; i < 10; i++) {
            System.out.println("abcabcabc" + i);
        }
    }
}

5）Thread类

常用方法：

变量和类型方法描述
longgetId()返回此Thread的标识符。
StringgetName()返回此线程的名称。
intgetPriority()返回此线程的优先级。
voidsetPriority(int newPriority)更改此线程的优先级。
voidstart()导致此线程开始执行；Java虚拟机调用此线程的run方法。
voidsetDaemon(boolean on)将此线程标记为 daemon线程或用户线程。
static voidsleep(long millis)导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。

6）设置和获取线程名称

public class RunDemo {

    public static void main(String[] args) {
        // 1.如何获取线程的名称
        // main线程
        System.out.println(Thread.currentThread().getName());

        // Thread-0 Thread-1 ...Thread-n线程
        new Thread(new MyRunnable()).start();
        new Thread(new MyRunnable()).start();

        // 2.如何设置线程的名称
        // 直接传入线程名称
        new Thread(new MyRunnable(), "线程1").start();

    }

    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

7）线程休眠sleep

public class RunDemo {

    public static void main(String[] args) throws InterruptedException {
        // 线程的休眠 sleep
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            // 每输出一次休眠 1秒钟
            Thread.sleep(1000);
        }
    }
}

8）线程阻塞

所有消耗时间的操作称之为阻塞。比如说文件读取...

9）线程的中断

public class RunDemo {

    public static void main(String[] args) {
        // 线程的中断
        // 一个线程是一个独立的执行路径，它是否应该结束，应该由其自身决定
        Thread t1 = new Thread(new MyRunnable());
        t1.start();

        // 主线程
        for (int i = 0; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            // 每输出一次休眠 1秒钟
            try {
                // 子不能声明比父更大的异常，所以这里只能 try-catch
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 给线程 t1添加中断标记
        t1.interrupt();
    }

    static class MyRunnable implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                // 每输出一次休眠 1秒钟
                try {
                    // 子不能声明比父更大的异常，所以这里只能 try-catch
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    System.out.println("发现了中断标记，我们这个线程自杀");
                    return;
                }
            }

        }
    }
}

10）守护线程

public class RunDemo {

    public static void main(String[] args) {
        /**
         * 线程：分为守护线程和用户线程。
         * 用户线程：当一个进程不包含任何的存活的用户线程时，进行结束。
         * 守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。
         */
        Thread t1 = new Thread(new MyRunnable());
        // 设置 t1为守护线程
        t1.setDaemon(true);
        t1.start();

        // 主线程
        for (int i = 0; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class MyRunnable implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

11）线程安全问题

public class Demo {

    public static void main(String[] args) {
        // 线程不安全
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable {
        // 票数
        private int count = 10;

        @Override
        public void run() {
            while (count > 0) {
                // 卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票成功，余票:" + count);
            }
        }
    }
}

结果卖票出现了负数，超卖现象，不合理。

在这里插入图片描述

12）线程安全1-同步代码块

public class Demo {

    public static void main(String[] args) {
        
        /**
         * 线程不安全
         * 解决方案1.同步代码块 ->看守同一把锁
         * 格式：synchronized(锁对象){
         *
         *      }
         */
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable {
        // 票数
        private int count = 10;
        private Object o = new Object();

        @Override
        public void run() {	// A B C
            while (true) {
                // 看同一把锁
                synchronized (o) {
                    if (count > 0) {
                        // 卖票
                        System.out.println("正在准备卖票...");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName() + "出票成功，余票:" + count);
                    } else {
                        break;
                    }
                }
            }
        }
    }
}

运行结果：

在这里插入图片描述

13）线程安全2-同步方法

public class Demo {

    public static void main(String[] args) {
        /**
         * 线程不安全
         * 解决方案2.同步方法 ->看守同一把锁
         * 格式：synchronized修饰方法
         */
        Runnable run = new Ticket();
        // 同一个 run对象
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable {
        // 票数
        private int count = 10;

        @Override
        public void run() {
            while (true) {
                // 看同一把锁
                boolean flag = sale();
                if (!flag) {
                    break;
                }
            }
        }

        // 不是静态修饰的同步方法，这个锁就是 this 
        public synchronized boolean sale() {
            if (count > 0) {
                // 卖票
                System.out.println("正在准备卖票...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName() + "出票成功，余票:" + count);
                return true;
            }
            return false;
        }
    }
}

14）线程安全3-显式锁Lock

public class Demo {

    public static void main(String[] args) {
        /**
         * 线程不安全
         * 同步代码块和同步方法都属于隐式锁
         * 解决方案3.显式锁 Lock 子类 ReentrantLock
         * 格式：
         */
        Runnable run = new Ticket();
        // 同一个 run对象
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable {
        // 票数
        private int count = 10;
        // 显式锁 l
        private Lock l = new ReentrantLock();

        @Override
        public void run() {
            while (true) {
                // 上锁
                l.lock();
                if (count > 0) {
                    // 卖票
                    System.out.println("正在准备卖票...");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName() + "出票成功，余票:" + count);
                } else {
                    break;
                }
                // 开锁
                l.unlock();
            }
        }

    }
}
liangqlai
关注
专栏目录
Node.js 命令行实战：从入门到精通
技术探秘者的博客
03-21 1128
Node.js是一个功能强大的JavaScript运行环境，可以用于开发各种类型的应用程序。通过学习和掌握Node.js命令行工具和最佳实践，您可以提高开发效率和代码质量，构建更好的Node.js应用程序。
多线程执行job任务 线程池
每天记录一点点，20181220回头看看是什么样
10-19 2490
先占个坑，后面补齐 本文主要介绍我们项目在晚上定时执行 job 的时候，由于数据量多，为缩短 job 的执行时间，采用线程池，多线程执行 job 的情况。 先看 job 任务的代码，我只保留了主要的： import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; imp
LODOP打印控件实现设计并且代码生成
Little Luck
11-09 7115
1. Lodop官方下载web打印控件，然后安装。官方下载地址：http://www.lodop.net/download.html2. 使用打印设计模式进行设计，其中有个按钮可以生成...
LODOP获取打印状态码和时间列表
weixin_30609331的博客
09-05 629
之前有博文介绍获取打印状态码和打印状态码的含义，相关博文：LODOP获取打印机状态码和状态码含义测试、此外 ，也有获取状态码及其变化的方法，可以获取打印状态码的列表，列表包含每个状态和每个状态的时间。方法和获取打印状态码含义的其中一种方法一样，都是LODOP.GET_VALUE方法，就是参数不同，获取打印状态码含义是PRINT_STATUS_TEXT，获取打印状态的列表是PRINT_ST...
精通C#5.0与.net4.5高级编程.
03-19
- 基于任务的并发（Task Parallel Library, TPL）：C#5.0进一步强化了对多线程和并行处理的支持，使开发者能够更容易地利用多核处理器的优势。 - 动态类型：动态类型允许在运行时确定变量的类型，增强了语言的灵活...
2020易语言模块大全持续更新1.zip
07-02
ZCL_多线程类1.01.ec ZCL_控件类库1.01.ec ZCL_文件读写1.01.ec ZCL_核库函数1.01.ec zip.ec zip压缩.ec zyJson.ec [YY][IS]查找模块.ec _易语言皮肤模块.EC 代码编辑器部分模块.ec 传世注册.ec 保存图片(1.0).EC ...
【4-5】多线程
weixin_41457862的博客
09-12 95
多线程 概念 进程与线程 进程（应用程序） 线程（执行路径） 多线程：一个进程的程序中开辟多个执行路劲，共享一个内存，自由切换，并发执行； 一个进程最少有一个线程 线程调度 CPU的分配机制： 分时调度：平均分配每个线程占用 CPU 的时间，更合理地交替执行； 抢占式调度（Java）：优先让优先级高的线程使用 CPU； 多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使 用率更高 同步与异步 同步:排队执行 , 效率低但是安全. 异步:同时执行 , 效率高但
MySQL-NET4.0&4.5&4.5.2-DLL.zip
06-13
10. **最新版本**：虽然这里包含的是较旧的版本，但MySQL Connector/NET会持续更新，最新的版本可能包含更多的优化和功能。因此，建议定期检查Oracle官方网站获取最新版本，以充分利用MySQL的最新特性。 以上就是...
多线程（持续更新）
kfdbes
08-01 323
【代码】多线程（持续更新）
多线程(更新中)
每天一点点
05-18 224
本文内容为读书笔记，强烈推荐《java高并发核心编程-卷2》这本书 书作者博客地址：https://www.cnblogs.com/crazymakercircle/p 1. 进程/线程 2. 并发/并行 3. 创建线程的四种方法 4. 线程原理理解 5. 线程的基本操作 6. 线程池 7. 线程数如何设定 8. ThreadLocal 9. 什么是线程安全 10. synchronized 11. 线程中的锁 12....
JAVA-01-变量
LJH_laura_li的博客
11-08 442
在方法、构造函数或块内部定义的变量。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 1069
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 664
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 338
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
在 C# 中，如何实现观察者模式？
Leo的博客
11-06 508
观察者模式是一种设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当该主题对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。这个模式常用于事件处理系统、通知系统等场景。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 1008
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
ArkTS--应用状态
最新发布
qq_63946637的博客
11-10 542
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
greendao使用封装
白高林的专栏
11-07 452
greenDAO
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值